Linux spi驱动分析(三)----spiddev分析

最新推荐文章于 2025-06-24 21:18:09 发布
最新推荐文章于 2025-06-24 21:18:09 发布
阅读量6.4k 收藏 12
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Linux SPI子系统 文章标签： linux驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/apple_guet/article/details/21449329
本文深入探讨了SPI设备接口在内核中的实现，从驱动层的注册、探测与移除，到应用层的测试程序，详细解释了如何通过SPI设备驱动与应用交互。主要内容包括驱动注册、探测与移除函数的实现，以及数据读写、I/O控制等功能的调用。此外，还展示了如何通过命令行操作SPI设备，设置工作模式、位大小和速率等关键参数。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、spidev简单介绍

        如果在内核中配置spidev，会在“/dev”目录下产生设备节点，通过此节点可以操作挂载在该SPI总线上的设备，接下来将从驱动层和应用层

来分析程序。

二、spidev驱动层

2.1、驱动注册

        分析一个设备驱动，一般都是从module_init和module_exit处开始，本文也不例外，程序如下：

点击(此处)折叠或打开

  1. #define SPIDEV_MAJOR            153    /* assigned */
  2. #define N_SPI_MINORS            32    /* ... up to 256 */

  4. static DECLARE_BITMAP(minors, N_SPI_MINORS);
  5. static struct spi_driver spidev_spi_driver = {
  6.     .driver = {
  7.         .name =        "spidev",
  8.         .owner =    THIS_MODULE,
  9.     },
  10.     .probe =    spidev_probe,
  11.     .remove =    __devexit_p(spidev_remove),

  13.     /* NOTE: suspend/resume methods are not necessary here.
  14.      * We don't do anything except pass the requests to/from
  15.      * the underlying controller. The refrigerator handles
  16.      * most issues; the controller driver handles the rest.
  17.      */
  18. };

  20. /*-------------------------------------------------------------------------*/

  22. static int __init spidev_init(void)
  23. {
  24.     int status;

  26.     /* Claim our 256 reserved device numbers. Then register a class
  27.      * that will key udev/mdev to add/remove /dev nodes. Last, register
  28.      * the driver which manages those device numbers.
  29.      */
  30.     BUILD_BUG_ON(N_SPI_MINORS > 256);
  31.     status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
  32.     if (status < 0)
  33.         return status;

  35.     spidev_class = class_create(THIS_MODULE, "spidev");
  36.     if (IS_ERR(spidev_class)) {
  37.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
  38.         return PTR_ERR(spidev_class);
  39.     }

  41.     status = spi_register_driver(&spidev_spi_driver);
  42.     if (status < 0) {
  43.         class_destroy(spidev_class);
  44.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
  45.     }
  46.     return status;
  47. }
  48. module_init(spidev_init);

  50. static void __exit spidev_exit(void)
  51. {
  52.     spi_unregister_driver(&spidev_spi_driver);
  53.     class_destroy(spidev_class);
  54.     unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
  55. }
  56. module_exit(spidev_exit);

  58. MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
  59. MODULE_DESCRIPTION("User mode SPI device interface");
  60. MODULE_LICENSE("GPL");
  61. MODULE_ALIAS("spi:spidev");

        说明：

        1) 在驱动注册函数中，首先注册函数操作集spidev_fops，该内容将在2.3中具体讲述。

        2) 生成spidev设备类，此类的表现是在“/sys/class”目录下生成一个名为spidev目录。

        3) 注册spi驱动。

        4) 退出函数是注册函数的相反过程，就是释放注册函数中注册的资源。

2.2、探测和移除函数

        探测函数程序如下：

