linux ad7606 驱动解读

本文记录阅读linux ad7606驱动的笔记。

主要文件

drivers/staging/iio/adc/ad7606_spi.c

drivers/staging/iio/adc/ad7606_core.c

drivers/staging/iio/adc/ad7606_ring.c

drivers/staging/iio/adc/ad7606_spi.c

static int __init ad7606_spi_init(void)
{
    return spi_register_driver(&ad7606_driver);
}
module_init(ad7606_spi_init);

static struct spi_driver ad7606_driver = {
    .driver = {
        .name = "ad7606",
        .bus = &spi_bus_type,
        .owner = THIS_MODULE,
        .pm    = AD7606_SPI_PM_OPS,
    },
    .probe = ad7606_spi_probe,
    .remove = __devexit_p(ad7606_spi_remove),
    .id_table = ad7606_id,
};

static int __devinit ad7606_spi_probe(struct spi_device *spi)
{
    struct iio_dev *indio_dev;
    indio_dev = ad7606_probe(&spi->dev, spi->irq, NULL,   ------+
               spi_get_device_id(spi)->driver_data,             |
               &ad7606_spi_bops);     ---------+                |
                                               |                |
    if (IS_ERR(indio_dev))                     |                |
        return PTR_ERR(indio_dev);             |                |
                                               |                |
                                               |                |
    spi_set_drvdata(spi, indio_dev);           |                |
                                               |                |
    return 0;                                  |                |
}                                              |                |
                                               V                |
static const struct ad7606_bus_ops ad7606_spi_bops = {          |
    .read_block    = ad7606_spi_read_block,                     |
};                                                              |
                                                                |
drivers/staging/iio/adc/ad7606_core.c                           |
struct iio_dev *ad7606_probe(struct device *dev, int irq,   <---+
                  void __iomem *base_address,
                  unsigned id,
                  const struct ad7606_bus_ops *bops)
{
    struct ad7606_platform_data *pdata = dev->platform_data;
    struct ad7606_state *st;
    int ret, regdone = 0;
    struct iio_dev *indio_dev = iio_allocate_device(sizeof(*st));

    if (indio_dev == NULL) {
        ret = -ENOMEM;
        goto error_ret;
    }

    st = iio_priv(indio_dev);

    st->dev = dev;
    st->id = id;
    st->irq = irq;
    st->bops = bops;
    st->base_address = base_address;
    // 默认的模拟通道输入电压范围, 10V/5V
    st->range = pdata->default_range == 10000 ? 10000 : 5000;
    // 过采样率
    ret = ad7606_oversampling_get_index(pdata->default_os);
    if (ret < 0) {
        dev_warn(dev, "oversampling %d is not supported\n",
             pdata->default_os);
        st->oversampling = 0;
    } else {
        st->oversampling = pdata->default_os;
    }

    st->reg = regulator_get(dev, "vcc");
    if (!IS_ERR(st->reg)) {
        ret = regulator_enable(st->reg);
        if (ret)
            goto error_put_reg;
    }

    st->pdata = pdata;
    st->chip_info = &ad7606_chip_info_tbl[id];   -----------------------------+
                                                                              |
    indio_dev->dev.parent = dev;                                              |
    indio_dev->info = &ad7606_info;                                           |
    indio_dev->modes = INDIO_DIRECT_MODE;                                     |
    indio_dev->name = st->chip_info->name;                                    |
    indio_dev->channels = st->chip_info->channels;                            |
    indio_dev->num_channels = st->chip_info->num_channels;                    |
                                                                              |
    init_waitqueue_head(&st->wq_data_avail);                                  |
                                                                              |
    ret = ad7606_request_gpios(st);        -------------------------------+   |
    if (ret)                                                              |   |
        goto error_disable_reg;                                           |   |
                                                                          |   |
                                                                          |   |
    ret = ad7606_reset(st);                                               |   |
    if (ret)                                                              |   |
        dev_warn(st->dev, "failed to RESET: no RESET GPIO specified\n");  |   |
    // ad7606中断，我使用的是busy引脚作为中断输入。                       |   |
    ret = request_irq(st->irq, ad7606_interrupt,            -------+      |   |
        IRQF_TRIGGER_FALLING, st->chip_info->name, indio_dev);     |      |   |
    if (ret)                                                       |      |   |
        goto error_free_gpios;                                     |      |   |
                                                                   |      |   |
    ret = ad7606_register_ring_funcs_and_init(indio_dev);          |      |   |
    if (ret)                                                       |      |   |
        goto error_free_irq;                                       |      |   |
                                                                   |      |   |
    ret = iio_device_register(indio_dev);                          |      |   |
    if (ret)                                                       |      |   |
        goto error_free_irq;                                       |      |   |
    regdone = 1;                                                   |      |   |
                                                                   |      |   |
    ret = iio_ring_buffer_register_ex(indio_dev->ring, 0,          |      |   |
                      indio_dev->channels,                         |      |   |
                      indio_dev->num_channels);                    |      |   |
    if (ret)                                                       |      |   |
        goto error_cleanup_ring;                                   |      |   |
                                                                   |      |   |
    return indio_dev;                                              |      |   |
                                                                   |      |   |
error_cleanup_ring:                                                |      |   |
    ad7606_ring_cleanup(indio_dev);                                |      |   |
                                                                   |      |   |
error_free_irq:                                                    |      |   |
    free_irq(st->irq, indio_dev);                                  |      |   |
                                                                   |      |   |
error_free_gpios:                                                  |      |   |
    ad7606_free_gpios(st);                                         |      |   |
                                                                   |      |   |
error_disable_reg:                                                 |      |   |
    if (!IS_ERR(st->reg))                                          |      |   |
        regulator_disable(st->reg);                                |      |   |
error_put_reg:                                                     |      |   |
    if (!IS_ERR(st->reg))                                          |      |   |
        regulator_put(st->reg);                                    |      |   |
    if (regdone)                                                   |      |   |
        iio_device_unregister(indio_dev);                          |      |   |
    else                                                           |      |   |
        iio_free_device(indio_dev);                                |      |   |
error_ret:                                                         |      |   |
    return ERR_PTR(ret);                                           |      |   |
}                                                                  |      |   |
                                                                   |      |   |
