Arduino ADC

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>

#define SCALE 4882
#define IRQ_TRIGGER_PIN 27
static unsigned int irq_trigger;

struct arduino_adc_data {
    struct i2c_client *client;
    struct mutex lock;
    struct iio_trigger *trigger;
};

static const struct iio_chan_spec arduino_adc_channels[] = {
    {
        .type = IIO_VOLTAGE,
        .indexed = 1,
        .channel = 0,
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
        .scan_index = 0,
        .scan_type = {
            .sign = 's',
            .realbits = 16,
            .storagebits = 16,
            .shift = 0,
            .endianness = IIO_CPU,
        },
    },
    {
        .type = IIO_VOLTAGE,
        .indexed = 1,
        .channel = 1,
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
        .scan_index = 1,
        .scan_type = {
            .sign = 's',
            .realbits = 16,
            .storagebits = 16,
            .shift = 0,
            .endianness = IIO_CPU,
        },
    },
};

static const struct iio_trigger_ops arduino_adc_trigger_ops = {
    .owner = THIS_MODULE,
};

static irqreturn_t arduino_adc_trigger_handler(int irq, void *p)
{
    int ret;
    struct iio_poll_func *pf = p;
    struct iio_dev *indio_dev = pf->indio_dev;
    struct arduino_adc_data *data = iio_priv(indio_dev);
    __be16 raw[2];
    int to_buffer[2];

    ret = i2c_master_recv(data->client, (char *)&raw, 4);
    if (ret < 0)
        return ret;

    to_buffer[0] = raw[0];
    to_buffer[1] = raw[1];

    iio_push_to_buffers_with_timestamp(indio_dev, to_buffer,
        pf->timestamp);

    iio_trigger_notify_done(indio_dev->trig);

    return IRQ_HANDLED;
}

static irqreturn_t erpi_gpio_irq_handler(unsigned int irq, void
                                         *dev_id, struct pt_regs *regs)
{
    return IRQ_HANDLED;
}

static int arduino_adc_read(struct arduino_adc_data *data, int *val, int channel)
{
    int ret;
    __be16 result[2];

    if(channel & ~1) {
        return -EINVAL;
    }

    ret = i2c_master_recv(data->client, (char *)&result, 4);
    if (ret < 0)
        return ret;

    *val = be16_to_cpu(result[channel]);

    return 0;
}

static int arduino_adc_read_raw(struct iio_dev *indio_dev,
               struct iio_chan_spec const *chan,
               int *val, int *val2, long mask)
{
    int ret;
    struct arduino_adc_data *data = iio_priv(indio_dev);

    switch (mask) {
    case IIO_CHAN_INFO_RAW:

        if (iio_buffer_enabled(indio_dev)) {
            return -EBUSY;
        }

        switch (chan->type) {
        case IIO_VOLTAGE:
            mutex_lock(&data->lock);
            ret = arduino_adc_read(data, val, chan->channel);
            mutex_unlock(&data->lock);
            if (ret < 0)
                return ret;

            return IIO_VAL_INT;
        default:
            return -EINVAL;
        }
    case IIO_CHAN_INFO_SCALE:
        *val = SCALE / 1000000;
        *val2 = SCALE % 1000000;
        return IIO_VAL_INT_PLUS_MICRO;
    default:
        return -EINVAL;
    }
}

static int arduino_adc_write_raw(struct iio_dev *indio_dev,
                struct iio_chan_spec const *chan,
                int val, int val2, long mask)
{
    return 0;
}

static const struct iio_info arduino_adc_info = {
    .read_raw = arduino_adc_read_raw,
    .write_raw = arduino_adc_write_raw,
};

static int arduino_adc_probe(struct i2c_client *client,
            const struct i2c_device_id *id)
{
    int ret;
    struct arduino_adc_data *data;
    struct iio_dev *indio_dev;

    printk(KERN_INFO "arduino_adc_probe called.\n");

    indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
    if (!indio_dev)
        return -ENOMEM;

    data = iio_priv(indio_dev);
    i2c_set_clientdata(client, indio_dev);
    data->client = client;

    indio_dev->dev.parent = &client->dev;
    indio_dev->info = &arduino_adc_info;
    indio_dev->name = id->name;
    indio_dev->channels = arduino_adc_channels;
    indio_dev->num_channels = ARRAY_SIZE(arduino_adc_channels);
    indio_dev->modes = INDIO_DIRECT_MODE;

    gpio_request(IRQ_TRIGGER_PIN, "sysfs");
    gpio_direction_input(IRQ_TRIGGER_PIN);
    gpio_export(IRQ_TRIGGER_PIN, false);
    irq_trigger = gpio_to_irq(IRQ_TRIGGER_PIN);

    ret = request_irq(irq_trigger,
                (irq_handler_t) erpi_gpio_irq_handler,
                IRQF_TRIGGER_RISING,
                "rpi_gpio",
                indio_dev);
    if (ret < 0) {
        return ret;
    }

    data->trigger = devm_iio_trigger_alloc(&client->dev, "rpi_gpio");
    if(!data->trigger){
        return -ENOMEM;
    }
    data->trigger->dev.parent = &client->dev;
    data->trigger->ops = &arduino_adc_trigger_ops;
    iio_trigger_set_drvdata(data->trigger, indio_dev);
    indio_dev->trig = data->trigger;
    iio_trigger_get(indio_dev->trig);
    ret = iio_trigger_register(data->trigger);
    if (ret < 0) {
        return ret;
    }

    ret = iio_triggered_buffer_setup(indio_dev, NULL,
                     arduino_adc_trigger_handler, NULL);
    if (ret < 0) {
        return ret;
    }

    return iio_device_register(indio_dev);
}

static int arduino_adc_remove(struct i2c_client *client)
{
    struct iio_dev *indio_dev = i2c_get_clientdata(client);;
    struct arduino_adc_data *data;
    data = iio_priv(indio_dev);

    iio_device_unregister(indio_dev);

    iio_triggered_buffer_cleanup(indio_dev);
    iio_trigger_unregister(data->trigger);

    free_irq(irq_trigger, NULL);
    gpio_unexport(IRQ_TRIGGER_PIN);
    gpio_free(IRQ_TRIGGER_PIN);

    return 0;
}


static const struct i2c_device_id arduino_adc_id[] = {
    { "arduino_adc", 0 },
    { }
};
MODULE_DEVICE_TABLE(i2c, arduino_adc_id);

static struct i2c_driver arduino_adc_driver = {
    .driver = {
        .name = "arduino_adc",
    },
    .probe = arduino_adc_probe,
    .remove = arduino_adc_remove,
    .id_table = arduino_adc_id,
};
module_i2c_driver(arduino_adc_driver);

MODULE_AUTHOR("Hazael dos Santos Batista");
MODULE_DESCRIPTION("Arduino ADC test driver");
MODULE_LICENSE("GPL");