点击(此处)折叠或打开

  1. static int __devinit spidev_probe(struct spi_device *spi)
  2. {
  3.     struct spidev_data    *spidev;
  4.     int            status;
  5.     unsigned long        minor;

  7.     /* Allocate driver data */
  8.     spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
  9.     if (!spidev)
  10.         return -ENOMEM;

  12.     /* Initialize the driver data */
  13.     spidev->spi = spi;
  14.     spin_lock_init(&spidev->spi_lock);
  15.     mutex_init(&spidev->buf_lock);

  17.     INIT_LIST_HEAD(&spidev->device_entry);

  19.     /* If we can allocate a minor number, hook up this device.
  20.      * Reusing minors is fine so long as udev or mdev is working.
  21.      */
  22.     mutex_lock(&device_list_lock);
  23.     minor = find_first_zero_bit(minors, N_SPI_MINORS);
  24.     if (minor < N_SPI_MINORS) {
  25.         struct device *dev;

  27.         spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
  28.         dev = device_create(spidev_class, &spi->dev, spidev->devt,
  29.                  spidev, "spidev%d.%d",
  30.                  spi->master->bus_num, spi->chip_select);
  31.         status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
  32.     } else {
  33.         dev_dbg(&spi->dev, "no minor number available!\n");
  34.         status = -ENODEV;
  35.     }
  36.     if (status == 0) {
  37.         set_bit(minor, minors);
  38.         list_add(&spidev->device_entry, &device_list);
  39.     }
  40.     mutex_unlock(&device_list_lock);

  42.     if (status == 0)
  43.         spi_set_drvdata(spi, spidev);
  44.     else
  45.         kfree(spidev);

  47.     return status;
  48. }

        说明：

        1) 首先声明spidev_data结构体内存。

        2) 初始化其成员变量。

        3) 在位图中寻找第一个未被用到的位。

        4) 如果位图寻找正确，创建“/dev”目录下的设备节点。

        4) 将spidev结构体中的链表插入局部全局链表device_list中，以便在函数操作集中的open函数中使用            

        移除函数如下：

点击(此处)折叠或打开

  1. static int __devexit spidev_remove(struct spi_device *spi)
  2. {
  3.     struct spidev_data    *spidev = spi_get_drvdata(spi);

  5.     /* make sure ops on existing fds can abort cleanly */
  6.     spin_lock_irq(&spidev->spi_lock);
  7.     spidev->spi = NULL;
  8.     spi_set_drvdata(spi, NULL);
  9.     spin_unlock_irq(&spidev->spi_lock);

  11.     /* prevent new opens */
  12.     mutex_lock(&device_list_lock);
  13.     list_del(&spidev->device_entry);
  14.     device_destroy(spidev_class, spidev->devt);
  15.     clear_bit(MINOR(spidev->devt), minors);
  16.     if (spidev->users == 0)
  17.         kfree(spidev);
  18.     mutex_unlock(&device_list_lock);

  20.     return 0;
  21. }

        说明：

        1) 移除函数就是探测函数的相反过程，主要就是释放探测函数中申请的资源。

2.2、函数操作集spidev_fop

        spidev_fop具体如下：

点击(此处)折叠或打开

  1. static const struct file_operations spidev_fops = {
  2.     .owner =    THIS_MODULE,
  3.     /* REVISIT switch to aio primitives, so that userspace
  4.      * gets more complete API coverage. It'll simplify things
  5.      * too, except for the locking.
  6.      */
  7.     .write =    spidev_write,
  8.     .read =        spidev_read,
  9.     .unlocked_ioctl = spidev_ioctl,
  10.     .compat_ioctl = spidev_compat_ioctl,
  11.     .open =        spidev_open,
  12.     .release =    spidev_release,
  13.     .llseek =    no_llseek,
  14. };

        首先看下打开函数spidev_open，程序如下：

点击(此处)折叠或打开

  1. static int spidev_open(struct inode *inode, struct file *filp)
  2. {
  3.     struct spidev_data    *spidev;
  4.     int            status = -ENXIO;

  6.     mutex_lock(&device_list_lock);

  8.     list_for_each_entry(spidev, &device_list, device_entry) {
  9.         if (spidev->devt == inode->i_rdev) {
  10.             status = 0;
  11.             break;
  12.         }
  13.     }
  14.     if (status == 0) {
  15.         if (!spidev->buffer) {
  16.             spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
  17.             if (!spidev->buffer) {
  18.                 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
  19.                 status = -ENOMEM;
  20.             }
  21.         }
  22.         if (status == 0) {
  23.             spidev->users++;
  24.             filp->private_data = spidev;
  25.             nonseekable_open(inode, filp);
  26.         }
  27.     } else
  28.         pr_debug("spidev: nothing for minor %d\n", iminor(inode));

  30.     mutex_unlock(&device_list_lock);
  31.     return status;
  32. }

        说明：

        1) 程序首先上本地全局互斥锁。

        2) 遍历链表device_list，通过设备号找到在探测函数中创建的设备结构体spidev。

        3) 如果寻找成功，将其保存在file的私有成员中，供其他操作集中的函数使用。

        realease函数如下：

