1/* 2 * sca3000_ring.c -- support VTI sca3000 series accelerometers via SPI 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License version 2 as published by 6 * the Free Software Foundation. 7 * 8 * Copyright (c) 2009 Jonathan Cameron <jic23@kernel.org> 9 * 10 */ 11 12#include <linux/interrupt.h> 13#include <linux/fs.h> 14#include <linux/slab.h> 15#include <linux/kernel.h> 16#include <linux/spi/spi.h> 17#include <linux/sysfs.h> 18#include <linux/sched.h> 19#include <linux/poll.h> 20 21#include <linux/iio/iio.h> 22#include <linux/iio/sysfs.h> 23#include <linux/iio/buffer.h> 24#include "../ring_hw.h" 25#include "sca3000.h" 26 27/* RFC / future work 28 * 29 * The internal ring buffer doesn't actually change what it holds depending 30 * on which signals are enabled etc, merely whether you can read them. 31 * As such the scan mode selection is somewhat different than for a software 32 * ring buffer and changing it actually covers any data already in the buffer. 33 * Currently scan elements aren't configured so it doesn't matter. 34 */ 35 36static int sca3000_read_data(struct sca3000_state *st, 37 uint8_t reg_address_high, 38 u8 **rx_p, 39 int len) 40{ 41 int ret; 42 struct spi_transfer xfer[2] = { 43 { 44 .len = 1, 45 .tx_buf = st->tx, 46 }, { 47 .len = len, 48 } 49 }; 50 *rx_p = kmalloc(len, GFP_KERNEL); 51 if (*rx_p == NULL) { 52 ret = -ENOMEM; 53 goto error_ret; 54 } 55 xfer[1].rx_buf = *rx_p; 56 st->tx[0] = SCA3000_READ_REG(reg_address_high); 57 ret = spi_sync_transfer(st->us, xfer, ARRAY_SIZE(xfer)); 58 if (ret) { 59 dev_err(get_device(&st->us->dev), "problem reading register"); 60 goto error_free_rx; 61 } 62 63 return 0; 64error_free_rx: 65 kfree(*rx_p); 66error_ret: 67 return ret; 68} 69 70/** 71 * sca3000_read_first_n_hw_rb() - main ring access, pulls data from ring 72 * @r: the ring 73 * @count: number of samples to try and pull 74 * @data: output the actual samples pulled from the hw ring 75 * 76 * Currently does not provide timestamps. As the hardware doesn't add them they 77 * can only be inferred approximately from ring buffer events such as 50% full 78 * and knowledge of when buffer was last emptied. This is left to userspace. 79 **/ 80static int sca3000_read_first_n_hw_rb(struct iio_buffer *r, 81 size_t count, char __user *buf) 82{ 83 struct iio_hw_buffer *hw_ring = iio_to_hw_buf(r); 84 struct iio_dev *indio_dev = hw_ring->private; 85 struct sca3000_state *st = iio_priv(indio_dev); 86 u8 *rx; 87 int ret, i, num_available, num_read = 0; 88 int bytes_per_sample = 1; 89 90 if (st->bpse == 11) 91 bytes_per_sample = 2; 92 93 mutex_lock(&st->lock); 94 if (count % bytes_per_sample) { 95 ret = -EINVAL; 96 goto error_ret; 97 } 98 99 ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_BUF_COUNT, 1); 100 if (ret) 101 goto error_ret; 102 else 103 num_available = st->rx[0]; 104 /* 105 * num_available is the total number of samples available 106 * i.e. number of time points * number of channels. 107 */ 108 if (count > num_available * bytes_per_sample) 109 num_read = num_available*bytes_per_sample; 110 else 111 num_read = count; 112 113 ret = sca3000_read_data(st, 114 SCA3000_REG_ADDR_RING_OUT, 115 &rx, num_read); 116 if (ret) 117 goto error_ret; 118 119 for (i = 0; i < num_read; i++) 120 *(((u16 *)rx) + i) = be16_to_cpup((__be16 *)rx + i); 121 122 if (copy_to_user(buf, rx, num_read)) 123 ret = -EFAULT; 124 kfree(rx); 125 r->stufftoread = 0; 126error_ret: 127 mutex_unlock(&st->lock); 128 129 return ret ? ret : num_read; 130} 131 132/* This is only valid with all 3 elements enabled */ 133static int sca3000_ring_get_length(struct iio_buffer *r) 134{ 135 return 64; 136} 137 138/* only valid if resolution is kept at 11bits */ 139static int sca3000_ring_get_bytes_per_datum(struct iio_buffer *r) 140{ 141 return 6; 142} 143 144static bool sca3000_ring_buf_data_available(struct iio_buffer *r) 145{ 146 return r->stufftoread; 147} 148 149static IIO_BUFFER_ENABLE_ATTR; 150static IIO_BUFFER_LENGTH_ATTR; 151 152/** 153 * sca3000_query_ring_int() is the hardware ring status interrupt enabled 154 **/ 155static ssize_t sca3000_query_ring_int(struct device *dev, 156 struct device_attribute *attr, 157 char *buf) 158{ 159 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 160 int ret, val; 161 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 162 struct sca3000_state *st = iio_priv(indio_dev); 163 164 mutex_lock(&st->lock); 165 ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1); 166 val = st->rx[0]; 167 mutex_unlock(&st->lock); 168 if (ret) 169 return ret; 170 171 return sprintf(buf, "%d\n", !!(val & this_attr->address)); 172} 173 174/** 175 * sca3000_set_ring_int() set state of ring status interrupt 176 **/ 177static ssize_t sca3000_set_ring_int(struct device *dev, 178 struct device_attribute *attr, 179 const char *buf, 180 size_t len) 181{ 182 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 183 struct sca3000_state *st = iio_priv(indio_dev); 184 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 185 u8 val; 186 int ret; 187 188 mutex_lock(&st->lock); 189 ret = kstrtou8(buf, 10, &val); 190 if (ret) 191 goto error_ret; 192 ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1); 193 if (ret) 194 goto error_ret; 195 if (val) 196 ret = sca3000_write_reg(st, 197 SCA3000_REG_ADDR_INT_MASK, 198 st->rx[0] | this_attr->address); 199 else 200 ret = sca3000_write_reg(st, 201 SCA3000_REG_ADDR_INT_MASK, 202 st->rx[0] & ~this_attr->address); 203error_ret: 204 mutex_unlock(&st->lock); 205 206 return ret ? ret : len; 207} 208 209static IIO_DEVICE_ATTR(50_percent, S_IRUGO | S_IWUSR, 210 sca3000_query_ring_int, 211 sca3000_set_ring_int, 212 SCA3000_INT_MASK_RING_HALF); 213 214static IIO_DEVICE_ATTR(75_percent, S_IRUGO | S_IWUSR, 215 sca3000_query_ring_int, 216 sca3000_set_ring_int, 217 SCA3000_INT_MASK_RING_THREE_QUARTER); 218 219static ssize_t sca3000_show_buffer_scale(struct device *dev, 220 struct device_attribute *attr, 221 char *buf) 222{ 223 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 224 struct sca3000_state *st = iio_priv(indio_dev); 225 226 return sprintf(buf, "0.%06d\n", 4*st->info->scale); 227} 228 229static IIO_DEVICE_ATTR(in_accel_scale, 230 S_IRUGO, 231 sca3000_show_buffer_scale, 232 NULL, 233 0); 234 235/* 236 * Ring buffer attributes 237 * This device is a bit unusual in that the sampling frequency and bpse 238 * only apply to the ring buffer. At all times full rate and accuracy 239 * is available via direct reading from registers. 240 */ 241static struct attribute *sca3000_ring_attributes[] = { 242 &dev_attr_length.attr, 243 &dev_attr_enable.attr, 244 &iio_dev_attr_50_percent.dev_attr.attr, 245 &iio_dev_attr_75_percent.dev_attr.attr, 246 &iio_dev_attr_in_accel_scale.dev_attr.attr, 247 NULL, 248}; 249 250static struct attribute_group sca3000_ring_attr = { 251 .attrs = sca3000_ring_attributes, 252 .name = "buffer", 253}; 254 255static struct iio_buffer *sca3000_rb_allocate(struct iio_dev *indio_dev) 256{ 257 struct iio_buffer *buf; 258 struct iio_hw_buffer *ring; 259 260 ring = kzalloc(sizeof(*ring), GFP_KERNEL); 261 if (!ring) 262 return NULL; 263 264 ring->private = indio_dev; 265 buf = &ring->buf; 266 buf->stufftoread = 0; 267 buf->attrs = &sca3000_ring_attr; 268 iio_buffer_init(buf); 269 270 return buf; 271} 272 273static void sca3000_ring_release(struct iio_buffer *r) 274{ 275 kfree(iio_to_hw_buf(r)); 276} 277 278static const struct iio_buffer_access_funcs sca3000_ring_access_funcs = { 279 .read_first_n = &sca3000_read_first_n_hw_rb, 280 .get_length = &sca3000_ring_get_length, 281 .get_bytes_per_datum = &sca3000_ring_get_bytes_per_datum, 282 .data_available = sca3000_ring_buf_data_available, 283 .release = sca3000_ring_release, 284}; 285 286int sca3000_configure_ring(struct iio_dev *indio_dev) 287{ 288 struct iio_buffer *buffer; 289 290 buffer = sca3000_rb_allocate(indio_dev); 291 if (buffer == NULL) 292 return -ENOMEM; 293 indio_dev->modes |= INDIO_BUFFER_HARDWARE; 294 295 indio_dev->buffer->access = &sca3000_ring_access_funcs; 296 297 iio_device_attach_buffer(indio_dev, buffer); 298 299 return 0; 300} 301 302void sca3000_unconfigure_ring(struct iio_dev *indio_dev) 303{ 304 iio_buffer_put(indio_dev->buffer); 305} 306 307static inline 308int __sca3000_hw_ring_state_set(struct iio_dev *indio_dev, bool state) 309{ 310 struct sca3000_state *st = iio_priv(indio_dev); 311 int ret; 312 313 mutex_lock(&st->lock); 314 ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); 315 if (ret) 316 goto error_ret; 317 if (state) { 318 dev_info(&indio_dev->dev, "supposedly enabling ring buffer\n"); 319 ret = sca3000_write_reg(st, 320 SCA3000_REG_ADDR_MODE, 321 (st->rx[0] | SCA3000_RING_BUF_ENABLE)); 322 } else 323 ret = sca3000_write_reg(st, 324 SCA3000_REG_ADDR_MODE, 325 (st->rx[0] & ~SCA3000_RING_BUF_ENABLE)); 326error_ret: 327 mutex_unlock(&st->lock); 328 329 return ret; 330} 331/** 332 * sca3000_hw_ring_preenable() hw ring buffer preenable function 333 * 334 * Very simple enable function as the chip will allows normal reads 335 * during ring buffer operation so as long as it is indeed running 336 * before we notify the core, the precise ordering does not matter. 337 **/ 338static int sca3000_hw_ring_preenable(struct iio_dev *indio_dev) 339{ 340 return __sca3000_hw_ring_state_set(indio_dev, 1); 341} 342 343static int sca3000_hw_ring_postdisable(struct iio_dev *indio_dev) 344{ 345 return __sca3000_hw_ring_state_set(indio_dev, 0); 346} 347 348static const struct iio_buffer_setup_ops sca3000_ring_setup_ops = { 349 .preenable = &sca3000_hw_ring_preenable, 350 .postdisable = &sca3000_hw_ring_postdisable, 351}; 352 353void sca3000_register_ring_funcs(struct iio_dev *indio_dev) 354{ 355 indio_dev->setup_ops = &sca3000_ring_setup_ops; 356} 357 358/** 359 * sca3000_ring_int_process() ring specific interrupt handling. 360 * 361 * This is only split from the main interrupt handler so as to 362 * reduce the amount of code if the ring buffer is not enabled. 363 **/ 364void sca3000_ring_int_process(u8 val, struct iio_buffer *ring) 365{ 366 if (val & (SCA3000_INT_STATUS_THREE_QUARTERS | 367 SCA3000_INT_STATUS_HALF)) { 368 ring->stufftoread = true; 369 wake_up_interruptible(&ring->pollq); 370 } 371} 372