小男孩‘自慰网亚洲一区二区,亚洲一级在线播放毛片,亚洲中文字幕av每天更新,黄aⅴ永久免费无码,91成人午夜在线精品,色网站免费在线观看,亚洲欧洲wwwww在线观看

搜索
分享

Linux spi驅(qū)動(dòng)分析(三)

 dwlinux_gs 2014-08-14

一、spidev簡(jiǎn)單介紹

        如果在內(nèi)核中配置spidev，會(huì)在“/dev”目錄下產(chǎn)生設(shè)備節(jié)點(diǎn)，通過(guò)此節(jié)點(diǎn)可以操作掛載在該SPI總線(xiàn)上的設(shè)備，接下來(lái)將從驅(qū)動(dòng)層和應(yīng)用層

來(lái)分析程序。

二、spidev驅(qū)動(dòng)層

2.1、驅(qū)動(dòng)注冊(cè)

        分析一個(gè)設(shè)備驅(qū)動(dòng)，一般都是從module_init和module_exit處開(kāi)始，本文也不例外，程序如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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");

        說(shuō)明：

        1) 在驅(qū)動(dòng)注冊(cè)函數(shù)中，首先注冊(cè)函數(shù)操作集spidev_fops，該內(nèi)容將在2.3中具體講述。

        2) 生成spidev設(shè)備類(lèi)，此類(lèi)的表現(xiàn)是在“/sys/class”目錄下生成一個(gè)名為spidev目錄。

        3) 注冊(cè)spi驅(qū)動(dòng)。

        4) 退出函數(shù)是注冊(cè)函數(shù)的相反過(guò)程，就是釋放注冊(cè)函數(shù)中注冊(cè)的資源。

2.2、探測(cè)和移除函數(shù)

        探測(cè)函數(shù)程序如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 首先聲明spidev_data結(jié)構(gòu)體內(nèi)存。

        2) 初始化其成員變量。

        3) 在位圖中尋找第一個(gè)未被用到的位。

        4) 如果位圖尋找正確，創(chuàng)建“/dev”目錄下的設(shè)備節(jié)點(diǎn)。

        4) 將spidev結(jié)構(gòu)體中的鏈表插入局部全局鏈表device_list中，以便在函數(shù)操作集中的open函數(shù)中使用            

        移除函數(shù)如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 移除函數(shù)就是探測(cè)函數(shù)的相反過(guò)程，主要就是釋放探測(cè)函數(shù)中申請(qǐng)的資源。

2.2、函數(shù)操作集spidev_fop

        spidev_fop具體如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. };

        首先看下打開(kāi)函數(shù)spidev_open，程序如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

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

        2) 遍歷鏈表device_list，通過(guò)設(shè)備號(hào)找到在探測(cè)函數(shù)中創(chuàng)建的設(shè)備結(jié)構(gòu)體spidev。

        3) 如果尋找成功，將其保存在file的私有成員中，供其他操作集中的函數(shù)使用。

        realease函數(shù)如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 首先減少使用次數(shù)。

        2) 釋放傳輸buf空間。

        3) 釋放結(jié)構(gòu)體內(nèi)存。

        spi讀數(shù)據(jù)函數(shù)如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 進(jìn)入讀函數(shù)中，首先上互斥鎖。

        2) 然后調(diào)用spidev_sync_read函數(shù)讀數(shù)據(jù)。

        3) 如果讀取成功，將讀取到的數(shù)據(jù)拷貝到應(yīng)用層。

        4) 解互斥鎖。

        5) 在spidev_sync_read函數(shù)中，首先定義一個(gè)傳輸結(jié)構(gòu)體spi_transfer，由于是讀操作，所以只初始化其接收buf。

        6) 初始化spi_message，調(diào)用函數(shù)spidev_sync傳輸數(shù)據(jù)，其具體程序如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 首先定義并初始化一個(gè)completion。

        2) 上自旋鎖，調(diào)用spi_async函數(shù)傳輸數(shù)據(jù)，spi_async就是在Linux核心中提供的傳輸函數(shù)。

        3) 如果調(diào)用傳輸函數(shù)成功，則等待。

        3) wait_for_completion(&done);等待傳輸完成，如果傳輸正確，函數(shù)返回值為傳輸?shù)淖止?jié)數(shù)。

        函數(shù)操作集寫(xiě)函數(shù)spidev_write程序如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 寫(xiě)函數(shù)首先上互斥鎖，然后從應(yīng)用層拷貝需要寫(xiě)的數(shù)據(jù)。

        2) 如果拷貝成功，調(diào)用函數(shù)spidev_sync_write完成寫(xiě)數(shù)據(jù)。

        3) 解互斥鎖。

        4) spidev_sync_write函數(shù)中，首先定義spi_transfer傳輸結(jié)構(gòu)體，由于是寫(xiě)，此結(jié)構(gòu)體只有tx_buf。

        5) 初始化spi_message，然后調(diào)用spidev_sync傳輸數(shù)據(jù)，此函數(shù)在上面的讀操作中已經(jīng)講述。

        ioctl函數(shù)如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 函數(shù)首先判斷命令是否有效，如果無(wú)效，直接退出。

        2) 上互斥鎖。

        3) switch分支中，前面的case都是支持對(duì)SPI設(shè)備的設(shè)置，包括模式、傳輸位、位方向和最大速率等。

        4) 在設(shè)置分支中，最后調(diào)用spi_setup實(shí)現(xiàn)設(shè)置，此函數(shù)最終是調(diào)用總線(xiàn)驅(qū)動(dòng)中的gsc3280_spi_setup(struct spi_device *spi)