// 中断处理函数                                                    |      |   |
static irqreturn_t ad7606_interrupt(int irq, void *dev_id)     <---+      |   |
{                                                                         |   |
    struct iio_dev *indio_dev = dev_id;                                   |   |
    struct ad7606_state *st = iio_priv(indio_dev);                        |   |
                                                                          |   |
    if (iio_ring_enabled(indio_dev)) {                                    |   |
        if (!work_pending(&st->poll_work))                                |   |
            schedule_work(&st->poll_work);                                |   |
    } else {                                                              |   |
        st->done = true;                                                  |   |
        // 唤醒中断                                                       |   |
        wake_up_interruptible(&st->wq_data_avail);                        |   |
    }                                                                     |   |
                                                                          |   |
    return IRQ_HANDLED;                                                   |   |
};                                                                        |   |
static int ad7606_request_gpios(struct ad7606_state *st)       <----------+   |
{                                                                             |
    struct gpio gpio_array[3] = {                                             |
        [0] = {                                                               |
            .gpio =  st->pdata->gpio_os0,                                     |
            .flags = GPIOF_DIR_OUT | ((st->oversampling & 1) ?                |
                 GPIOF_INIT_HIGH : GPIOF_INIT_LOW),                           |
            .label = "AD7606_OS0",                                            |
        },                                                                    |
        [1] = {                                                               |
            .gpio =  st->pdata->gpio_os1,                                     |
            .flags = GPIOF_DIR_OUT | ((st->oversampling & 2) ?                |
                 GPIOF_INIT_HIGH : GPIOF_INIT_LOW),                           |
            .label = "AD7606_OS1",                                            |
        },                                                                    |
        [2] = {                                                               |
            .gpio =  st->pdata->gpio_os2,                                     |
            .flags = GPIOF_DIR_OUT | ((st->oversampling & 4) ?                |
                 GPIOF_INIT_HIGH : GPIOF_INIT_LOW),                           |
            .label = "AD7606_OS2",                                            |
        },                                                                    |
    };                                                                        |
    int ret;                                                                  |
                                                                              |
    ret = gpio_request_one(st->pdata->gpio_convst, GPIOF_OUT_INIT_LOW,        |
                   "AD7606_CONVST");                                          |
    if (ret) {                                                                |
        dev_err(st->dev, "failed to request GPIO CONVST\n");                  |
        return ret;                                                           |
    }                                                                         |
                                                                              |
    ret = gpio_request_array(gpio_array, ARRAY_SIZE(gpio_array));             |
    if (!ret) {                                                               |
        st->have_os = true;                                                   |
    }                                                                         |
                                                                              |
    ret = gpio_request_one(st->pdata->gpio_reset, GPIOF_OUT_INIT_LOW,         |
                   "AD7606_RESET");                                           |
    if (!ret)                                                                 |
        st->have_reset = true;                                                |
                                                                              |
    ret = gpio_request_one(st->pdata->gpio_range, GPIOF_DIR_OUT |             |
                ((st->range == 10000) ? GPIOF_INIT_HIGH :                     |
                GPIOF_INIT_LOW), "AD7606_RANGE");                             |
    if (!ret)                                                                 |
        st->have_range = true;                                                |
                                                                              |
    ret = gpio_request_one(st->pdata->gpio_stby, GPIOF_OUT_INIT_HIGH,         |
                   "AD7606_STBY");                                            |
    if (!ret)                                                                 |
        st->have_stby = true;                                                 |
    // 是否定义了gpio_frstdata,没有定义就是-1.                                |
    // 我调试的时候这个信号有问题，所以就设置成-1.st->have_frstdata=false     |
    if (gpio_is_valid(st->pdata->gpio_frstdata)) {                            |
        ret = gpio_request_one(st->pdata->gpio_frstdata, GPIOF_IN,            |
                       "AD7606_FRSTDATA");                                    |
        if (!ret)                                                             |
            st->have_frstdata = true;                                         |
    }                                                                         |
                                                                              |
    return 0;                                                                 |
}                                                                             |
                                                                              |