点击(此处)折叠或打开

  1. static int spidev_release(struct inode *inode, struct file *filp)
  2. {
  3.     struct spidev_data    *spidev;
  4.     int            status = 0;

  6.     mutex_lock(&device_list_lock);
  7.     spidev = filp->private_data;
  8.     filp->private_data = NULL;

  10.     /* last close? */
  11.     spidev->users--;
  12.     if (!spidev->users) {
  13.         int        dofree;

  15.         kfree(spidev->buffer);
  16.         spidev->buffer = NULL;

  18.         /* ... after we unbound from the underlying device? */
  19.         spin_lock_irq(&spidev->spi_lock);
  20.         dofree = (spidev->spi == NULL);
  21.         spin_unlock_irq(&spidev->spi_lock);

  23.         if (dofree)
  24.             kfree(spidev);
  25.     }
  26.     mutex_unlock(&device_list_lock);

  28.     return status;
  29. }

        说明：

        1) 首先减少使用次数。

        2) 释放传输buf空间。

        3) 释放结构体内存。

        spi读数据函数如下：

点击(此处)折叠或打开

  1. static inline ssize_t
  2. spidev_sync_read(struct spidev_data *spidev, size_t len)
  3. {
  4.     struct spi_transfer    t = {
  5.             .rx_buf        = spidev->buffer,
  6.             .len        = len,
  7.         };
  8.     struct spi_message    m;

  10.     spi_message_init(&m);
  11.     spi_message_add_tail(&t, &m);
  12.     return spidev_sync(spidev, &m);
  13. }
  14. static ssize_t
  15. spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
  16. {
  17.     struct spidev_data    *spidev;
  18.     ssize_t            status = 0;

  20.     /* chipselect only toggles at start or end of operation */
  21.     if (count > bufsiz)
  22.         return -EMSGSIZE;

  24.     spidev = filp->private_data;

  26.     mutex_lock(&spidev->buf_lock);
  27.     status = spidev_sync_read(spidev, count);
  28.     if (status > 0) {
  29.         unsigned long    missing;

  31.         missing = copy_to_user(buf, spidev->buffer, status);
  32.         if (missing == status)
  33.             status = -EFAULT;
  34.         else
  35.             status = status - missing;
  36.     }
  37.     mutex_unlock(&spidev->buf_lock);

  39.     return status;
  40. }

        说明：

        1) 进入读函数中，首先上互斥锁。

        2) 然后调用spidev_sync_read函数读数据。

        3) 如果读取成功，将读取到的数据拷贝到应用层。

        4) 解互斥锁。

        5) 在spidev_sync_read函数中，首先定义一个传输结构体spi_transfer，由于是读操作，所以只初始化其接收buf。

        6) 初始化spi_message，调用函数spidev_sync传输数据，其具体程序如下：

点击(此处)折叠或打开

  1. static ssize_t
  2. spidev_sync(struct spidev_data *spidev, struct spi_message *message)
  3. {
  4.     DECLARE_COMPLETION_ONSTACK(done);
  5.     int status;

  7.     message->complete = spidev_complete;
  8.     message->context = &done;

  10.     spin_lock_irq(&spidev->spi_lock);
  11.     if (spidev->spi == NULL)
  12.         status = -ESHUTDOWN;
  13.     else
  14.         status = spi_async(spidev->spi, message);
  15.     spin_unlock_irq(&spidev->spi_lock);

  17.     if (status == 0) {
  18.         wait_for_completion(&done);
  19.         status = message->status;
  20.         if (status == 0)
  21.             status = message->actual_length;
  22.     }
  23.     return status;
  24. }

        说明：

        1) 首先定义并初始化一个completion。

        2) 上自旋锁，调用spi_async函数传输数据，spi_async就是在Linux核心中提供的传输函数。

        3) 如果调用传输函数成功，则等待。

        3) wait_for_completion(&done);等待传输完成，如果传输正确，函数返回值为传输的字节数。

        函数操作集写函数spidev_write程序如下：

