sca3000_ring.c

Go to the documentation of this file.

/*
 * sca3000_ring.c -- support VTI sca3000 series accelerometers via SPI
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * Copyright (c) 2009 Jonathan Cameron <[email protected]>
 *
 */

#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/spi/spi.h>
#include <linux/sysfs.h>
#include <linux/sched.h>
#include <linux/poll.h>

#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
#include "../ring_hw.h"
#include "sca3000.h"

/* RFC / future work
 *
 * The internal ring buffer doesn't actually change what it holds depending
 * on which signals are enabled etc, merely whether you can read them.
 * As such the scan mode selection is somewhat different than for a software
 * ring buffer and changing it actually covers any data already in the buffer.
 * Currently scan elements aren't configured so it doesn't matter.
 */

static int sca3000_read_data(struct sca3000_state *st,
                uint8_t reg_address_high,
                u8 **rx_p,
                int len)
{
    int ret;
    struct spi_message msg;
    struct spi_transfer xfer[2] = {
        {
            .len = 1,
            .tx_buf = st->tx,
        }, {
            .len = len,
        }
    };
    *rx_p = kmalloc(len, GFP_KERNEL);
    if (*rx_p == NULL) {
        ret = -ENOMEM;
        goto error_ret;
    }
    xfer[1].rx_buf = *rx_p;
    st->tx[0] = SCA3000_READ_REG(reg_address_high);
    spi_message_init(&msg);
    spi_message_add_tail(&xfer[0], &msg);
    spi_message_add_tail(&xfer[1], &msg);
    ret = spi_sync(st->us, &msg);
    if (ret) {
        dev_err(get_device(&st->us->dev), "problem reading register");
        goto error_free_rx;
    }

    return 0;
error_free_rx:
    kfree(*rx_p);
error_ret:
    return ret;
}

static int sca3000_read_first_n_hw_rb(struct iio_buffer *r,
                      size_t count, char __user *buf)
{
    struct iio_hw_buffer *hw_ring = iio_to_hw_buf(r);
    struct iio_dev *indio_dev = hw_ring->private;
    struct sca3000_state *st = iio_priv(indio_dev);
    u8 *rx;
    int ret, i, num_available, num_read = 0;
    int bytes_per_sample = 1;

    if (st->bpse == 11)
        bytes_per_sample = 2;

    mutex_lock(&st->lock);
    if (count % bytes_per_sample) {
        ret = -EINVAL;
        goto error_ret;
    }

    ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_BUF_COUNT, 1);
    if (ret)
        goto error_ret;
    else
        num_available = st->rx[0];
    /*
     * num_available is the total number of samples available
     * i.e. number of time points * number of channels.
     */
    if (count > num_available * bytes_per_sample)
        num_read = num_available*bytes_per_sample;
    else
        num_read = count;

    ret = sca3000_read_data(st,
                SCA3000_REG_ADDR_RING_OUT,
                &rx, num_read);
    if (ret)
        goto error_ret;

    for (i = 0; i < num_read; i++)
        *(((u16 *)rx) + i) = be16_to_cpup((u16 *)rx + i);

    if (copy_to_user(buf, rx, num_read))
        ret = -EFAULT;
    kfree(rx);
    r->stufftoread = 0;
error_ret:
    mutex_unlock(&st->lock);

    return ret ? ret : num_read;
}

/* This is only valid with all 3 elements enabled */
static int sca3000_ring_get_length(struct iio_buffer *r)
{
    return 64;
}

/* only valid if resolution is kept at 11bits */
static int sca3000_ring_get_bytes_per_datum(struct iio_buffer *r)
{
    return 6;
}

static IIO_BUFFER_ENABLE_ATTR;
static IIO_BUFFER_LENGTH_ATTR;

static ssize_t sca3000_query_ring_int(struct device *dev,
                      struct device_attribute *attr,
                      char *buf)
{
    struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
    int ret, val;
    struct iio_dev *indio_dev = dev_to_iio_dev(dev);
    struct sca3000_state *st = iio_priv(indio_dev);

    mutex_lock(&st->lock);
    ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
    val = st->rx[0];
    mutex_unlock(&st->lock);
    if (ret)
        return ret;

    return sprintf(buf, "%d\n", !!(val & this_attr->address));
}

static ssize_t sca3000_set_ring_int(struct device *dev,
                      struct device_attribute *attr,
                      const char *buf,
                      size_t len)
{
    struct iio_dev *indio_dev = dev_to_iio_dev(dev);
    struct sca3000_state *st = iio_priv(indio_dev);
    struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
    long val;
    int ret;

    mutex_lock(&st->lock);
    ret = strict_strtol(buf, 10, &val);
    if (ret)
        goto error_ret;
    ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
    if (ret)
        goto error_ret;
    if (val)
        ret = sca3000_write_reg(st,
                    SCA3000_REG_ADDR_INT_MASK,
                    st->rx[0] | this_attr->address);
    else
        ret = sca3000_write_reg(st,
                    SCA3000_REG_ADDR_INT_MASK,
                    st->rx[0] & ~this_attr->address);
error_ret:
    mutex_unlock(&st->lock);

    return ret ? ret : len;
}