static const struct ad7606_chip_info ad7606_chip_info_tbl[] = {        <------+
    /*
     * More devices added in future
     */
    [ID_AD7606_8] = {
        .name = "ad7606",
        .int_vref_mv = 2500,
        .channels = ad7606_8_channels,
        .num_channels = 8,
    },
    [ID_AD7606_6] = {
        .name = "ad7606-6",
        .int_vref_mv = 2500,
        .channels = ad7606_6_channels,
        .num_channels = 6,
    },
    [ID_AD7606_4] = {
        .name = "ad7606-4",
        .int_vref_mv = 2500,
        .channels = ad7606_4_channels,
        .num_channels = 4,
    },
};

static int ad7606_oversampling_get_index(unsigned val)
{
    unsigned char supported[] = {0, 2, 4, 8, 16, 32, 64};
    int i;

    for (i = 0; i < ARRAY_SIZE(supported); i++)
        if (val == supported[i])
            return i;

    return -EINVAL;
}

//应用层读取的时候会调用这个函数。
static int ad7606_read_raw(struct iio_dev *indio_dev,
               struct iio_chan_spec const *chan,
               int *val,
               int *val2,
               long m)
{
    int ret;
    struct ad7606_state *st = iio_priv(indio_dev);
    unsigned int scale_uv;

    switch (m) {
    case 0:
        mutex_lock(&indio_dev->mlock);
        if (iio_ring_enabled(indio_dev))
            ret = ad7606_scan_from_ring(indio_dev, chan->address);
        else
            ret = ad7606_scan_direct(indio_dev, chan->address);          ------+
        mutex_unlock(&indio_dev->mlock);                                       |
                                                                               |
        if (ret < 0)                                                           |
            return ret;                                                        |
        *val = (short) ret;                                                    |
        return IIO_VAL_INT;                                                    |
    case (1 << IIO_CHAN_INFO_SCALE_SHARED):                                    |
        scale_uv = (st->range * 1000 * 2)                                      |
            >> st->chip_info->channels[0].scan_type.realbits;                  |
        *val =  scale_uv / 1000;                                               |
        *val2 = (scale_uv % 1000) * 1000;                                      |
        return IIO_VAL_INT_PLUS_MICRO;                                         |
    }                                                                          |
    return -EINVAL;                                                            |
}                                                                              |
                                                                               |
static int ad7606_scan_direct(struct iio_dev *indio_dev, unsigned ch)     <----+
{
    struct ad7606_state *st = iio_priv(indio_dev);
    int ret;

    st->done = false;
    gpio_set_value(st->pdata->gpio_convst, 1);

    // 此处中断, 等待中断调用ad7606_interrupt函数唤醒中断。
    ret = wait_event_interruptible(st->wq_data_avail, st->done);
    if (ret)
        goto error_ret;
    // 判断have_frstdata是否为true
    if (st->have_frstdata) {
        ret = st->bops->read_block(st->dev, 1, st->data);
        if (ret)
            goto error_ret;
        if (!gpio_get_value(st->pdata->gpio_frstdata)) {
            /* This should never happen */
            ad7606_reset(st);
            ret = -EIO;
            goto error_ret;
        }
        ret = st->bops->read_block(st->dev,
            st->chip_info->num_channels - 1, &st->data[1]);
        if (ret){
            goto error_ret;
    } else {
        ret = st->bops->read_block(st->dev,
            st->chip_info->num_channels, st->data);
        if (ret)
            goto error_ret;
    }

    ret = st->data[ch];

error_ret:
    gpio_set_value(st->pdata->gpio_convst, 0);

    return ret;
}

static int ad7606_spi_read_block(struct device *dev,
                 int count, void *buf)
{
    struct spi_device *spi = to_spi_device(dev);
    int i, ret;
    unsigned short *data = buf;

    ret = spi_read(spi, (u8 *)buf, count * 2);
    if (ret < 0) {
        dev_err(&spi->dev, "SPI read error\n");
        return ret;
    }

    for (i = 0; i < count; i++) {
        data[i] = be16_to_cpu(data[i]);
    }

    return 0;
}

include/linux/spi/spi.h
static inline int
spi_read(struct spi_device *spi, void *buf, size_t len)
{
	struct spi_transfer	t = {
			.rx_buf		= buf,
			.len		= len,
		};
	struct spi_message	m;

	spi_message_init(&m);
	spi_message_add_tail(&t, &m);
	return spi_sync(spi, &m);
}

Tony Liu

2017-1-13, Shenzhen