点击(此处)折叠或打开

  1. static inline ssize_t
  2. spidev_sync_write(struct spidev_data *spidev, size_t len)
  3. {
  4.     struct spi_transfer    t = {
  5.             .tx_buf        = spidev->buffer,
  6.             .len        = len,
  7.         };
  8.     struct spi_message    m;

  10.     spi_message_init(&m);
  11.     spi_message_add_tail(&t, &m);
  12.     return spidev_sync(spidev, &m);
  13. }
  14. static ssize_t
  15. spidev_write(struct file *filp, const char __user *buf,
  16.         size_t count, loff_t *f_pos)
  17. {
  18.     struct spidev_data    *spidev;
  19.     ssize_t            status = 0;
  20.     unsigned long        missing;

  22.     /* chipselect only toggles at start or end of operation */
  23.     if (count > bufsiz)
  24.         return -EMSGSIZE;

  26.     spidev = filp->private_data;

  28.     mutex_lock(&spidev->buf_lock);
  29.     missing = copy_from_user(spidev->buffer, buf, count);
  30.     if (missing == 0) {
  31.         status = spidev_sync_write(spidev, count);
  32.     } else
  33.         status = -EFAULT;
  34.     mutex_unlock(&spidev->buf_lock);

  36.     return status;
  37. }

        说明：

        1) 写函数首先上互斥锁，然后从应用层拷贝需要写的数据。

        2) 如果拷贝成功，调用函数spidev_sync_write完成写数据。

        3) 解互斥锁。

        4) spidev_sync_write函数中，首先定义spi_transfer传输结构体，由于是写，此结构体只有tx_buf。

        5) 初始化spi_message，然后调用spidev_sync传输数据，此函数在上面的读操作中已经讲述。

        ioctl函数如下：

