drivers/staging/iio/accel/sca3000_ring.c

   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
  36 static 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;
  64 error_free_rx:
  65         kfree(*rx_p);
  66 error_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  **/
  80 static 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((u16 *)rx + i);
 121
 122         if (copy_to_user(buf, rx, num_read))
 123                 ret = -EFAULT;
 124         kfree(rx);
 125         r->stufftoread = 0;
 126 error_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 */
 133 static int sca3000_ring_get_length(struct iio_buffer *r)
 134 {
 135         return 64;
 136 }
 137
 138 /* only valid if resolution is kept at 11bits */
 139 static int sca3000_ring_get_bytes_per_datum(struct iio_buffer *r)
 140 {
 141         return 6;
 142 }
 143
 144 static bool sca3000_ring_buf_data_available(struct iio_buffer *r)
 145 {
 146         return r->stufftoread;
 147 }
 148
 149 static IIO_BUFFER_ENABLE_ATTR;
 150 static IIO_BUFFER_LENGTH_ATTR;
 151
 152 /**
 153  * sca3000_query_ring_int() is the hardware ring status interrupt enabled
 154  **/
 155 static 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  **/
 177 static 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);
 203 error_ret:
 204         mutex_unlock(&st->lock);
 205
 206         return ret ? ret : len;
 207 }
 208
 209 static 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
 214 static 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
 219 static 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
 229 static 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  */
 241 static 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
 250 static struct attribute_group sca3000_ring_attr = {
 251         .attrs = sca3000_ring_attributes,
 252         .name = "buffer",
 253 };
 254
 255 static 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
 273 static void sca3000_ring_release(struct iio_buffer *r)
 274 {
 275         kfree(iio_to_hw_buf(r));
 276 }
 277
 278 static 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
 286 int 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
 302 void sca3000_unconfigure_ring(struct iio_dev *indio_dev)
 303 {
 304         iio_buffer_put(indio_dev->buffer);
 305 }
 306
 307 static inline
 308 int __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));
 326 error_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  **/
 338 static int sca3000_hw_ring_preenable(struct iio_dev *indio_dev)
 339 {
 340         return __sca3000_hw_ring_state_set(indio_dev, 1);
 341 }
 342
 343 static int sca3000_hw_ring_postdisable(struct iio_dev *indio_dev)
 344 {
 345         return __sca3000_hw_ring_state_set(indio_dev, 0);
 346 }
 347
 348 static const struct iio_buffer_setup_ops sca3000_ring_setup_ops = {
 349         .preenable = &sca3000_hw_ring_preenable,
 350         .postdisable = &sca3000_hw_ring_postdisable,
 351 };
 352
 353 void 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  **/
 364 void 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 }