From: Jonathan Cameron Date: Wed, 18 May 2011 13:40:54 +0000 (+0100) Subject: staging:iio: remove ability to escalate events. X-Git-Tag: firefly_0821_release~7613^2~1326^2~108 X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=939606d5cc454ea0ebae5346ace632d89f145e62;p=firefly-linux-kernel-4.4.55.git staging:iio: remove ability to escalate events. Whilst it is possible to output events to say buffers have passed a particular level there are no obvious reasons to actually do so. The upshot of this patch is that buffers will only ever have one threshold turned on at a time. For now sca3000 has it's ring buffer effectively disabled. Fixed later in series. Signed-off-by: Jonathan Cameron Signed-off-by: Greg Kroah-Hartman --- diff --git a/drivers/staging/iio/accel/sca3000_ring.c b/drivers/staging/iio/accel/sca3000_ring.c index b505e70429a1..c20bfe04d414 100644 --- a/drivers/staging/iio/accel/sca3000_ring.c +++ b/drivers/staging/iio/accel/sca3000_ring.c @@ -45,9 +45,12 @@ * Currently does not provide timestamps. As the hardware doesn't add them they * can only be inferred approximately from ring buffer events such as 50% full * and knowledge of when buffer was last emptied. This is left to userspace. + * + * Temporarily deliberately broken. **/ static int sca3000_read_first_n_hw_rb(struct iio_ring_buffer *r, - size_t count, u8 **data, int *dead_offset) + size_t count, char __user *buf, + int *dead_offset) { struct iio_hw_ring_buffer *hw_ring = iio_to_hw_ring_buf(r); struct iio_dev *indio_dev = hw_ring->private; @@ -56,6 +59,8 @@ static int sca3000_read_first_n_hw_rb(struct iio_ring_buffer *r, s16 *samples; int ret, i, num_available, num_read = 0; int bytes_per_sample = 1; + u8 *datas; + u8 **data = &datas; if (st->bpse == 11) bytes_per_sample = 2; @@ -353,9 +358,9 @@ void sca3000_register_ring_funcs(struct iio_dev *indio_dev) void sca3000_ring_int_process(u8 val, struct iio_ring_buffer *ring) { if (val & SCA3000_INT_STATUS_THREE_QUARTERS) - iio_push_or_escallate_ring_event(ring, - IIO_EVENT_CODE_RING_75_FULL, - 0); + iio_push_ring_event(ring, + IIO_EVENT_CODE_RING_75_FULL, + 0); else if (val & SCA3000_INT_STATUS_HALF) iio_push_ring_event(ring, IIO_EVENT_CODE_RING_50_FULL, 0); diff --git a/drivers/staging/iio/chrdev.h b/drivers/staging/iio/chrdev.h index 62c4285cbef6..d72049cb1073 100644 --- a/drivers/staging/iio/chrdev.h +++ b/drivers/staging/iio/chrdev.h @@ -45,23 +45,10 @@ struct iio_event_data { * struct iio_detected_event_list - list element for events that have occurred * @list: linked list header * @ev: the event itself - * @shared_pointer: used when the event is shared - i.e. can be escallated - * on demand (eg ring buffer 50%->100% full) */ struct iio_detected_event_list { struct list_head list; struct iio_event_data ev; - struct iio_shared_ev_pointer *shared_pointer; -}; -/** - * struct iio_shared_ev_pointer - allows shared events to identify if currently - * in the detected event list - * @ev_p: pointer to detected event list element (null if not in list) - * @lock: protect this element to prevent simultaneous edit and remove - */ -struct iio_shared_ev_pointer { - struct iio_detected_event_list *ev_p; - spinlock_t lock; }; /** diff --git a/drivers/staging/iio/iio.h b/drivers/staging/iio/iio.h index 440704c9bd5a..1663220981f0 100644 --- a/drivers/staging/iio/iio.h +++ b/drivers/staging/iio/iio.h @@ -394,22 +394,10 @@ int iio_push_event(struct iio_dev *dev_info, * @ev_int: the event interface to which we are pushing the event * @ev_code: the outgoing event code * @timestamp: timestamp of the event - * @shared_pointer_p: the shared event pointer **/ int __iio_push_event(struct iio_event_interface *ev_int, - int ev_code, - s64 timestamp, - struct iio_shared_ev_pointer* - shared_pointer_p); -/** - * __iio_change_event() - change an event code in case of event escalation - * @ev: the event to be changed - * @ev_code: new event code - * @timestamp: new timestamp - **/ -void __iio_change_event(struct iio_detected_event_list *ev, - int ev_code, - s64 timestamp); + int ev_code, + s64 timestamp); /** * iio_setup_ev_int() - configure an event interface (chrdev) diff --git a/drivers/staging/iio/industrialio-core.c b/drivers/staging/iio/industrialio-core.c index b67394c042c5..24ce21675b50 100644 --- a/drivers/staging/iio/industrialio-core.c +++ b/drivers/staging/iio/industrialio-core.c @@ -82,15 +82,6 @@ static const char * const iio_chan_info_postfix[] = { [IIO_CHAN_INFO_CALIBBIAS_SHARED/2] = "calibbias", }; -void __iio_change_event(struct iio_detected_event_list *ev, - int ev_code, - s64 timestamp) -{ - ev->ev.id = ev_code; - ev->ev.timestamp = timestamp; -} -EXPORT_SYMBOL(__iio_change_event); - /* Used both in the interrupt line put events and the ring buffer ones */ /* Note that in it's current form someone has to be listening before events @@ -99,9 +90,7 @@ EXPORT_SYMBOL(__iio_change_event); */ int __iio_push_event(struct iio_event_interface *ev_int, int ev_code, - s64 timestamp, - struct iio_shared_ev_pointer * - shared_pointer_p) + s64 timestamp) { struct iio_detected_event_list *ev; int ret = 0; @@ -121,9 +110,6 @@ int __iio_push_event(struct iio_event_interface *ev_int, } ev->ev.id = ev_code; ev->ev.timestamp = timestamp; - ev->shared_pointer = shared_pointer_p; - if (ev->shared_pointer) - shared_pointer_p->ev_p = ev; list_add_tail(&ev->list, &ev_int->det_events.list); ev_int->current_events++; @@ -143,7 +129,7 @@ int iio_push_event(struct iio_dev *dev_info, s64 timestamp) { return __iio_push_event(&dev_info->event_interfaces[ev_line], - ev_code, timestamp, NULL); + ev_code, timestamp); } EXPORT_SYMBOL(iio_push_event); @@ -311,18 +297,6 @@ static ssize_t iio_event_chrdev_read(struct file *filep, list_del(&el->list); ev_int->current_events--; mutex_unlock(&ev_int->event_list_lock); - /* - * Possible concurency issue if an update of this event is on its way - * through. May lead to new event being removed whilst the reported - * event was the unescalated event. In typical use case this is not a - * problem as userspace will say read half the buffer due to a 50% - * full event which would make the correct 100% full incorrect anyway. - */ - if (el->shared_pointer) { - spin_lock(&el->shared_pointer->lock); - (el->shared_pointer->ev_p) = NULL; - spin_unlock(&el->shared_pointer->lock); - } kfree(el); return len; diff --git a/drivers/staging/iio/industrialio-ring.c b/drivers/staging/iio/industrialio-ring.c index d6b4bb7aa27a..5d7cd0e7cc57 100644 --- a/drivers/staging/iio/industrialio-ring.c +++ b/drivers/staging/iio/industrialio-ring.c @@ -27,28 +27,11 @@ int iio_push_ring_event(struct iio_ring_buffer *ring_buf, s64 timestamp) { return __iio_push_event(&ring_buf->ev_int, - event_code, - timestamp, - &ring_buf->shared_ev_pointer); + event_code, + timestamp); } EXPORT_SYMBOL(iio_push_ring_event); -int iio_push_or_escallate_ring_event(struct iio_ring_buffer *ring_buf, - int event_code, - s64 timestamp) -{ - if (ring_buf->shared_ev_pointer.ev_p) - __iio_change_event(ring_buf->shared_ev_pointer.ev_p, - event_code, - timestamp); - else - return iio_push_ring_event(ring_buf, - event_code, - timestamp); - return 0; -} -EXPORT_SYMBOL(iio_push_or_escallate_ring_event); - /** * iio_ring_open() - chrdev file open for ring buffer access * @@ -228,8 +211,6 @@ void iio_ring_buffer_init(struct iio_ring_buffer *ring, ring->indio_dev = dev_info; ring->ev_int.private = ring; ring->access_handler.private = ring; - ring->shared_ev_pointer.ev_p = NULL; - spin_lock_init(&ring->shared_ev_pointer.lock); } EXPORT_SYMBOL(iio_ring_buffer_init); diff --git a/drivers/staging/iio/ring_generic.h b/drivers/staging/iio/ring_generic.h index ada51c27039a..d51c21c42297 100644 --- a/drivers/staging/iio/ring_generic.h +++ b/drivers/staging/iio/ring_generic.h @@ -107,8 +107,6 @@ struct iio_ring_access_funcs { * @scan_timestamp: [INTERN] does the scan mode include a timestamp * @access_handler: [INTERN] chrdev access handling * @ev_int: [INTERN] chrdev interface for the event chrdev - * @shared_ev_pointer: [INTERN] the shared event pointer to allow escalation of - * events * @access: [DRIVER] ring access functions associated with the * implementation. * @preenable: [DRIVER] function to run prior to marking ring enabled @@ -133,7 +131,6 @@ struct iio_ring_buffer { bool scan_timestamp; struct iio_handler access_handler; struct iio_event_interface ev_int; - struct iio_shared_ev_pointer shared_ev_pointer; struct iio_ring_access_funcs access; int (*preenable)(struct iio_dev *); int (*postenable)(struct iio_dev *); diff --git a/drivers/staging/iio/ring_sw.c b/drivers/staging/iio/ring_sw.c index ea0015eee13e..000481421e49 100644 --- a/drivers/staging/iio/ring_sw.c +++ b/drivers/staging/iio/ring_sw.c @@ -123,14 +123,6 @@ static int iio_store_to_sw_ring(struct iio_sw_ring_buffer *ring, */ if (change_test_ptr == ring->read_p) ring->read_p = temp_ptr; - - spin_lock(&ring->buf.shared_ev_pointer.lock); - - ret = iio_push_or_escallate_ring_event(&ring->buf, - IIO_EVENT_CODE_RING_100_FULL, timestamp); - spin_unlock(&ring->buf.shared_ev_pointer.lock); - if (ret) - goto error_ret; } /* investigate if our event barrier has been passed */ /* There are definite 'issues' with this and chances of @@ -140,15 +132,11 @@ static int iio_store_to_sw_ring(struct iio_sw_ring_buffer *ring, if (ring->half_p == ring->data + ring->buf.length*ring->buf.bytes_per_datum) ring->half_p = ring->data; if (ring->half_p == ring->read_p) { - spin_lock(&ring->buf.shared_ev_pointer.lock); code = IIO_EVENT_CODE_RING_50_FULL; ret = __iio_push_event(&ring->buf.ev_int, code, - timestamp, - &ring->buf.shared_ev_pointer); - spin_unlock(&ring->buf.shared_ev_pointer.lock); + timestamp); } -error_ret: return ret; }