点击(此处)折叠或打开

  1. static long
  2. spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  3. {
  4.     int            err = 0;
  5.     int            retval = 0;
  6.     struct spidev_data    *spidev;
  7.     struct spi_device    *spi;
  8.     u32            tmp;
  9.     unsigned        n_ioc;
  10.     struct spi_ioc_transfer    *ioc;

  12.     /* Check type and command number */
  13.     if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
  14.         return -ENOTTY;

  16.     /* Check access direction once here; don't repeat below.
  17.      * IOC_DIR is from the user perspective, while access_ok is
  18.      * from the kernel perspective; so they look reversed.
  19.      */
  20.     if (_IOC_DIR(cmd) & _IOC_READ)
  21.         err = !access_ok(VERIFY_WRITE,
  22.                 (void __user *)arg, _IOC_SIZE(cmd));
  23.     if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
  24.         err = !access_ok(VERIFY_READ,
  25.                 (void __user *)arg, _IOC_SIZE(cmd));
  26.     if (err)
  27.         return -EFAULT;

  29.     /* guard against device removal before, or while,
  30.      * we issue this ioctl.
  31.      */
  32.     spidev = filp->private_data;
  33.     spin_lock_irq(&spidev->spi_lock);
  34.     spi = spi_dev_get(spidev->spi);
  35.     spin_unlock_irq(&spidev->spi_lock);

  37.     if (spi == NULL)
  38.         return -ESHUTDOWN;

  40.     /* use the buffer lock here for triple duty:
  41.      * - prevent I/O (from us) so calling spi_setup() is safe;
  42.      * - prevent concurrent SPI_IOC_WR_* from morphing
  43.      * data fields while SPI_IOC_RD_* reads them;
  44.      * - SPI_IOC_MESSAGE needs the buffer locked "normally".
  45.      */
  46.     mutex_lock(&spidev->buf_lock);

  48.     switch (cmd) {
  49.     /* read requests */
  50.     case SPI_IOC_RD_MODE:
  51.         retval = __put_user(spi->mode & SPI_MODE_MASK,
  52.                     (__u8 __user *)arg);
  53.         break;
  54.     case SPI_IOC_RD_LSB_FIRST:
  55.         retval = __put_user((spi->mode & SPI_LSB_FIRST) ? 1 : 0,
  56.                     (__u8 __user *)arg);
  57.         break;
  58.     case SPI_IOC_RD_BITS_PER_WORD:
  59.         retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
  60.         break;
  61.     case SPI_IOC_RD_MAX_SPEED_HZ:
  62.         retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
  63.         break;

  65.     /* write requests */
  66.     case SPI_IOC_WR_MODE:
  67.         retval = __get_user(tmp, (u8 __user *)arg);
  68.         if (retval == 0) {
  69.             u8    save = spi->mode;

  71.             if (tmp & ~SPI_MODE_MASK) {
  72.                 retval = -EINVAL;
  73.                 break;
  74.             }

  76.             tmp |= spi->mode & ~SPI_MODE_MASK;
  77.             spi->mode = (u8)tmp;
  78.             retval = spi_setup(spi);
  79.             if (retval < 0)
  80.                 spi->mode = save;
  81.             else
  82.                 dev_dbg(&spi->dev, "spi mode %02x\n", tmp);
  83.         }
  84.         break;
  85.     case SPI_IOC_WR_LSB_FIRST:
  86.         retval = __get_user(tmp, (__u8 __user *)arg);
  87.         if (retval == 0) {
  88.             u8    save = spi->mode;

  90.             if (tmp)
  91.                 spi->mode |= SPI_LSB_FIRST;
  92.             else
  93.                 spi->mode &= ~SPI_LSB_FIRST;
  94.             retval = spi_setup(spi);
  95.             if (retval < 0)
  96.                 spi->mode = save;
  97.             else
  98.                 dev_dbg(&spi->dev, "%csb first\n",
  99.                         tmp ? 'l' : 'm');
  100.         }
  101.         break;
  102.     case SPI_IOC_WR_BITS_PER_WORD:
  103.         retval = __get_user(tmp, (__u8 __user *)arg);
  104.         if (retval == 0) {
  105.             u8    save = spi->bits_per_word;

  107.             spi->bits_per_word = tmp;
  108.             retval = spi_setup(spi);
  109.             if (retval < 0)
  110.                 spi->bits_per_word = save;
  111.             else
  112.                 dev_dbg(&spi->dev, "%d bits per word\n", tmp);
  113.         }
  114.         break;
  115.     case SPI_IOC_WR_MAX_SPEED_HZ:
  116.         retval = __get_user(tmp, (__u32 __user *)arg);
  117.         if (retval == 0) {
  118.             u32    save = spi->max_speed_hz;

  120.             spi->max_speed_hz = tmp;
  121.             retval = spi_setup(spi);
  122.             if (retval < 0)
  123.                 spi->max_speed_hz = save;
  124.             else
  125.                 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
  126.         }
  127.         break;

  129.     default:
  130.         /* segmented and/or full-duplex I/O request */
  131.         if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
  132.                 || _IOC_DIR(cmd) != _IOC_WRITE) {
  133.             retval = -ENOTTY;
  134.             break;
  135.         }

  137.         tmp = _IOC_SIZE(cmd);
  138.         if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
  139.             retval = -EINVAL;
  140.             break;
  141.         }
  142.         n_ioc = tmp / sizeof(struct spi_ioc_transfer);
  143.         if (n_ioc == 0)
  144.             break;

  146.         /* copy into scratch area */
  147.         ioc = kmalloc(tmp, GFP_KERNEL);
  148.         if (!ioc) {
  149.             retval = -ENOMEM;
  150.             break;
  151.         }
  152.         if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
  153.             kfree(ioc);
  154.             retval = -EFAULT;
  155.             break;
  156.         }

  158.         /* translate to spi_message, execute */
  159.         retval = spidev_message(spidev, ioc, n_ioc);
  160.         kfree(ioc);
  161.         break;
  162.     }

  164.     mutex_unlock(&spidev->buf_lock);
  165.     spi_dev_put(spi);
  166.     return retval;
  167. }

        说明：

        1) 函数首先判断命令是否有效，如果无效，直接退出。

        2) 上互斥锁。

        3) switch分支中，前面的case都是支持对SPI设备的设置，包括模式、传输位、位方向和最大速率等。

        4) 在设置分支中，最后调用spi_setup实现设置，此函数最终是调用总线驱动中的gsc3280_spi_setup(struct spi_device *spi)

实现设置。

        5) default分支中是进行数据传输的分支，首先判断是否是有效的数据，如果不是，退出switch分支。

        6) 申请内存，复制从应用层传过来的数据。

        7) 调用spidev_message函数实现数据传输。

        8) 解互斥锁，退出。

        spidev_message函数如下：

