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

主要文件

drivers/staging/iio/adc/ad7606_spi.c

drivers/staging/iio/adc/ad7606_core.c

drivers/staging/iio/adc/ad7606_ring.c

  1. drivers/staging/iio/adc/ad7606_spi.c
  3. static int __init ad7606_spi_init(void)
  4. {
  5.     return spi_register_driver(&ad7606_driver);
  6. }
  7. module_init(ad7606_spi_init);
  9. static struct spi_driver ad7606_driver = {
  10.     .driver = {
  11.         .name = "ad7606",
  12.         .bus = &spi_bus_type,
  13.         .owner = THIS_MODULE,
  14.         .pm    = AD7606_SPI_PM_OPS,
  15.     },
  16.     .probe = ad7606_spi_probe,
  17.     .remove = __devexit_p(ad7606_spi_remove),
  18.     .id_table = ad7606_id,
  19. };
  21. static int __devinit ad7606_spi_probe(struct spi_device *spi)
  22. {
  23.     struct iio_dev *indio_dev;
  24.     indio_dev = ad7606_probe(&spi->dev, spi->irq, NULL,   ------+
  25.                spi_get_device_id(spi)->driver_data,             |
  26.                &ad7606_spi_bops);     ---------+                |
  27.                                                |                |
  28.     if (IS_ERR(indio_dev))                     |                |
  29.         return PTR_ERR(indio_dev);             |                |
  30.                                                |                |
  31.                                                |                |
  32.     spi_set_drvdata(spi, indio_dev);           |                |
  33.                                                |                |
  34.     return 0;                                  |                |
  35. }                                              |                |
  36.                                                V                |
  37. static const struct ad7606_bus_ops ad7606_spi_bops = {          |
  38.     .read_block    = ad7606_spi_read_block,                     |
  39. };                                                              |
  40.                                                                 |
  41. drivers/staging/iio/adc/ad7606_core.c                           |
  42. struct iio_dev *ad7606_probe(struct device *dev, int irq,   <---+
  43.                   void __iomem *base_address,
  44.                   unsigned id,
  45.                   const struct ad7606_bus_ops *bops)
  46. {
  47.     struct ad7606_platform_data *pdata = dev->platform_data;
  48.     struct ad7606_state *st;
  49.     int ret, regdone = 0;
  50.     struct iio_dev *indio_dev = iio_allocate_device(sizeof(*st));
  52.     if (indio_dev == NULL) {
  53.         ret = -ENOMEM;
  54.         goto error_ret;
  55.     }
  57.     st = iio_priv(indio_dev);
  59.     st->dev = dev;
  60.     st->id = id;
  61.     st->irq = irq;
  62.     st->bops = bops;
  63.     st->base_address = base_address;
  64.     // 默认的模拟通道输入电压范围, 10V/5V
  65.     st->range = pdata->default_range == 10000 ? 10000 : 5000;
  66.     // 过采样率
  67.     ret = ad7606_oversampling_get_index(pdata->default_os);
  68.     if (ret < 0) {
  69.         dev_warn(dev, "oversampling %d is not supported\n",
  70.              pdata->default_os);
  71.         st->oversampling = 0;
  72.     } else {
  73.         st->oversampling = pdata->default_os;
  74.     }
  76.     st->reg = regulator_get(dev, "vcc");
  77.     if (!IS_ERR(st->reg)) {
  78.         ret = regulator_enable(st->reg);
  79.         if (ret)
  80.             goto error_put_reg;
  81.     }
  83.     st->pdata = pdata;
  84.     st->chip_info = &ad7606_chip_info_tbl[id];   -----------------------------+
  85.                                                                               |
  86.     indio_dev->dev.parent = dev;                                              |
  87.     indio_dev->info = &ad7606_info;                                           |
  88.     indio_dev->modes = INDIO_DIRECT_MODE;                                     |
  89.     indio_dev->name = st->chip_info->name;                                    |
  90.     indio_dev->channels = st->chip_info->channels;                            |
  91.     indio_dev->num_channels = st->chip_info->num_channels;                    |
  92.                                                                               |
  93.     init_waitqueue_head(&st->wq_data_avail);                                  |
  94.                                                                               |
  95.     ret = ad7606_request_gpios(st);        -------------------------------+   |
  96.     if (ret)                                                              |   |
  97.         goto error_disable_reg;                                           |   |
  98.                                                                           |   |
  99.                                                                           |   |
  100.     ret = ad7606_reset(st);                                               |   |
  101.     if (ret)                                                              |   |
  102.         dev_warn(st->dev, "failed to RESET: no RESET GPIO specified\n");  |   |
  103.     // ad7606中断，我使用的是busy引脚作为中断输入。                       |   |
  104.     ret = request_irq(st->irq, ad7606_interrupt,            -------+      |   |
  105.         IRQF_TRIGGER_FALLING, st->chip_info->name, indio_dev);     |      |   |
  106.     if (ret)                                                       |      |   |
  107.         goto error_free_gpios;                                     |      |   |
  108.                                                                    |      |   |
  109.     ret = ad7606_register_ring_funcs_and_init(indio_dev);          |      |   |
  110.     if (ret)                                                       |      |   |
  111.         goto error_free_irq;                                       |      |   |
  112.                                                                    |      |   |
  113.     ret = iio_device_register(indio_dev);                          |      |   |
  114.     if (ret)                                                       |      |   |
  115.         goto error_free_irq;                                       |      |   |
  116.     regdone = 1;                                                   |      |   |
  117.                                                                    |      |   |
  118.     ret = iio_ring_buffer_register_ex(indio_dev->ring, 0,          |      |   |
  119.                       indio_dev->channels,                         |      |   |
  120.                       indio_dev->num_channels);                    |      |   |
  121.     if (ret)                                                       |      |   |
  122.         goto error_cleanup_ring;                                   |      |   |
  123.                                                                    |      |   |
  124.     return indio_dev;                                              |      |   |
  125.                                                                    |      |   |
  126. error_cleanup_ring:                                                |      |   |
  127.     ad7606_ring_cleanup(indio_dev);                                |      |   |
  128.                                                                    |      |   |
  129. error_free_irq:                                                    |      |   |
  130.     free_irq(st->irq, indio_dev);                                  |      |   |
  131.                                                                    |      |   |
  132. error_free_gpios:                                                  |      |   |
  133.     ad7606_free_gpios(st);                                         |      |   |
  134.                                                                    |      |   |
  135. error_disable_reg:                                                 |      |   |
  136.     if (!IS_ERR(st->reg))                                          |      |   |
  137.         regulator_disable(st->reg);                                |      |   |
  138. error_put_reg:                                                     |      |   |
  139.     if (!IS_ERR(st->reg))                                          |      |   |
  140.         regulator_put(st->reg);                                    |      |   |
  141.     if (regdone)                                                   |      |   |
  142.         iio_device_unregister(indio_dev);                          |      |   |
  143.     else                                                           |      |   |
  144.         iio_free_device(indio_dev);                                |      |   |
  145. error_ret:                                                         |      |   |
  146.     return ERR_PTR(ret);                                           |      |   |
  147. }                                                                  |      |   |
  148.                                                                    |      |   |
  149. // 中断处理函数                                                    |      |   |
  150. static irqreturn_t ad7606_interrupt(int irq, void *dev_id)     <---+      |   |
  151. {                                                                         |   |
  152.     struct iio_dev *indio_dev = dev_id;                                   |   |
  153.     struct ad7606_state *st = iio_priv(indio_dev);                        |   |
  154.                                                                           |   |
  155.     if (iio_ring_enabled(indio_dev)) {                                    |   |
  156.         if (!work_pending(&st->poll_work))                                |   |
  157.             schedule_work(&st->poll_work);                                |   |
  158.     } else {                                                              |   |
  159.         st->done = true;                                                  |   |
  160.         // 唤醒中断                                                       |   |
  161.         wake_up_interruptible(&st->wq_data_avail);                        |   |
  162.     }                                                                     |   |
  163.                                                                           |   |
  164.     return IRQ_HANDLED;                                                   |   |
  165. };                                                                        |   |
  166. static int ad7606_request_gpios(struct ad7606_state *st)       <----------+   |
  167. {                                                                             |
  168.     struct gpio gpio_array[3] = {                                             |
  169.         [0] = {                                                               |
  170.             .gpio =  st->pdata->gpio_os0,                                     |
  171.             .flags = GPIOF_DIR_OUT | ((st->oversampling & 1) ?                |
  172.                  GPIOF_INIT_HIGH : GPIOF_INIT_LOW),                           |
  173.             .label = "AD7606_OS0",                                            |
  174.         },                                                                    |
  175.         [1] = {                                                               |
  176.             .gpio =  st->pdata->gpio_os1,                                     |
  177.             .flags = GPIOF_DIR_OUT | ((st->oversampling & 2) ?                |
  178.                  GPIOF_INIT_HIGH : GPIOF_INIT_LOW),                           |
  179.             .label = "AD7606_OS1",                                            |
  180.         },                                                                    |
  181.         [2] = {                                                               |
  182.             .gpio =  st->pdata->gpio_os2,                                     |
  183.             .flags = GPIOF_DIR_OUT | ((st->oversampling & 4) ?                |
  184.                  GPIOF_INIT_HIGH : GPIOF_INIT_LOW),                           |
  185.             .label = "AD7606_OS2",                                            |
  186.         },                                                                    |
  187.     };                                                                        |
  188.     int ret;                                                                  |
  189.                                                                               |
  190.     ret = gpio_request_one(st->pdata->gpio_convst, GPIOF_OUT_INIT_LOW,        |
  191.                    "AD7606_CONVST");                                          |
  192.     if (ret) {                                                                |
  193.         dev_err(st->dev, "failed to request GPIO CONVST\n");                  |
  194.         return ret;                                                           |
  195.     }                                                                         |
  196.                                                                               |
  197.     ret = gpio_request_array(gpio_array, ARRAY_SIZE(gpio_array));             |
  198.     if (!ret) {                                                               |
  199.         st->have_os = true;                                                   |
  200.     }                                                                         |
  201.                                                                               |
  202.     ret = gpio_request_one(st->pdata->gpio_reset, GPIOF_OUT_INIT_LOW,         |
  203.                    "AD7606_RESET");                                           |
  204.     if (!ret)                                                                 |
  205.         st->have_reset = true;                                                |
  206.                                                                               |
  207.     ret = gpio_request_one(st->pdata->gpio_range, GPIOF_DIR_OUT |             |
  208.                 ((st->range == 10000) ? GPIOF_INIT_HIGH :                     |
  209.                 GPIOF_INIT_LOW), "AD7606_RANGE");                             |
  210.     if (!ret)                                                                 |
  211.         st->have_range = true;                                                |
  212.                                                                               |
  213.     ret = gpio_request_one(st->pdata->gpio_stby, GPIOF_OUT_INIT_HIGH,         |
  214.                    "AD7606_STBY");                                            |
  215.     if (!ret)                                                                 |
  216.         st->have_stby = true;                                                 |
  217.     // 是否定义了gpio_frstdata,没有定义就是-1.                                |
  218.     // 我调试的时候这个信号有问题，所以就设置成-1.st->have_frstdata=false     |
  219.     if (gpio_is_valid(st->pdata->gpio_frstdata)) {                            |
  220.         ret = gpio_request_one(st->pdata->gpio_frstdata, GPIOF_IN,            |
  221.                        "AD7606_FRSTDATA");                                    |
  222.         if (!ret)                                                             |
  223.             st->have_frstdata = true;                                         |
  224.     }                                                                         |
  225.                                                                               |
  226.     return 0;                                                                 |
  227. }                                                                             |
  228.                                                                               |
  229. static const struct ad7606_chip_info ad7606_chip_info_tbl[] = {        <------+
  230.     /*
  231.      * More devices added in future
  232.      */
  233.     [ID_AD7606_8] = {
  234.         .name = "ad7606",
  235.         .int_vref_mv = 2500,
  236.         .channels = ad7606_8_channels,
  237.         .num_channels = 8,
  238.     },
  239.     [ID_AD7606_6] = {
  240.         .name = "ad7606-6",
  241.         .int_vref_mv = 2500,
  242.         .channels = ad7606_6_channels,
  243.         .num_channels = 6,
  244.     },
  245.     [ID_AD7606_4] = {
  246.         .name = "ad7606-4",
  247.         .int_vref_mv = 2500,
  248.         .channels = ad7606_4_channels,
  249.         .num_channels = 4,
  250.     },
  251. };
  253. static int ad7606_oversampling_get_index(unsigned val)
  254. {
  255.     unsigned char supported[] = {0, 2, 4, 8, 16, 32, 64};
  256.     int i;
  258.     for (i = 0; i < ARRAY_SIZE(supported); i++)
  259.         if (val == supported[i])
  260.             return i;
  262.     return -EINVAL;
  263. }
  265. //应用层读取的时候会调用这个函数。
  266. static int ad7606_read_raw(struct iio_dev *indio_dev,
  267.                struct iio_chan_spec const *chan,
  268.                int *val,
  269.                int *val2,
  270.                long m)
  271. {
  272.     int ret;
  273.     struct ad7606_state *st = iio_priv(indio_dev);
  274.     unsigned int scale_uv;
  276.     switch (m) {
  277.     case 0:
  278.         mutex_lock(&indio_dev->mlock);
  279.         if (iio_ring_enabled(indio_dev))
  280.             ret = ad7606_scan_from_ring(indio_dev, chan->address);
  281.         else
  282.             ret = ad7606_scan_direct(indio_dev, chan->address);          ------+
  283.         mutex_unlock(&indio_dev->mlock);                                       |
  284.                                                                                |
  285.         if (ret < 0)                                                           |
  286.             return ret;                                                        |
  287.         *val = (short) ret;                                                    |
  288.         return IIO_VAL_INT;                                                    |
  289.     case (1 << IIO_CHAN_INFO_SCALE_SHARED):                                    |
  290.         scale_uv = (st->range * 1000 * 2)                                      |
  291.             >> st->chip_info->channels[0].scan_type.realbits;                  |
  292.         *val =  scale_uv / 1000;                                               |
  293.         *val2 = (scale_uv % 1000) * 1000;                                      |
  294.         return IIO_VAL_INT_PLUS_MICRO;                                         |
  295.     }                                                                          |
  296.     return -EINVAL;                                                            |
  297. }                                                                              |
  298.                                                                                |
  299. static int ad7606_scan_direct(struct iio_dev *indio_dev, unsigned ch)     <----+
  300. {
  301.     struct ad7606_state *st = iio_priv(indio_dev);
  302.     int ret;
  304.     st->done = false;
  305.     gpio_set_value(st->pdata->gpio_convst, 1);
  307.     // 此处中断, 等待中断调用ad7606_interrupt函数唤醒中断。
  308.     ret = wait_event_interruptible(st->wq_data_avail, st->done);
  309.     if (ret)
  310.         goto error_ret;
  311.     // 判断have_frstdata是否为true
  312.     if (st->have_frstdata) {
  313.         ret = st->bops->read_block(st->dev, 1, st->data);
  314.         if (ret)
  315.             goto error_ret;
  316.         if (!gpio_get_value(st->pdata->gpio_frstdata)) {
  317.             /* This should never happen */
  318.             ad7606_reset(st);
  319.             ret = -EIO;
  320.             goto error_ret;
  321.         }
  322.         ret = st->bops->read_block(st->dev,
  323.             st->chip_info->num_channels - 1, &st->data[1]);
  324.         if (ret){
  325.             goto error_ret;
  326.     } else {
  327.         ret = st->bops->read_block(st->dev,
  328.             st->chip_info->num_channels, st->data);
  329.         if (ret)
  330.             goto error_ret;
  331.     }
  333.     ret = st->data[ch];
  335. error_ret:
  336.     gpio_set_value(st->pdata->gpio_convst, 0);
  338.     return ret;
  339. }
  341. static int ad7606_spi_read_block(struct device *dev,
  342.                  int count, void *buf)
  343. {
  344.     struct spi_device *spi = to_spi_device(dev);
  345.     int i, ret;
  346.     unsigned short *data = buf;
  348.     ret = spi_read(spi, (u8 *)buf, count * 2);
  349.     if (ret < 0) {
  350.         dev_err(&spi->dev, "SPI read error\n");
  351.         return ret;
  352.     }
  354.     for (i = 0; i < count; i++) {
  355.         data[i] = be16_to_cpu(data[i]);
  356.     }
  358.     return 0;
  359. }
  361. include/linux/spi/spi.h
  362. static inline int
  363. spi_read(struct spi_device *spi, void *buf, size_t len)
  364. {
  365. 	struct spi_transfer	t = {
  366. 			.rx_buf		= buf,
  367. 			.len		= len,
  368. 		};
  369. 	struct spi_message	m;
  371. 	spi_message_init(&m);
  372. 	spi_message_add_tail(&t, &m);
  373. 	return spi_sync(spi, &m);
  374. }

Tony Liu

2017-1-13, Shenzhen

linux ad7606 驱动解读的更多相关文章

  1. Linux ad7606 驱动

    Linux中已经移植好了ad7606,位于driver/staging/iio/adc/目录中.只要在板级文件中添加device中即可. 移植参考文档: https://wiki.analog.com ...

  2. Linux网络驱动--snull

    snull是<Linux Device Drivers>中的一个网络驱动的例子.这里引用这个例子学习Linux网络驱动. 因为snull的源码,网上已经更新到适合最新内核,而我自己用的还是 ...

  3. 浅谈Android系统移植、Linux设备驱动

    一.Android系统架构 第一层:Linux内核 包括驱动程序,管理内存.进程.电源等资源的程序 第二层:C/C++代码库 包括Linux的.so文件以及嵌入到APK程序中的NDK代码 第三层:An ...

  4. Linux设备驱动模型之I2C总线

    一.I2C子系统总体架构 1.三大组成部分 (1)I2C核心(i2c-core):I2C核心提供了I2C总线驱动(适配器)和设备驱动的注册.注销方法,提供了与具体硬件无关的I2C读写函数. (2)I2 ...

  5. linux设备驱动概述,王明学learn

    linux设备驱动学习-1 本章节主要学习有操作系统的设备驱动和无操作系统设备驱动的区别,以及对操作系统和设备驱动关系的认识. 一.设备驱动的作用 对设备驱动最通俗的解释就是“驱使硬件设备行动” .设 ...

  6. Smart210学习记录------linux串口驱动

    转自:http://blog.chinaunix.net/xmlrpc.php?r=blog/article&uid=27025492&id=327609 一.核心数据结构 串口驱动有 ...

  7. linux网卡驱动移植

    这里重要的是物理层PHY receiver,MAC(media access control)层,这里与软件中的协议栈不同,在硬件上MAC是PHY的下一层.DM9000A将MAC和PHY做到一起,也可 ...

  8. Linux USB驱动

    linux usb 驱动详解 一 http://blog.163.com/cl2006ky@126/blog/static/87195173201131245557340/ USB设备驱动开发-USB ...

  9. 我就是认真：Linux SWAP 深度解读（必须收藏）

    我就是认真:Linux SWAP 深度解读(必须收藏) http://mp.weixin.qq.com/s?__biz=MzA4Nzg5Nzc5OA==&mid=2651660097& ...

随机推荐

  1. 安装R语言的包的方法

    安装R语言的包的方法: 1. 在线安装 在R的控制台,输入类似install.packages("TSA")  # 安装 TSA install.packages("TS ...

  2. 两种方式— 在hive SQL中传入参数

    第一种: sql = sql.format(dt=dt) 第二种: item_third_cate_cd_list = " 发发发 " ...... ""&qu ...

  3. python标准库介绍——20 cStringIO 模块详解

    ==cStringIO 模块== ``cStringIO`` 是一个可选的模块, 是 ``StringIO`` 的更快速实现. 它的工作方式和 ``StringIO`` 基本相同, 但是它不可以被继承 ...

  4. Google大牛分享的面试秘籍

    我憋了很长时间想写点关于去Google面试的秘籍.不过我总是推迟,因为写出来的东西会让你抓狂.很可能是这样.如果按统计规律来定义“你”的话,这文章很可能让你不爽. 为啥呢?因为啊……好吧,对此我写首小 ...

  5. cocos2dx当节点存在缩放时要注意的问题

    cocos2dx(所有引擎也均如此),如果一个节点存在缩放,一定不要忘了其局部空间里的单位长度也会发生变化.其子节点位移,局部空间转世界空间结果等都会受影响. 有时候我们想将父节点的缩放转移到子节点中 ...

  6. rabbitmq增加vhost

    查看当前rabbitmq上的vhost列表: # rabbitmqctl list_vhosts Listing vhosts ... / vhost2 添加名为demo的vhost虚似主机: rab ...

  7. C++ 11 auto关键字

    熟悉脚本语言的人都知道,很多脚本语言都引入了“类型自动推断”技术:比如Python,可以直接声明变量,在运行时进行类型检查.随着C++11标准的发布,C++语言也引入了类型自动推断的功能,这就是我们今 ...

  8. 理解 Linux 配置文件

    介绍 每个 Linux 程序都是一个可执行文件,它含有操作码列表,CPU 将执行这些操作码来完成特定的操作.例如,ls 命令是由 /bin/ls 文件提供的,该文件含有机器指令的列表,在屏幕上显示当前 ...

  9. iOS自定义组与组之间的距离以及视图

    iOS自定义组与组之间的距离以及视图 //头视图高度 - (CGFloat)tableView:(UITableView *)tableView heightForHeaderInSection:(N ...

  10. Java – Convert IP address to Decimal Number

    In this tutorial, we show you how to convert an IP address to its decimal equivalent in Java, and vi ...