drivers/staging/iio/adc/max1363_ring.c

   1 /*
   2  * Copyright (C) 2008 Jonathan Cameron
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * max1363_ring.c
   9  */
  10
  11 #include <linux/interrupt.h>
  12 #include <linux/gpio.h>
  13 #include <linux/workqueue.h>
  14 #include <linux/device.h>
  15 #include <linux/slab.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sysfs.h>
  18 #include <linux/list.h>
  19 #include <linux/i2c.h>
  20 #include <linux/bitops.h>
  21
  22 #include "../iio.h"
  23 #include "../ring_generic.h"
  24 #include "../ring_sw.h"
  25 #include "../trigger.h"
  26 #include "../sysfs.h"
  27
  28 #include "max1363.h"
  29
  30 /* Todo: test this */
  31 int max1363_single_channel_from_ring(long mask, struct max1363_state *st)
  32 {
  33         unsigned long numvals;
  34         int count = 0, ret;
  35         u8 *ring_data;
  36         if (!(st->current_mode->modemask & mask)) {
  37                 ret = -EBUSY;
  38                 goto error_ret;
  39         }
  40         numvals = hweight_long(st->current_mode->modemask);
  41
  42         ring_data = kmalloc(numvals*2, GFP_KERNEL);
  43         if (ring_data == NULL) {
  44                 ret = -ENOMEM;
  45                 goto error_ret;
  46         }
  47         ret = st->indio_dev->ring->access.read_last(st->indio_dev->ring,
  48                                                 ring_data);
  49         if (ret)
  50                 goto error_free_ring_data;
  51         /* Need a count of channels prior to this one */
  52         mask >>= 1;
  53         while (mask) {
  54                 if (mask & st->current_mode->modemask)
  55                         count++;
  56                 mask >>= 1;
  57         }
  58         if (st->chip_info->bits != 8)
  59                 ret = ((int)(ring_data[count*2 + 0] & 0x0F) << 8)
  60                         + (int)(ring_data[count*2 + 1]);
  61         else
  62                 ret = ring_data[count];
  63
  64 error_free_ring_data:
  65         kfree(ring_data);
  66 error_ret:
  67         return ret;
  68 }
  69
  70 /**
  71  * max1363_ring_preenable() setup the parameters of the ring before enabling
  72  *
  73  * The complex nature of the setting of the nuber of bytes per datum is due
  74  * to this driver currently ensuring that the timestamp is stored at an 8
  75  * byte boundary.
  76  **/
  77 static int max1363_ring_preenable(struct iio_dev *indio_dev)
  78 {
  79         struct max1363_state *st = indio_dev->dev_data;
  80         size_t d_size;
  81         unsigned long numvals;
  82
  83         /*
  84          * Need to figure out the current mode based upon the requested
  85          * scan mask in iio_dev
  86          */
  87         st->current_mode = max1363_match_mode(st->indio_dev->scan_mask,
  88                                         st->chip_info);
  89         if (!st->current_mode)
  90                 return -EINVAL;
  91
  92         max1363_set_scan_mode(st);
  93
  94         numvals = hweight_long(st->current_mode->modemask);
  95         if (indio_dev->ring->access.set_bpd) {
  96                 if (st->chip_info->bits != 8)
  97                         d_size = numvals*2 + sizeof(s64);
  98                 else
  99                         d_size = numvals + sizeof(s64);
 100                 if (d_size % 8)
 101                         d_size += 8 - (d_size % 8);
 102                 indio_dev->ring->access.set_bpd(indio_dev->ring, d_size);
 103         }
 104
 105         return 0;
 106 }
 107
 108 /**
 109  * max1363_ring_postenable() typical ring post enable
 110  *
 111  * Only not moved into the core for the hardware ring buffer cases
 112  * that are more sophisticated.
 113  **/
 114 static int max1363_ring_postenable(struct iio_dev *indio_dev)
 115 {
 116         if (indio_dev->trig == NULL)
 117                 return 0;
 118         return iio_trigger_attach_poll_func(indio_dev->trig,
 119                                             indio_dev->pollfunc);
 120 }
 121
 122 /**
 123  * max1363_ring_predisable() runs just prior to ring buffer being disabled
 124  *
 125  * Typical predisable function which ensures that no trigger events can
 126  * occur before we disable the ring buffer (and hence would have no idea
 127  * what to do with them)
 128  **/
 129 static int max1363_ring_predisable(struct iio_dev *indio_dev)
 130 {
 131         if (indio_dev->trig)
 132                 return iio_trigger_dettach_poll_func(indio_dev->trig,
 133                                                      indio_dev->pollfunc);
 134         else
 135                 return 0;
 136 }
 137
 138 /**
 139  * max1363_poll_func_th() th of trigger launched polling to ring buffer
 140  *
 141  * As sampling only occurs on i2c comms occuring, leave timestamping until
 142  * then.  Some triggers will generate their own time stamp.  Currently
 143  * there is no way of notifying them when no one cares.
 144  **/
 145 static void max1363_poll_func_th(struct iio_dev *indio_dev)
 146 {
 147         struct max1363_state *st = indio_dev->dev_data;
 148
 149         schedule_work(&st->poll_work);
 150
 151         return;
 152 }
 153 /**
 154  * max1363_poll_bh_to_ring() bh of trigger launched polling to ring buffer
 155  * @work_s:     the work struct through which this was scheduled
 156  *
 157  * Currently there is no option in this driver to disable the saving of
 158  * timestamps within the ring.
 159  * I think the one copy of this at a time was to avoid problems if the
 160  * trigger was set far too high and the reads then locked up the computer.
 161  **/
 162 static void max1363_poll_bh_to_ring(struct work_struct *work_s)
 163 {
 164         struct max1363_state *st = container_of(work_s, struct max1363_state,
 165                                                   poll_work);
 166         struct iio_dev *indio_dev = st->indio_dev;
 167         struct iio_sw_ring_buffer *ring = iio_to_sw_ring(indio_dev->ring);
 168         s64 time_ns;
 169         __u8 *rxbuf;
 170         int b_sent;
 171         size_t d_size;
 172         unsigned long numvals = hweight_long(st->current_mode->modemask);
 173
 174         /* Ensure the timestamp is 8 byte aligned */
 175         if (st->chip_info->bits != 8)
 176                 d_size = numvals*2 + sizeof(s64);
 177         else
 178                 d_size = numvals + sizeof(s64);
 179         if (d_size % sizeof(s64))
 180                 d_size += sizeof(s64) - (d_size % sizeof(s64));
 181
 182         /* Ensure only one copy of this function running at a time */
 183         if (atomic_inc_return(&st->protect_ring) > 1)
 184                 return;
 185
 186         /* Monitor mode prevents reading. Whilst not currently implemented
 187          * might as well have this test in here in the meantime as it does
 188          * no harm.
 189          */
 190         if (numvals == 0)
 191                 return;
 192
 193         rxbuf = kmalloc(d_size, GFP_KERNEL);
 194         if (rxbuf == NULL)
 195                 return;
 196         if (st->chip_info->bits != 8)
 197                 b_sent = i2c_master_recv(st->client, rxbuf, numvals*2);
 198         else
 199                 b_sent = i2c_master_recv(st->client, rxbuf, numvals);
 200         if (b_sent < 0)
 201                 goto done;
 202
 203         time_ns = iio_get_time_ns();
 204
 205         memcpy(rxbuf + d_size - sizeof(s64), &time_ns, sizeof(time_ns));
 206
 207         indio_dev->ring->access.store_to(&ring->buf, rxbuf, time_ns);
 208 done:
 209         kfree(rxbuf);
 210         atomic_dec(&st->protect_ring);
 211 }
 212
 213
 214 int max1363_register_ring_funcs_and_init(struct iio_dev *indio_dev)
 215 {
 216         struct max1363_state *st = indio_dev->dev_data;
 217         int ret = 0;
 218
 219         indio_dev->ring = iio_sw_rb_allocate(indio_dev);
 220         if (!indio_dev->ring) {
 221                 ret = -ENOMEM;
 222                 goto error_ret;
 223         }
 224         /* Effectively select the ring buffer implementation */
 225         iio_ring_sw_register_funcs(&st->indio_dev->ring->access);
 226         indio_dev->pollfunc = kzalloc(sizeof(*indio_dev->pollfunc), GFP_KERNEL);
 227         if (indio_dev->pollfunc == NULL) {
 228                 ret = -ENOMEM;
 229                 goto error_deallocate_sw_rb;
 230         }
 231         /* Configure the polling function called on trigger interrupts */
 232         indio_dev->pollfunc->poll_func_main = &max1363_poll_func_th;
 233         indio_dev->pollfunc->private_data = indio_dev;
 234
 235         /* Ring buffer functions - here trigger setup related */
 236         indio_dev->ring->postenable = &max1363_ring_postenable;
 237         indio_dev->ring->preenable = &max1363_ring_preenable;
 238         indio_dev->ring->predisable = &max1363_ring_predisable;
 239         INIT_WORK(&st->poll_work, &max1363_poll_bh_to_ring);
 240
 241         /* Flag that polled ring buffering is possible */
 242         indio_dev->modes |= INDIO_RING_TRIGGERED;
 243         return 0;
 244 error_deallocate_sw_rb:
 245         iio_sw_rb_free(indio_dev->ring);
 246 error_ret:
 247         return ret;
 248 }
 249
 250 void max1363_ring_cleanup(struct iio_dev *indio_dev)
 251 {
 252         /* ensure that the trigger has been detached */
 253         if (indio_dev->trig) {
 254                 iio_put_trigger(indio_dev->trig);
 255                 iio_trigger_dettach_poll_func(indio_dev->trig,
 256                                               indio_dev->pollfunc);
 257         }
 258         kfree(indio_dev->pollfunc);
 259         iio_sw_rb_free(indio_dev->ring);
 260 }
 261
 262 void max1363_uninitialize_ring(struct iio_ring_buffer *ring)
 263 {
 264         iio_ring_buffer_unregister(ring);
 265 };
 266
 267 int max1363_initialize_ring(struct iio_ring_buffer *ring)
 268 {
 269         return iio_ring_buffer_register(ring, 0);
 270 };