点击(此处)折叠或打开

  1. static int spidev_message(struct spidev_data *spidev,
  2.         struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
  3. {
  4.     struct spi_message    msg;
  5.     struct spi_transfer    *k_xfers;
  6.     struct spi_transfer    *k_tmp;
  7.     struct spi_ioc_transfer *u_tmp;
  8.     unsigned        n, total;
  9.     u8            *buf;
  10.     int            status = -EFAULT;

  12.     spi_message_init(&msg);
  13.     k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
  14.     if (k_xfers == NULL)
  15.         return -ENOMEM;

  17.     /* Construct spi_message, copying any tx data to bounce buffer.
  18.      * We walk the array of user-provided transfers, using each one
  19.      * to initialize a kernel version of the same transfer.
  20.      */
  21.     buf = spidev->buffer;
  22.     total = 0;
  23.     for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
  24.             n;
  25.             n--, k_tmp++, u_tmp++) {
  26.         k_tmp->len = u_tmp->len;

  28.         total += k_tmp->len;
  29.         if (total > bufsiz) {
  30.             status = -EMSGSIZE;
  31.             goto done;
  32.         }

  34.         if (u_tmp->rx_buf) {
  35.             k_tmp->rx_buf = buf;
  36.             if (!access_ok(VERIFY_WRITE, (u8 __user *)
  37.                         (uintptr_t) u_tmp->rx_buf,
  38.                         u_tmp->len))
  39.                 goto done;
  40.         }
  41.         if (u_tmp->tx_buf) {
  42.             k_tmp->tx_buf = buf;
  43.             if (copy_from_user(buf, (const u8 __user *)
  44.                         (uintptr_t) u_tmp->tx_buf,
  45.                     u_tmp->len))
  46.                 goto done;
  47.         }
  48.         buf += k_tmp->len;

  50.         k_tmp->cs_change = !!u_tmp->cs_change;
  51.         k_tmp->bits_per_word = u_tmp->bits_per_word;
  52.         k_tmp->delay_usecs = u_tmp->delay_usecs;
  53.         k_tmp->speed_hz = u_tmp->speed_hz;
  54. #ifdef VERBOSE
  55.         dev_dbg(&spidev->spi->dev,
  56.             " xfer len %zd %s%s%s%dbits %u usec %uHz\n",
  57.             u_tmp->len,
  58.             u_tmp->rx_buf ? "rx " : "",
  59.             u_tmp->tx_buf ? "tx " : "",
  60.             u_tmp->cs_change ? "cs " : "",
  61.             u_tmp->bits_per_word ? : spidev->spi->bits_per_word,
  62.             u_tmp->delay_usecs,
  63.             u_tmp->speed_hz ? : spidev->spi->max_speed_hz);
  64. #endif
  65.         spi_message_add_tail(k_tmp, &msg);
  66.     }

  68.     status = spidev_sync(spidev, &msg);
  69.     if (status < 0)
  70.         goto done;

  72.     /* copy any rx data out of bounce buffer */
  73.     buf = spidev->buffer;
  74.     for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
  75.         if (u_tmp->rx_buf) {
  76.             if (__copy_to_user((u8 __user *)
  77.                     (uintptr_t) u_tmp->rx_buf, buf,
  78.                     u_tmp->len)) {
  79.                 status = -EFAULT;
  80.                 goto done;
  81.             }
  82.         }
  83.         buf += u_tmp->len;
  84.     }
  85.     status = total;

  87. done:
  88.     kfree(k_xfers);
  89.     return status;
  90. }

        说明：

        1) 申请传输的结构体内存。

        2) 通过for循环，对spi_ioc_transfer类型的数据进行转换。

        3) 转换中，首先对本次传输的数据大小进行累计，如果总传输量超出buf的大小，直接退出。

        4) 如果本次传输是接收，则设置接收数组，并对buf进行检查，查看是否可读。

        5) 如果本次传输是写，则从应用层拷贝数据。

        6) 对传输中参数进行赋值，包括速度、模式、速率等等。

        7) 调用spidev_sync进行数据传输。

        8) 将接收数据拷贝到应用层。

三、应用层

        在应用层提供了二中驱动的测试程序，在“/documenation/spi”目录下，文件名称为spidev_test.c中，具体程序如下：

