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 */ 31int 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 64error_free_ring_data: 65 kfree(ring_data); 66error_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 **/ 77static 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 **/ 116static 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 **/ 133static 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); 179done: 180 kfree(rxbuf); 181 atomic_dec(&st->protect_ring); 182} 183 184 185int 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; 210error_deallocate_sw_rb: 211 iio_sw_rb_free(indio_dev->ring); 212error_ret: 213 return ret; 214} 215 216void 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} 227