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 /**
 110  * max1363_poll_func_th() - th of trigger launched polling to ring buffer
 111  *
 112  * As sampling only occurs on i2c comms occuring, leave timestamping until
 113  * then.  Some triggers will generate their own time stamp.  Currently
 114  * there is no way of notifying them when no one cares.
 115  **/
 116 static void max1363_poll_func_th(struct iio_dev *indio_dev, s64 time)
 117 {
 118         struct max1363_state *st = indio_dev->dev_data;
 119
 120         schedule_work(&st->poll_work);
 121
 122         return;
 123 }
 124 /**
 125  * max1363_poll_bh_to_ring() - bh of trigger launched polling to ring buffer
 126  * @work_s:     the work struct through which this was scheduled
 127  *
 128  * Currently there is no option in this driver to disable the saving of
 129  * timestamps within the ring.
 130  * I think the one copy of this at a time was to avoid problems if the
 131  * trigger was set far too high and the reads then locked up the computer.
 132  **/
 133 static void max1363_poll_bh_to_ring(struct work_struct *work_s)
 134 {
 135         struct max1363_state *st = container_of(work_s, struct max1363_state,
 136                                                   poll_work);
 137         struct iio_dev *indio_dev = st->indio_dev;
 138         struct iio_sw_ring_buffer *ring = iio_to_sw_ring(indio_dev->ring);
 139         s64 time_ns;
 140         __u8 *rxbuf;
 141         int b_sent;
 142         size_t d_size;
 143         unsigned long numvals = hweight_long(st->current_mode->modemask);
 144
 145         /* Ensure the timestamp is 8 byte aligned */
 146         if (st->chip_info->bits != 8)
 147                 d_size = numvals*2 + sizeof(s64);
 148         else
 149                 d_size = numvals + sizeof(s64);
 150         if (d_size % sizeof(s64))
 151                 d_size += sizeof(s64) - (d_size % sizeof(s64));
 152
 153         /* Ensure only one copy of this function running at a time */
 154         if (atomic_inc_return(&st->protect_ring) > 1)
 155                 return;
 156
 157         /* Monitor mode prevents reading. Whilst not currently implemented
 158          * might as well have this test in here in the meantime as it does
 159          * no harm.
 160          */
 161         if (numvals == 0)
 162                 return;
 163
 164         rxbuf = kmalloc(d_size, GFP_KERNEL);
 165         if (rxbuf == NULL)
 166                 return;
 167         if (st->chip_info->bits != 8)
 168                 b_sent = i2c_master_recv(st->client, rxbuf, numvals*2);
 169         else
 170                 b_sent = i2c_master_recv(st->client, rxbuf, numvals);
 171         if (b_sent < 0)
 172                 goto done;
 173
 174         time_ns = iio_get_time_ns();
 175
 176         memcpy(rxbuf + d_size - sizeof(s64), &time_ns, sizeof(time_ns));
 177
 178         indio_dev->ring->access.store_to(&ring->buf, rxbuf, time_ns);
 179 done:
 180         kfree(rxbuf);
 181         atomic_dec(&st->protect_ring);
 182 }
 183
 184
 185 int max1363_register_ring_funcs_and_init(struct iio_dev *indio_dev)
 186 {
 187         struct max1363_state *st = indio_dev->dev_data;
 188         int ret = 0;
 189
 190         indio_dev->ring = iio_sw_rb_allocate(indio_dev);
 191         if (!indio_dev->ring) {
 192                 ret = -ENOMEM;
 193                 goto error_ret;
 194         }
 195         /* Effectively select the ring buffer implementation */
 196         iio_ring_sw_register_funcs(&st->indio_dev->ring->access);
 197         ret = iio_alloc_pollfunc(indio_dev, NULL, &max1363_poll_func_th);
 198         if (ret)
 199                 goto error_deallocate_sw_rb;
 200
 201         /* Ring buffer functions - here trigger setup related */
 202         indio_dev->ring->postenable = &iio_triggered_ring_postenable;
 203         indio_dev->ring->preenable = &max1363_ring_preenable;
 204         indio_dev->ring->predisable = &iio_triggered_ring_predisable;
 205         INIT_WORK(&st->poll_work, &max1363_poll_bh_to_ring);
 206
 207         /* Flag that polled ring buffering is possible */
 208         indio_dev->modes |= INDIO_RING_TRIGGERED;
 209         return 0;
 210 error_deallocate_sw_rb:
 211         iio_sw_rb_free(indio_dev->ring);
 212 error_ret:
 213         return ret;
 214 }
 215
 216 void max1363_ring_cleanup(struct iio_dev *indio_dev)
 217 {
 218         /* ensure that the trigger has been detached */
 219         if (indio_dev->trig) {
 220                 iio_put_trigger(indio_dev->trig);
 221                 iio_trigger_dettach_poll_func(indio_dev->trig,
 222                                               indio_dev->pollfunc);
 223         }
 224         kfree(indio_dev->pollfunc);
 225         iio_sw_rb_free(indio_dev->ring);
 226 }