点击(此处)折叠或打开

  1. int main(int argc, char *argv[])
  2. {
  3.     int ret = 0;
  4.     int fd;

  6.     parse_opts(argc, argv);

  8.     fd = open(device, O_RDWR);
  9.     if (fd < 0)
  10.         pabort("can't open device");

  12.     /*
  13.      * spi mode
  14.      */
  15.     ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
  16.     if (ret == -1)
  17.         pabort("can't set spi mode");

  19.     ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
  20.     if (ret == -1)
  21.         pabort("can't get spi mode");

  23.     /*
  24.      * bits per word
  25.      */
  26.     ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
  27.     if (ret == -1)
  28.         pabort("can't set bits per word");

  30.     ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
  31.     if (ret == -1)
  32.         pabort("can't get bits per word");

  34.     /*
  35.      * max speed hz
  36.      */
  37.     ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
  38.     if (ret == -1)
  39.         pabort("can't set max speed hz");

  41.     ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
  42.     if (ret == -1)
  43.         pabort("can't get max speed hz");

  45.     printf("spi mode: %d\n", mode);
  46.     printf("bits per word: %d\n", bits);
  47.     printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);

  49.     transfer(fd);

  51.     close(fd);

  53.     return ret;
  54. }

        说明：

        1) 首先打开设备。

        2) 然后设置工作模式、位大小和速率等。

        3) 传输数据


linux spidev 应用_Linux下SPI驱动的移植和应用程序的测试
weixin_39813574的博客
12-21 329
Linux2.6.32下SPI驱动的移植如下图所示：下面需要修改部分内核代码，具体操作如下：1. 修改arch/arm/mach-s3c2440/mach-mini2440.c文件在include头文件代码行之后增加如下代码//spiaddbyshiguang#include#includestaticstructspi_board_infos3c2410_spi0_board...
【kernel8】spi
最新发布
openbmc
07-01 750
如下7位地址码不同的排列组合就有2的7次方=128种，正好访问存储器的128个字节。如下第一行是不是休眠唤醒，pdev->id是3，mode_bit默认都是0，需不需要填充，set_cs下面都是函数的回调函数，个字节（不是FF十进制255个字节），每个字节都有属于自己的地址，那怎么读取这1024位数据呢？下面dtsi描述的就是spi控制器，控制器也是驱动，一旦status设为ok，则用default，pinctrl-0。如下解析内存相关，获取设备树的reg，再做ioremap。波形是由spi控制器拉出。
SPI驱动之SPI设备驱动程序
热门推荐
伍意的博客
04-17 1万+
 前篇文章分析了SPI主控制器驱动，也就是SPI总线驱动，既然总线有了，根据Linux设备驱动模型，还得有SPI设备和SPI设备驱动。SPI设备是在板级文件中注册，SPI设备驱动需要用户自己实现，好在内核为我们提供了一个通用的SPI设备驱动spidev.c，下面就来分析一下这个文件，该文件位于kernel3.0.15/drivers/spi/spidev.c。 1. 模块初始化和注销：sp
