04 Dec, 2013
1 commit
-
This patch implements the data_available() callback for the kfifo buffer instead
of using the stufftoread flag. The kfifo used by the buffer already knows
whether it is empty or not based on the position of its read and write pointer.
Using this makes it a lot easier to tell whether data is available or not and it
is not necessary to take special measures to ensure that no race conditions
between reading and writing from the buffer occur.Note, that we still have to take the buffers lock to protect against concurrent
resizeing of the kfifo.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron
16 Oct, 2013
4 commits
-
update_needed is used to decide whether the kfifo buffer needs to be
re-allocated. It is set to true whenever the size of the buffer is changed. It
is never set to false though, causing the buffer to always be re-allocated.
Setting update_needed to false after the new buffer has been allocated fixes the
problem.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron -
The kfifo's request_update callback will free the current buffer and allocate a
new one if the size has changed. This will remove any samples that might still
be left in the buffer. If the size has not changed the buffer content is
left untouched though. This is a bit inconsistent and might cause an application
to see data from a previous capture. This patch inserts a call to
kfifo_reset_out() when the size did not change. This makes sure that any pending
samples are removed from the buffer.Note, due to a different bug the buffer is currently always re-allocated, even
if the size did not change. So this patch will not change the behavior. In the
next patch the bug will be fixed and this patch makes sure that the current
behavior is kept.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron -
It is possible for userspace to concurrently access the buffer from multiple
threads or processes. To avoid corruption of the internal state of the buffer we
need to add proper locking. It is possible for multiple processes to try to read
from the buffer concurrently and it is also possible that one process causes a
buffer re-allocation while a different process still access the buffer. Both can
be fixed by protecting the calls to kfifo_to_user() and kfifo_alloc() by the
same mutex. In iio_read_first_n_kfifo() we also use kfifo_recsize() instead of
the buffers bytes_per_datum to avoid a race that can happen if bytes_per_datum
has been changed, but the buffer has not been reallocated yet.Note that all access to the buffer from within the kernel is already properly
synchronized, so there is no need for extra locking in iio_store_to_kfifo().Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron -
We need to free the kfifo when we release the buffer, otherwise the fifos memory
will be leaked.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron
12 Oct, 2013
1 commit
-
Since the buffer is accessed by userspace we can not just free the buffers
memory once we are done with it in kernel space. There might still be open file
descriptors and userspace still might be accessing the buffer. This patch adds
support for reference counting to the IIO buffers. When a buffer is created and
initialized its initial reference count is set to 1. Instead of freeing the
memory of the buffer the buffer's _free() function will drop that reference
again. But only after the last reference to the buffer has been dropped the
buffer the buffer's memory will be freed. The IIO device will take a reference
to its primary buffer. The patch adds a small helper function for this called
iio_device_attach_buffer() which will get a reference to the buffer and assign
the buffer to the IIO device. This function must be used instead of assigning
the buffer to the device by hand. The reference is only dropped once the IIO
device is freed and we can be sure that there are no more open file handles. A
reference to a buffer will also be taken whenever the buffer is active to avoid
the buffer being freed while data is still being send to it.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron
16 Sep, 2013
2 commits
-
Change the type of the 'data' parameter for iio_push_to_buffers() from 'u8 *' to
'const void *'. Drivers typically use the correct type (e.g. __be16 *) for their
data buffer. When passing the buffer to iio_push_to_buffers() it needs to be
cast to 'u8 *' for the compiler to not complain (and also having to add __force
if we want to keep sparse happy as well). Since the buffer implementation should
not care about the data layout (except the size of one sample) using a void
pointer is the correct thing to do. Also make it const as the buffer
implementations are not supposed to modify it.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron -
Use wake_up_interruptible_poll() instead of wake_up_interruptible() to only wake
up those threads that listen for input poll notifications.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron
01 Feb, 2013
1 commit
-
__iio_update_buffer updates the buffer's bytes_per_datum and length fields.
But the only user of this function just passes in these exact fields, so the
call basically looks like this:buffer->bytes_per_datum = buffer->bytes_per_datum;
buffer->length = buffer->length;Which means it is a noop and can be removed. Also remove the function itself,
since it is now unused.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron
08 Sep, 2012
1 commit
-
Drop timestamp parameter from buffer store_to callback and subsequently from
iio_push_to_buffer. The timestamp parameter is unused and it seems likely that
it will stay unused in the future, so it should be safe to remove it.Signed-off-by: Lars-Peter Clausen
Signed-off-by: Jonathan Cameron
28 Aug, 2012
3 commits
-
This buffer implementation was missing poll support.
Signed-off-by: Jonathan Cameron
Tested-by: Lars-Peter Clausen
Acked-by: srinivas pandruvada -
These two elements were originally in the patch
iio:kfifo_buf Take advantage of the fixed record size used in IIO
but Lars-Peter Clausen pointed out they should not have been
so here they are.Signed-off-by: Jonathan Cameron
Tested-by: Lars-Peter Clausen -
By bypassing the standard macros for setting up the kfifo we can
take advantage of the fixed record size implementation without
having to have a type to pass in (from which the size of an element
is normally established).In IIO we have variable 'scans' as our records in which any element
can be present or not. They do not however vary when we are
actually filling or reading from the buffer. Thus we have a fixed
record size whenever we are actually running. As setup and tear
down are not in the fast path we can take the overhead of reinitializing
the kfifo every time.Signed-off-by: Jonathan Cameron
Tested-by: Lars-Peter Clausen
26 Apr, 2012
1 commit
-
Take the core support + the kfifo buffer implentation out of
staging. Whilst we are far from done in improving this subsystem
it is now at a stage where the userspae interfaces (provided by
the core) can be considered stable.Drivers will follow over a longer time scale.
Signed-off-by: Jonathan Cameron
Signed-off-by: Greg Kroah-Hartman