實(shí)現(xiàn)設(shè)置。

        5) default分支中是進(jìn)行數(shù)據(jù)傳輸?shù)姆种?，首先判斷是否是有效的?shù)據(jù)，如果不是，退出switch分支。

        6) 申請(qǐng)內(nèi)存，復(fù)制從應(yīng)用層傳過(guò)來(lái)的數(shù)據(jù)。

        7) 調(diào)用spidev_message函數(shù)實(shí)現(xiàn)數(shù)據(jù)傳輸。

        8) 解互斥鎖，退出。

        spidev_message函數(shù)如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 申請(qǐng)傳輸?shù)慕Y(jié)構(gòu)體內(nèi)存。

        2) 通過(guò)for循環(huán)，對(duì)spi_ioc_transfer類(lèi)型的數(shù)據(jù)進(jìn)行轉(zhuǎn)換。

        3) 轉(zhuǎn)換中，首先對(duì)本次傳輸?shù)臄?shù)據(jù)大小進(jìn)行累計(jì)，如果總傳輸量超出buf的大小，直接退出。

        4) 如果本次傳輸是接收，則設(shè)置接收數(shù)組，并對(duì)buf進(jìn)行檢查，查看是否可讀。

        5) 如果本次傳輸是寫(xiě)，則從應(yīng)用層拷貝數(shù)據(jù)。

        6) 對(duì)傳輸中參數(shù)進(jìn)行賦值，包括速度、模式、速率等等。

        7) 調(diào)用spidev_sync進(jìn)行數(shù)據(jù)傳輸。

        8) 將接收數(shù)據(jù)拷貝到應(yīng)用層。

三、應(yīng)用層

        在應(yīng)用層提供了二中驅(qū)動(dòng)的測(cè)試程序，在“/documenation/spi”目錄下，文件名稱(chēng)為spidev_test.c中，具體程序如下：

點(diǎn)擊(此處)折疊或打開(kāi)

  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. }

        說(shuō)明：

        1) 首先打開(kāi)設(shè)備。

        2) 然后設(shè)置工作模式、位大小和速率等。

        3) 傳輸數(shù)據(jù)

    本站是提供個(gè)人知識(shí)管理的網(wǎng)絡(luò)存儲(chǔ)空間，所有內(nèi)容均由用戶(hù)發(fā)布，不代表本站觀點(diǎn)。請(qǐng)注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購(gòu)買(mǎi)等信息，謹(jǐn)防詐騙。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請(qǐng)點(diǎn)擊一鍵舉報(bào)。
    轉(zhuǎn)藏 分享 獻(xiàn)花（0）

    0條評(píng)論

    發(fā)表

    請(qǐng)遵守用戶(hù) 評(píng)論公約

    類(lèi)似文章 更多