Linux内核4.14版本——SPI框架（7）——spidev.c分析
yangguoyu8023的博客
02-08 2315
xx
Linux中spidev添加
seiyaaa的专栏
05-07 800
​ SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这种简单易用的特性，越来越多的芯片集成了这种通信协议，比如AT91RM9200
linux spidev 应用_linux spi驱动开发学习(二)-----spidev.c和spi test app
weixin_35995565的博客
02-01 834
#include#include#include#include#include#include#include#include#include#include#include#include#include#define SPIDEV_MAJOR 153 //spidev主设备号#define N_SPI_MINORS 32 /* ... up to...
linux spidev 应用_Linux通过SPI通讯
weixin_36317492的博客
01-04 2102
平台：树莓派 bcm2835 Raspberry Pi 3 Model B Rev 1.2SPI是串行外设接口，这里用的外设是oled的12864显示屏，使用树莓派点亮它学习Linux SPI应用的开发。(这里不使用python库、wiringPi库和bcm2835驱动库)代码没有自己写，用了libssd1306这个代码库，作者的github名为michaelKle。另外参考了csd...
SPI.rar_arm spi_linux spi_基于spi-flash的点阵屏
09-21
在这个“SPI.rar_arm spi_linux spi_基于spi-flash的点阵屏”压缩包中，我们可以找到与SPI接口在ARM处理器和Linux操作系统环境下使用的相关资源，特别是针对使用SPI闪存驱动点阵显示屏的应用。 1. **SPI接口原理**...
spi.rar_board_linux spi_linux-spi_spi_spi 2440
09-23
5. **Linux spi-linux-spi**： "linux-spi"可能指的是Linux SPI用户空间库或工具，它允许用户应用程序通过标准的SPI接口与硬件进行通信，而无需深入到内核驱动的细节。这些工具通常提供了API，简化了SPI设备的控制...
spi-farsight.rar_SPI a8_linux spi_linux-spi_s3c2410 spi
09-22
在解压并分析"spi-farsight"文件后，你可以深入研究代码，了解如何在A8处理器和S3C2410平台上实现具体的SPI操作，包括初始化、数据传输、错误处理等细节。这将有助于你在开发嵌入式系统时更好地利用SPI接口进行硬件...
CP2130.rar_USB spi_USB-SPI_cp2130驱动包_usb_spi_上位机 SPI
07-14
该驱动包"USB-SPI-SP2130"是为CP2130设计的，用于安装在计算机上，确保操作系统能够识别并正确通信。驱动程序通常包括安装向导、配置工具以及必要的库文件，确保USB设备连接到PC时能被正确枚举和操作。驱动安装后，...
spidev-test 程序
06-05
SPI测试程序，包含修改过编译bug的源码，以及相关头文件。博客：https://blog.youkuaiyun.com/wxxgoodjob/article/details/80583566
基于 Linux SPI驱动74HC595做8路led控制
07-09
本程序为c编写的简单实例，用于linux以SPI方式驱动74HC595，做8路led控制，该程序中SPI选的是/dev/spidev2.0，速率10000，每1秒切换一次led亮灭状态。
嵌入式linux之iMX6ULL驱动开发 | 通用spi驱动之spidev使用总结
猫哥 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS，AIOT)
07-26 7498
因为兴趣，业余时间把玩下手边的imax6ul开发板。Linux内核集成了spidev驱动，提供了SPI设备的用户空间API。支持用于半双工通信的read和write访问接口以及用于全双工通信和I/O配置的ioctl接口。使用时，只需将SPI从设备的compatible属性值添加到spidev区动的spidev dt ids[]数组中，即可将该SPI从设备创建为spidev设备。如果不想编写单独的spi设备驱动，那么使用linux内核提供的通用spidev设备驱动就够了
嵌入式Linux SPI驱动 spidev的使用(SPI用户态API)
你要拥有一个你喜欢并且热爱的人生
01-15 1446
嵌入式Linux SPI驱动 spidev的使用(SPI用户态API)
linux spidev 应用_linux spi 应用程序。
weixin_39663602的博客
12-21 654
/***功能：同步数据传输*入口参数：*TxBuf->发送数据首地址*len->交换数据的长度*出口参数：*RxBuf->接收数据缓冲区*返回值：0成功*开发人员：Lzy2013－5－22*/intSPI_Transfer(const.../*** 功 能：同步数据传输* 入口参数 ：* TxBuf -> 发送数据首地址* len -> 交换数据的长度* 出口参数：*...
spidev的使用(SPI用户态API)
jia_weihui的博客
02-28 2184
在这样一个速食的时代，坚持做自己，慢下来，潜心琢磨，心怀敬畏，领悟知识，才能向下扎到根，向上捅破天，背着世界往前行！使用read、write函数时，只能读、写，这是半双工方式。使用read、write函数时，只能读、写，这是半双工方式。仅此向嵌入行业里的每一个认真做技术的从业者致敬！使用ioctl可以达到全双工的读写。使用ioctl可以达到全双工的读写。匹配之后，spidev.c的。
Linux SPI核心驱动spidev.c深度解析
weixin_46356409的博客
06-24 589
是Linux内核中SPI设备的通用用户空间接口驱动，它允许用户空间程序通过。理解这些数据结构和流程对于开发SPI驱动和应用程序至关重要。文件直接访问SPI设备。
linux spidev 应用_linux 测试 SPI 测试应用程序代码 | 学步园
weixin_39535283的博客
12-21 217
mail:bookworepeng@Hotmail.comqq:196568501author:DriverMonkeyphone:13410905075测试硬件平台：TI AM335X测试代码：/** SPI testing utility (using spidev driver)** Copyright (c) 2007 MontaVista Software, Inc.* Copyri...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值