static IIO_DEVICE_ATTR(50_percent, S_IRUGO | S_IWUSR,
               sca3000_query_ring_int,
               sca3000_set_ring_int,
               SCA3000_INT_MASK_RING_HALF);

static IIO_DEVICE_ATTR(75_percent, S_IRUGO | S_IWUSR,
               sca3000_query_ring_int,
               sca3000_set_ring_int,
               SCA3000_INT_MASK_RING_THREE_QUARTER);

static ssize_t sca3000_show_buffer_scale(struct device *dev,
                     struct device_attribute *attr,
                     char *buf)
{
    struct iio_dev *indio_dev = dev_to_iio_dev(dev);
    struct sca3000_state *st = iio_priv(indio_dev);

    return sprintf(buf, "0.%06d\n", 4*st->info->scale);
}

static IIO_DEVICE_ATTR(in_accel_scale,
               S_IRUGO,
               sca3000_show_buffer_scale,
               NULL,
               0);

/*
 * Ring buffer attributes
 * This device is a bit unusual in that the sampling frequency and bpse
 * only apply to the ring buffer.  At all times full rate and accuracy
 * is available via direct reading from registers.
 */
static struct attribute *sca3000_ring_attributes[] = {
    &dev_attr_length.attr,
    &dev_attr_enable.attr,
    &iio_dev_attr_50_percent.dev_attr.attr,
    &iio_dev_attr_75_percent.dev_attr.attr,
    &iio_dev_attr_in_accel_scale.dev_attr.attr,
    NULL,
};

static struct attribute_group sca3000_ring_attr = {
    .attrs = sca3000_ring_attributes,
    .name = "buffer",
};

static struct iio_buffer *sca3000_rb_allocate(struct iio_dev *indio_dev)
{
    struct iio_buffer *buf;
    struct iio_hw_buffer *ring;

    ring = kzalloc(sizeof *ring, GFP_KERNEL);
    if (!ring)
        return NULL;

    ring->private = indio_dev;
    buf = &ring->buf;
    buf->stufftoread = 0;
    buf->attrs = &sca3000_ring_attr;
    iio_buffer_init(buf);

    return buf;
}

static inline void sca3000_rb_free(struct iio_buffer *r)
{
    kfree(iio_to_hw_buf(r));
}

static const struct iio_buffer_access_funcs sca3000_ring_access_funcs = {
    .read_first_n = &sca3000_read_first_n_hw_rb,
    .get_length = &sca3000_ring_get_length,
    .get_bytes_per_datum = &sca3000_ring_get_bytes_per_datum,
};

int sca3000_configure_ring(struct iio_dev *indio_dev)
{
    indio_dev->buffer = sca3000_rb_allocate(indio_dev);
    if (indio_dev->buffer == NULL)
        return -ENOMEM;
    indio_dev->modes |= INDIO_BUFFER_HARDWARE;

    indio_dev->buffer->access = &sca3000_ring_access_funcs;

    return 0;
}

void sca3000_unconfigure_ring(struct iio_dev *indio_dev)
{
    sca3000_rb_free(indio_dev->buffer);
}

static inline
int __sca3000_hw_ring_state_set(struct iio_dev *indio_dev, bool state)
{
    struct sca3000_state *st = iio_priv(indio_dev);
    int ret;

    mutex_lock(&st->lock);
    ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
    if (ret)
        goto error_ret;
    if (state) {
        printk(KERN_INFO "supposedly enabling ring buffer\n");
        ret = sca3000_write_reg(st,
                    SCA3000_REG_ADDR_MODE,
                    (st->rx[0] | SCA3000_RING_BUF_ENABLE));
    } else
        ret = sca3000_write_reg(st,
                    SCA3000_REG_ADDR_MODE,
                    (st->rx[0] & ~SCA3000_RING_BUF_ENABLE));
error_ret:
    mutex_unlock(&st->lock);

    return ret;
}
static int sca3000_hw_ring_preenable(struct iio_dev *indio_dev)
{
    return __sca3000_hw_ring_state_set(indio_dev, 1);
}

static int sca3000_hw_ring_postdisable(struct iio_dev *indio_dev)
{
    return __sca3000_hw_ring_state_set(indio_dev, 0);
}

static const struct iio_buffer_setup_ops sca3000_ring_setup_ops = {
    .preenable = &sca3000_hw_ring_preenable,
    .postdisable = &sca3000_hw_ring_postdisable,
};

void sca3000_register_ring_funcs(struct iio_dev *indio_dev)
{
    indio_dev->setup_ops = &sca3000_ring_setup_ops;
}

void sca3000_ring_int_process(u8 val, struct iio_buffer *ring)
{
    if (val & (SCA3000_INT_STATUS_THREE_QUARTERS |
           SCA3000_INT_STATUS_HALF)) {
        ring->stufftoread = true;
        wake_up_interruptible(&ring->pollq);
    }
}