国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

打開APP
userphoto
未登錄

開通VIP，暢享免費電子書等14項超值服

開通VIP

首頁

好書

留言交流

下載APP

聯(lián)系客服
davinci平臺的spi驅動框架
davinci平臺的spi驅動框架
http://blog.chinaunix.net/uid-27717694-id-3774328.html

  1. 一、SPI總線概述
  2. SPI是英語Serial Peripheral interface的縮寫，顧名思義就是串行外圍設備接口，是Motorola首先在其MC68HCXX系列處理器上定義的。SPI接口主要應用在 EEPROM，F(xiàn)LASH，實時時鐘，AD轉換器，還有數(shù)字信號處理器和數(shù)字信號解碼器之間。SPI是一種高速的，全雙工，同步的通信總線，并且在芯片的管腳上只占用四根線，節(jié)約了芯片的管腳，同時為PCB的布局上節(jié)省空間，提供方便。
  3. SPI的通信原理很簡單，它以主從方式工作，這種模式通常有一個主設備和一個或多個從設備，需要4根線，事實上3根也可以。也是所有基于SPI的設備共有的，它們是SDI(數(shù)據(jù)輸入)，SDO(數(shù)據(jù)輸出)，SCLK(時鐘)，CS(片選)。
  4. MOSI(SDO)：主器件數(shù)據(jù)輸出，從器件數(shù)據(jù)輸入。
  5. MISO(SDI)：主器件數(shù)據(jù)輸入，從器件數(shù)據(jù)輸出。
  6. SCLK ：時鐘信號，由主器件產生。
  7. CS：從器件使能信號，由主器件控制。
  8. 其中CS是控制芯片是否被選中的，也就是說只有片選信號為預先規(guī)定的使能信號時（高電位或低電位），對此芯片的操作才有效，這就允許在同一總線上連接多個SPI設備成為可能。需要注意的是，在具體的應用中，當一條SPI總線上連接有多個設備時，SPI本身的CS有可能被其他的GPIO腳代替，即每個設備的CS腳被連接到處理器端不同的GPIO，通過操作不同的GPIO口來控制具體的需要操作的SPI設備，減少各個SPI設備間的干擾。
  9. SPI是串行通訊協(xié)議，也就是說數(shù)據(jù)是一位一位從MSB或者LSB開始傳輸?shù)?，這就是SCK時鐘線存在的原因，由SCK提供時鐘脈沖，MISO、MOSI則基于此脈沖完成數(shù)據(jù)傳輸。 SPI支持4-32bits的串行數(shù)據(jù)傳輸，支持MSB和LSB，每次數(shù)據(jù)傳輸時當從設備的大小端發(fā)生變化時需要重新設置SPI Master的大小端。

  11. 二、Linux SPI驅動總體架構
  12. 在2.6的linux內核中，SPI的驅動架構可以分為如下三個層次：SPI 核心層、SPI控制器驅動層和SPI設備驅動層。Linux 中SPI驅動代碼位于drivers/spi目錄。
  13. 1.SPI核心層
  14. SPI核心層是Linux的SPI核心部分，提供了核心數(shù)據(jù)結構的定義、SPI控制器驅動和設備驅動的注冊、注銷管理等API。其為硬件平臺無關層，向下屏蔽了物理總線控制器的差異，定義了統(tǒng)一的訪問策略和接口；其向上提供了統(tǒng)一的接口，以便SPI設備驅動通過總線控制器進行數(shù)據(jù)收發(fā)。
  15. Linux中，SPI核心層的代碼位于driver/spi/spi.c。

  17. 2.SPI控制器驅動層
  18. SPI控制器驅動層，每種處理器平臺都有自己的控制器驅動，屬于平臺移植相關層。它的職責是為系統(tǒng)中每條SPI總線實現(xiàn)相應的讀寫方法。在物理上，每個SPI控制器可以連接若干個SPI從設備。
  19. 在系統(tǒng)開機時，SPI控制器驅動被首先裝載。一個控制器驅動用于支持一條特定的SPI總線的讀寫。一個控制器驅動可以用數(shù)據(jù)結構struct spi_master來描述。

  21. 3.SPI設備驅動層
  22. SPI設備驅動層為用戶接口層，其為用戶提供了通過SPI總線訪問具體設備的接口。
  23. SPI設備驅動層可以用兩個模塊來描述，struct spi_driver和struct spi_device。
  24. Driver是為device服務的，spi_driver注冊時會掃描SPI bus上的設備，進行驅動和設備的綁定，probe函數(shù)用于驅動和設備匹配時被調用。從上面的結構體注釋中我們可以知道，SPI的通信是通過消息隊列機制，而不是像I2C那樣通過與從設備進行對話的方式。

  26. 三、spi子系統(tǒng)主要數(shù)據(jù)結構
  27. 1.在Linux中，使用spi_master結構來描述一個SPI主機控制器的驅動。
  28. struct spi_master {
  29.     struct device dev;
  30.     s16 bus_num; //為該控制器對應的SPI總線號
  31.     u16 num_chipselect; //控制器支持的片選數(shù)量，即能支持多少個spi設備，從設備的片選號不能大于這個數(shù)量
  32.     u16 dma_alignment;
  33.     int (*setup)(struct spi_device *spi);//函數(shù)是設置SPI總線的模式，時鐘等的初始化函數(shù)， 針對設備設置SPI的工作時鐘及數(shù)據(jù)傳輸模式等。在spi_add_device函數(shù)中調用
  34.     int (*transfer)(struct spi_device *spi,struct spi_message *mesg);//實現(xiàn)SPI總線讀寫方法的函數(shù)。實現(xiàn)數(shù)據(jù)的雙向傳輸，可能會睡眠
  35.     void (*cleanup)(struct spi_device *spi); //注銷時候調用
  36. };
  37. //分配，注冊和注銷的SPI主機的API由SPI核心提供：
  38. struct spi_master *spi_alloc_master(struct device *host, unsigned size);
  39. int spi_register_master(struct spi_master *master);
  40. void spi_unregister_master(struct spi_master *master);
  41.    
  42. 2.在Linux中用spi_driver來描述一個SPI外設驅動。
  43. struct spi_driver {
  44.     const struct spi_device_id *id_table;//匹配的設備表
  45.     int            (*probe)(struct spi_device *spi);
  46.     int            (*remove)(struct spi_device *spi);
  47.     void        (*shutdown)(struct spi_device *spi);
  48.     int            (*suspend)(struct spi_device *spi, pm_message_t mesg);
  49.     int            (*resume)(struct spi_device *spi);
  50.     struct device_driver    driver;
  51. };

  53. 3.Linux用spi_device來描述一個SPI外設設備。
  54. struct spi_device {
  55.     struct device        dev;
  56.     struct spi_master    *master;//對應的控制器指針
  57.     u32            max_speed_hz;//spi通信的時鐘
  58.     u8            chip_select; //片選，用于區(qū)分同一總線上的不同設備
  59.     u8            mode;
  60. #define    SPI_CPHA    0x01            /* clock phase */
  61. #define    SPI_CPOL    0x02            /* clock polarity */
  62. #define    SPI_MODE_0    (0|0)            /* (original MicroWire) */
  63. #define    SPI_MODE_1    (0|SPI_CPHA)
  64. #define    SPI_MODE_2    (SPI_CPOL|0)
  65. #define    SPI_MODE_3    (SPI_CPOL|SPI_CPHA)
  66. #define    SPI_CS_HIGH    0x04            /* chipselect active high? */
  67. #define    SPI_LSB_FIRST    0x08            /* per-word bits-on-wire */
  68. #define    SPI_3WIRE    0x10            /* SI/SO signals shared */
  69. #define    SPI_LOOP    0x20            /* loopback mode */
  70. #define    SPI_NO_CS    0x40            /* 1 dev/bus, no chipselect */
  71. #define    SPI_READY    0x80            /* slave pulls low to pause */
  72.     u8            bits_per_word;//每個字長的比特數(shù)
  73.     int            irq;//使用的中斷號
  74.     void            *controller_state;
  75.     void            *controller_data;
  76.     char            modalias[SPI_NAME_SIZE];//名字
  77. };
  78. 看這三個結構的關系，這里spi_device與spi_master是同一個父設備，這是在spi_new_device函數(shù)中設定的，一般這個設備是一個物理設備。

  80. 4.為了解決多個不同的SPI設備共享SPI控制器而帶來的訪問沖突，spi_bitbang使用內核提供的工作隊列(workqueue)。 workqueue是Linux內核中定義的一種回調處理方式。采用這種方式需要傳輸數(shù)據(jù)時，不直接完成數(shù)據(jù)的傳輸，而是將要傳輸?shù)墓ぷ鞣盅b成相應的消息 (spi_message)，發(fā)送給對應的workqueue，由與workqueue關聯(lián)的內核守護線程(daemon)負責具體的執(zhí)行。由于 workqueue會將收到的消息按時間先后順序排列，這樣就是對設備的訪問嚴格串行化，解決了沖突。
  81. struct spi_bitbang {
  82.     struct workqueue_struct *workqueue;//工作隊列頭
  83.     struct work_struct work;//每一次傳輸都傳遞下來一個spi_message，都向工作隊列頭添加一個
  84.     workspinlock_t lock;
  85.     struct list_head queue;//掛接spi_message，如果上一次的spi_message還沒有處理完，接下來的spi_message就掛接在queue上等待處理
  86.     u8 busy;//忙碌標志
  87.     u8 use_dma;
  88.     u8 flags;
  89.     struct spi_master *master;//指向spi控制器
  90.     int (*setup_transfer)(struct spi_device *spi,struct spi_transfer *t);//設置傳輸模式
  91.     void (*chipselect)(struct spi_device *spi, int is_on);//片選
  92. #define BITBANG_CS_ACTIVE 1 /* normally nCS, active low */
  93. #define BITBANG_CS_INACTIVE 0
  94.     int (*txrx_bufs)(struct spi_device *spi, struct spi_transfer *t);//傳輸函數(shù)
  95.     u32 (*txrx_word[4])(struct spi_device *spi,unsigned nsecs,u32 word, u8 bits);
  96. };

  98. 5.下面來看看spi_message：
  99. struct spi_message {
  100.     struct list_head transfers; //此次消息的傳輸隊列，一個消息可以包含多個傳輸段
  101.     struct spi_device *spi; //傳輸?shù)哪康脑O備
  102.     unsigned is_dma_mapped:1; //如果為真，此次調用提供dma和cpu虛擬地址
  103.     void (*complete)(void *context); //異步調用完成后的回調函數(shù)
  104.     void *context; //回調函數(shù)的參數(shù)
  105.     unsigned actual_length; //此次傳輸?shù)膶嶋H長度
  106.     int status; //執(zhí)行的結果，成功被置0，否則是一個負的錯誤碼
  107.     struct list_head queue;
  108.     void *state;
  109. };
  110. 在有消息需要傳遞的時候，會將spi_transfer通過自己的transfer_list字段掛到spi_message的transfers鏈表頭上。spi_message用來原子的執(zhí)行spi_transfer表示的一串數(shù)組傳輸請求。這個傳輸隊列是原子的，這意味著在這個消息完成之前不會有其 他消息占用總線。消息的執(zhí)行總是按照FIFO的順序。

  112. 6.下面看一看spi_transfer：
  113. struct spi_transfer {
  114.     const void *tx_buf; //要寫入設備的數(shù)據(jù)(必須是dma_safe)，或者為NULL
  115.     void *rx_buf; //要讀取的數(shù)據(jù)緩沖(必須是dma_safe)，或者為NULL
  116.     unsigned len; //tx和rx的大小(字節(jié)數(shù)),這里不是指它的和，而是各自的長度，他們總是相等的
  117.     dma_addr_t tx_dma; //如果spi_message.is_dma_mapped是真，這個是tx的dma地址
  118.     dma_addr_t rx_dma; //如果spi_message.is_dma_mapped是真，這個是rx的dma地址
  119.     unsigned cs_change:1; //影響此次傳輸之后的片選，指示本次tranfer結束之后是否要重新片選并調用setup改變設置，這個標志可以較少系統(tǒng)開銷u8
  120.     bits_per_word; //每個字長的比特數(shù)，如果是0，使用默認值
  121.     u16 delay_usecs; //此次傳輸結束和片選改變之間的延時，之后就會啟動另一個傳輸或者結束整個消息
  122.     u32 speed_hz; //通信時鐘。如果是0，使用默認值
  123.     struct list_head transfer_list; //用來連接的雙向鏈表節(jié)點
  124. };

  126. 7.spi控制器驅動的私有數(shù)據(jù)
  127. struct davinci_spi {
  128.     struct spi_bitbang    bitbang;
  129.     struct clk        *clk;//時鐘
  130.     u8            version;
  131.     resource_size_t        pbase;//spi寄存器物理地址
  132.     void __iomem        *base;//spi寄存器虛擬地址
  133.     u32            irq;//spi中斷號
  134.     struct completion    done;

  136.     const void    *tx;//發(fā)送buffer
  137.     void            *rx;//讀buffer
  138. #define SPI_TMP_BUFSZ    (SMP_CACHE_BYTES + 1)
  139.     u8            rx_tmp_buf[SPI_TMP_BUFSZ];
  140.     int            rcount;//讀數(shù)據(jù)個數(shù)
  141.     int            wcount;//寫數(shù)據(jù)個數(shù)
  142.     struct davinci_spi_dma    dma;
  143.     struct davinci_spi_platform_data *pdata;

  145.     void        (*get_rx)(u32 rx_data, struct davinci_spi *);//讀數(shù)據(jù)函數(shù)
  146.     u32            (*get_tx)(struct davinci_spi *);//發(fā)送數(shù)據(jù)函數(shù)
  147.     u8            bytes_per_word[SPI_MAX_CHIPSELECT];
  148.     u32            speed;
  149.     u32            cs_num;
  150.     bool        in_use;

  152. #ifdef CONFIG_CPU_FREQ
  153.     struct notifier_block freq_transition;
  154. #endif
  155. };


  158. 四、spi驅動初始化
  159. 1.spi總線注冊
  160. //spi總線結構
  161. struct bus_type spi_bus_type = {
  162.     .name        = "spi",
  163.     .dev_attrs    = spi_dev_attrs,
  164.     .match        = spi_match_device,
  165.     .uevent        = spi_uevent,
  166.     .suspend    = spi_suspend,
  167.     .resume        = spi_resume,
  168. };

  170. //spi_master類，會在sysfs文件系統(tǒng)創(chuàng)建該類
  171. static struct class spi_master_class = {
  172.     .name        = "spi_master",
  173.     .owner        = THIS_MODULE,
  174.     .dev_release    = spi_master_release,
  175. };

  177. static int __init spi_init(void)
  178. {
  179.     int    status;

  181.     buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
  182.     if (!buf) {
  183.         status = -ENOMEM;
  184.         goto err0;
  185.     }
  186.     //分別對應sysfs文件系統(tǒng)中的sys/bus/下的spi目錄和sys/class/下的spi_master目錄。
  187.     status = bus_register(&spi_bus_type);//注冊spi總線
  188.     if (status < 0)
  189.         goto err1;

  191.     status = class_register(&spi_master_class);//創(chuàng)建spi_master的類
  192.     if (status < 0)
  193.         goto err2;
  194.     return 0;

  196. err2:
  197.     bus_unregister(&spi_bus_type);
  198. err1:
  199.     kfree(buf);
  200.     buf = NULL;
  201. err0:
  202.     return status;
  203. }

  205. 2.spi控制器管腳的復用配置
  206. const short da850_spi0_pins[] __initdata = {
  207.     DA850_SPI0_CLK,DA850_SPI0_ENA,DA850_SPI0_SOMI,DA850_SPI0_SIMO,
  208.     -1
  209. };

  211. static __init void da850_evm_init(void)
  212. {
  213.     //......
  214.     ret = davinci_cfg_reg_list(da850_spi0_pins);//復用管腳配置
  215.     if (ret)
  216.         pr_warning("da850_evm_init: spi0 mux setup failed: %d\n",    ret);
  217.     //......    
  218. }

  220. 3.注冊spi的platform device設備        
  221. static struct spi_board_info da850evm_spi_info[] = {
  222.     {
  223.         .modalias = "ads7846",//設備名，與spi_driver中定義的名字相同
  224.         .bus_num = 0,
  225.         .chip_select = 0,
  226.         .max_speed_hz = 1500000,
  227.         .mode             = SPI_MODE_0,
  228.         .irq = 128,//GPIO1[11]
  229.         .platform_data = &ads7846_config,
  230.         },
  231. };

  233. static void __init da850evm_init_spi0(struct spi_board_info *info, unsigned len)
  234. {
  235.     int ret;
  236.     
  237.     //注冊spi設備的信息到board_list鏈表中，待spi master注冊好后掃描這些板級設備再進行注冊
  238.     ret = spi_register_board_info(info, len);
  239.     if (ret)
  240.         pr_warning("failed to register board info : %d\n", ret);
  241.     
  242.     //注冊spi0的platform device
  243.     ret = da8xx_register_spi(0, &da850evm_spi0_pdata);
  244.     if (ret)
  245.         pr_warning("failed to register spi 1 device : %d\n", ret);

  247.     if (!(system_rev & 0x100))
  248.         register_mtd_user(&spi_notifier);
  249. }

  251. int __init spi_register_board_info(struct spi_board_info const *info, unsigned n)
  252. {
  253.     struct boardinfo *bi;
  254.     int i;

  256.     bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);//分配一個boardinfo結構
  257.     if (!bi)
  258.         return -ENOMEM;

  260.     for (i = 0; i < n; i++, bi++, info++) {
  261.         struct spi_master *master;
  262.         memcpy(&bi->board_info, info, sizeof(*info));//填充boardinfo結構
  263.         mutex_lock(&board_lock);
  264.         list_add_tail(&bi->list, &board_list);//掛載到全局鏈表board_list中
  265.         
  266.         //遍歷spi_master_list鏈表，查看是否有spi設備在此spi控制器上，現(xiàn)在因為spi master尚未注冊，不會注冊板級設備。
  267.         //待spi控制器注冊后，還會掃描鏈表進行匹配，來注冊板級設備
  268.         list_for_each_entry(master, &spi_master_list, list)
  269.             spi_match_master_to_boardinfo(master, &bi->board_info);
  270.         mutex_unlock(&board_lock);
  271.     }
  272.     return 0;
  273. }

  275. static struct resource da8xx_spi0_resources[] = {
  276.     [0] = {
  277.         .start = 0x01c41000,
  278.         .end = 0x01c41fff,
  279.         .flags = IORESOURCE_MEM,
  280.     },
  281.     [1] = {
  282.         .start = IRQ_DA8XX_SPINT0,
  283.         .end = IRQ_DA8XX_SPINT0,
  284.         .flags = IORESOURCE_IRQ,
  285.     },
  286.     [2] = {
  287.         .start = EDMA_CTLR_CHAN(0, 14),
  288.         .end = EDMA_CTLR_CHAN(0, 14),
  289.         .flags = IORESOURCE_DMA,
  290.     },
  291.     [3] = {
  292.         .start = EDMA_CTLR_CHAN(0, 15),
  293.         .end = EDMA_CTLR_CHAN(0, 15),
  294.         .flags = IORESOURCE_DMA,
  295.     },
  296.     [4] = {
  297.         .start = 0,
  298.         .end = 0,
  299.         .flags = IORESOURCE_DMA,
  300.     },
  301. };

  303. static struct platform_device da8xx_spi_device[] = {
  304.     [0] = {
  305.         .name = "spi_davinci",
  306.         .id = 0,
  307.         .num_resources = ARRAY_SIZE(da8xx_spi0_resources),
  308.         .resource = da8xx_spi0_resources,
  309.     },
  310.     [1] = {
  311.         .name = "spi_davinci",
  312.         .id = 1,
  313.         .num_resources = ARRAY_SIZE(da8xx_spi1_resources),
  314.         .resource = da8xx_spi1_resources,
  315.     },
  316. };

  318. int __init da8xx_register_spi(int instance,struct davinci_spi_platform_data *pdata)
  319. {
  320.     struct platform_device *pdev;

  322.     if (instance == 0)
  323.         pdev = &da8xx_spi_device[0];
  324.     else if (instance == 1)
  325.         pdev = &da8xx_spi_device[1];
  326.     else
  327.         return -EINVAL;

  329.     pdev->dev.platform_data = pdata;

  331.     return platform_device_register(pdev);//注冊platform device設備
  332. }

  334. 4.注冊platform driver，會注冊spi控制器spi_master

  336. static struct platform_driver davinci_spi_driver = {
  337.     .driver = {
  338.         .name = "spi_davinci",
  339.         .owner = THIS_MODULE,
  340.     },
  341.     .remove = __exit_p(davinci_spi_remove),
  342.     .suspend = davinci_spi_suspend,
  343.     .resume = davinci_spi_resume,
  344. };

  346. static int __init davinci_spi_init(void)
  347. {
  348.     return platform_driver_probe(&davinci_spi_driver, davinci_spi_probe);
  349. }

  351. //platform driver與platform device匹配成功后，調用davinci_spi_probe
  352. static int davinci_spi_probe(struct platform_device *pdev)
  353. {
  354.     struct spi_master *master;
  355.     struct davinci_spi *dspi;
  356.     struct davinci_spi_platform_data *pdata;
  357.     struct resource *r, *mem;
  358.     resource_size_t dma_rx_chan = SPI_NO_RESOURCE;
  359.     resource_size_t    dma_tx_chan = SPI_NO_RESOURCE;
  360.     resource_size_t    dma_eventq = SPI_NO_RESOURCE;
  361.     int i = 0, ret = 0;
  362.     u32 spipc0;

  364.     pdata = pdev->dev.platform_data;
  365.     if (pdata == NULL) {
  366.         ret = -ENODEV;
  367.         goto err;
  368.     }
  369.     
  370.     //分配一個spi控制器的spi_master結構,分配struct spi_master + struct davinci_spi大小的數(shù)據(jù)，把davinci_spi設為spi_master的私有數(shù)據(jù)
  371.     master = spi_alloc_master(&pdev->dev, sizeof(struct davinci_spi));
  372.     if (master == NULL) {
  373.         ret = -ENOMEM;
  374.         goto err;
  375.     }
  376.     
  377.     //把spi_master設置為platform_device結構中dev的私有數(shù)據(jù)
  378.     dev_set_drvdata(&pdev->dev, master);
  379.     
  380.     //從master中獲得私有數(shù)據(jù)davinci_spi
  381.     dspi = spi_master_get_devdata(master);
  382.     if (dspi == NULL) {
  383.         ret = -ENOENT;
  384.         goto free_master;
  385.     }
  386.     
  387.     //從platform device的私有數(shù)據(jù)中獲得spi控制器的寄存器物理地址資源
  388.     r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  389.     if (r == NULL) {
  390.         ret = -ENOENT;
  391.         goto free_master;
  392.     }
  393.     dspi->pbase = r->start;//spi寄存器起始物理地址
  394.     dspi->pdata = pdata;
  395.     
  396.     //為spi控制器的物理地址申請內存空間
  397.     mem = request_mem_region(r->start, resource_size(r), pdev->name);
  398.     if (mem == NULL) {
  399.         ret = -EBUSY;
  400.         goto free_master;
  401.     }
  402.     
  403.     //將spi控制器的寄存器物理地址映射到內核空間
  404.     dspi->base = ioremap(r->start, resource_size(r));
  405.     if (dspi->base == NULL) {
  406.         ret = -ENOMEM;
  407.         goto release_region;
  408.     }
  409.     
  410.     //從platform device的私有數(shù)據(jù)中獲得spi控制器的中斷號
  411.     dspi->irq = platform_get_irq(pdev, 0);
  412.     if (dspi->irq <= 0) {
  413.         ret = -EINVAL;
  414.         goto unmap_io;
  415.     }
  416.     
  417.     //申請中斷號
  418.     ret = request_irq(dspi->irq, davinci_spi_irq, 0, dev_name(&pdev->dev),dspi);
  419.     if (ret)
  420.         goto unmap_io;
  421.     
  422.     //spi master計數(shù)加1，且
  423.     dspi->bitbang.master = spi_master_get(master);
  424.     if (dspi->bitbang.master == NULL) {
  425.         ret = -ENODEV;
  426.         goto irq_free;
  427.     }
  428.     
  429.     //獲得spi時鐘
  430.     dspi->clk = clk_get(&pdev->dev, NULL);
  431.     if (IS_ERR(dspi->clk)) {
  432.         ret = -ENODEV;
  433.         goto put_master;
  434.     }
  435.     clk_enable(dspi->clk);//時鐘使能

  437.     master->bus_num = pdev->id;//spi控制器所在的spi總線號
  438.     master->num_chipselect = pdata->num_chipselect;//spi控制器的片選數(shù)量
  439.     master->setup = davinci_spi_setup;//spi控制器的setup函數(shù)
  440.     
  441.     //spi_bitbang專門負責數(shù)據(jù)的傳輸*
  442.     dspi->bitbang.chipselect = davinci_spi_chipselect;//片選選擇函數(shù)
  443.     dspi->bitbang.setup_transfer = davinci_spi_setup_transfer;//建立傳輸?shù)暮瘮?shù)

  445.     dspi->version = pdata->version;//版本號SPI_VERSION_2
  446.     //設置一些標志位
  447.     dspi->bitbang.flags = SPI_NO_CS | SPI_LSB_FIRST | SPI_LOOP;
  448.     if (dspi->version == SPI_VERSION_2)
  449.         dspi->bitbang.flags |= SPI_READY;
  450.     
  451.     //DMA操作的一些設置
  452.     r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
  453.     if (r)
  454.         dma_rx_chan = r->start;
  455.     r = platform_get_resource(pdev, IORESOURCE_DMA, 1);
  456.     if (r)
  457.         dma_tx_chan = r->start;
  458.     r = platform_get_resource(pdev, IORESOURCE_DMA, 2);
  459.     if (r)
  460.         dma_eventq = r->start;

  462.     //數(shù)據(jù)傳輸函數(shù)
  463.     dspi->bitbang.txrx_bufs = davinci_spi_bufs;
  464.     //沒有使用DMA
  465.     if (dma_rx_chan != SPI_NO_RESOURCE &&dma_tx_chan != SPI_NO_RESOURCE &&dma_eventq != SPI_NO_RESOURCE) {
  466.         dspi->dma.rx_channel = dma_rx_chan;
  467.         dspi->dma.tx_channel = dma_tx_chan;
  468.         dspi->dma.eventq = dma_eventq;

  470.         ret = davinci_spi_request_dma(dspi);
  471.         if (ret)
  472.             goto free_clk;

  474.         dev_info(&pdev->dev, "DMA: supported\n");
  475.         dev_info(&pdev->dev, "DMA: RX channel: %d, TX channel: %d, event queue: %d\n", dma_rx_chan, dma_tx_chan,dma_eventq);
  476.     }
  477.     
  478.     //設置spi的讀寫函數(shù)
  479.     dspi->get_rx = davinci_spi_rx_buf_u8;
  480.     dspi->get_tx = davinci_spi_tx_buf_u8;

  482.     init_completion(&dspi->done);
  483.     ret = davinci_spi_cpufreq_register(dspi);//cpu變頻相關操作
  484.     if (ret) {
  485.         pr_info("davinci SPI contorller driver failed to register cpufreq\n");
  486.         goto free_dma;
  487.     }

  489.     iowrite32(0, dspi->base + SPIGCR0);//reset spi控制器
  490.     udelay(100);
  491.     iowrite32(1, dspi->base + SPIGCR0);//跳出spi控制器reset狀態(tài)

  493.     //初始化設置寄存器，包括對SPIMOSI,SPIMISO,SPICLK引腳的設置
  494.     spipc0 = SPIPC0_DIFUN_MASK | SPIPC0_DOFUN_MASK | SPIPC0_CLKFUN_MASK;
  495.     iowrite32(spipc0, dspi->base + SPIPC0);

  497.     //GPIO作為片選管腳的初始化
  498.     if (pdata->chip_sel) {
  499.         for (i = 0; i < pdata->num_chipselect; i++) {
  500.             if (pdata->chip_sel[i] != SPI_INTERN_CS)
  501.                 gpio_direction_output(pdata->chip_sel[i], 1);
  502.         }
  503.     }

  505.     if (pdata->intr_line)
  506.         iowrite32(SPI_INTLVL_1, dspi->base + SPILVL);//設置spi中斷的等級
  507.     else
  508.         iowrite32(SPI_INTLVL_0, dspi->base + SPILVL);

  510.     iowrite32(CS_DEFAULT, dspi->base + SPIDEF);//設置片選寄存器，寫入默認值0xFF

  512.     /* master mode default */
  513.     set_io_bits(dspi->base + SPIGCR1, SPIGCR1_CLKMOD_MASK);//設置為master模式
  514.     set_io_bits(dspi->base + SPIGCR1, SPIGCR1_MASTER_MASK);//設置為master模式
  515.     set_io_bits(dspi->base + SPIGCR1, SPIGCR1_POWERDOWN_MASK);//設置為power-down模式

  517.     //設置bitbang傳輸
  518.     ret = spi_bitbang_start(&dspi->bitbang);
  519.     if (ret)
  520.         goto free_dma;

  522.     dev_info(&pdev->dev, "Controller at 0x%p\n", dspi->base);

  524.     return ret;

  526. free_dma:
  527.     edma_free_channel(dspi->dma.tx_channel);
  528.     edma_free_channel(dspi->dma.rx_channel);
  529.     edma_free_slot(dspi->dma.dummy_param_slot);
  530. free_clk:
  531.     clk_disable(dspi->clk);
  532.     clk_put(dspi->clk);
  533. put_master:
  534.     spi_master_put(master);
  535. irq_free:
  536.     free_irq(dspi->irq, dspi);
  537. unmap_io:
  538.     iounmap(dspi->base);
  539. release_region:
  540.     release_mem_region(dspi->pbase, resource_size(r));
  541. free_master:
  542.     kfree(master);
  543. err:
  544.     return ret;
  545. }

  547. int spi_bitbang_start(struct spi_bitbang *bitbang)
  548. {
  549.     int    status;

  551.     if (!bitbang->master || !bitbang->chipselect)
  552.         return -EINVAL;
  553.     
  554.      /*初始化一個工作隊列，后面再create_singlethread_workqueue,等到有數(shù)據(jù)要傳輸?shù)臅r候，在spi_bitbang_transfer函數(shù)中通過調用queue_work(bitbang->workqueue, &bitbang->work)，把work扔進workqueue中調度運行，這是內核的一貫做法*/
  555.     //動態(tài)創(chuàng)建一個work_struct結構，它的處理函數(shù)是bitbang_work
  556.     INIT_WORK(&bitbang->work, bitbang_work);
  557.     spin_lock_init(&bitbang->lock);//初始化自旋鎖和鏈表頭
  558.     INIT_LIST_HEAD(&bitbang->queue);//初始化鏈表頭

  560.     if (!bitbang->master->mode_bits)
  561.         bitbang->master->mode_bits = SPI_CPOL | SPI_CPHA | bitbang->flags;

  563.     if (!bitbang->master->transfer)
  564.         bitbang->master->transfer = spi_bitbang_transfer;//spi數(shù)據(jù)的傳輸就是通過調用這個方法來實現(xiàn)的
  565.     
  566.     //數(shù)據(jù)傳輸過程：spi_bitbang_transfer-->......-->davinci_spi_bufs
  567.     if (!bitbang->txrx_bufs) {//前邊已經賦值davinci_spi_bufs
  568.         bitbang->use_dma = 0;
  569.         bitbang->txrx_bufs = spi_bitbang_bufs;
  570.         if (!bitbang->master->setup) {
  571.             if (!bitbang->setup_transfer)
  572.                 bitbang->setup_transfer =
  573.                      spi_bitbang_setup_transfer;
  574.             bitbang->master->setup = spi_bitbang_setup;
  575.             bitbang->master->cleanup = spi_bitbang_cleanup;
  576.         }
  577.     } else if (!bitbang->master->setup)
  578.         return -EINVAL;

  580.     bitbang->busy = 0;
  581.     //調用create_singlethread_workqueue創(chuàng)建單個工作線程
  582.     bitbang->workqueue = create_singlethread_workqueue(dev_name(bitbang->master->dev.parent));
  583.     if (bitbang->workqueue == NULL) {
  584.         status = -EBUSY;
  585.         goto err1;
  586.     }

  588.     //注冊spi主機控制器
  589.     status = spi_register_master(bitbang->master);
  590.     if (status < 0)
  591.         goto err2;

  593.     return status;

  595. err2:
  596.     destroy_workqueue(bitbang->workqueue);
  597. err1:
  598.     return status;
  599. }

  601. int spi_register_master(struct spi_master *master)
  602. {
  603.     static atomic_t        dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
  604.     struct device        *dev = master->dev.parent;
  605.     struct boardinfo    *bi;
  606.     int            status = -ENODEV;
  607.     int            dynamic = 0;

  609.     if (!dev)
  610.         return -ENODEV;

  612.     //spi控制器的片選數(shù)量不能為0
  613.     if (master->num_chipselect == 0)
  614.         return -EINVAL;

  616.     if (master->bus_num < 0) {//spi控制器總線號不能為0
  617.         master->bus_num = atomic_dec_return(&dyn_bus_id);
  618.         dynamic = 1;
  619.     }

  621.     spin_lock_init(&master->bus_lock_spinlock);
  622.     mutex_init(&master->bus_lock_mutex);
  623.     master->bus_lock_flag = 0;

  625.     //設置spi控制器的名稱，即在sysfs文件系統(tǒng)中顯示的名稱
  626.     dev_set_name(&master->dev, "spi%u", master->bus_num);
  627.     
  628.     //設備添加到內核，會在sysfs文件系統(tǒng)下創(chuàng)建屬性文件,這也是sys/class/spi_master下產生spi0，spi1的原因
  629.     status = device_add(&master->dev);
  630.     if (status < 0)
  631.         goto done;
  632.     dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),dynamic ? " (dynamic)" : "");

  634.     mutex_lock(&board_lock);
  635.     list_add_tail(&master->list, &spi_master_list);//將spi控制器的master掛載到全局鏈表spi_master_list
  636.     
  637.     /*在spi controller的driver注冊的時候不但注冊這個主機控制器的驅動，還要遍歷這個主機控制器的總線上的spi_device，
  638.     將總線上的 spi_device全部注冊進內核。當注冊進內核并且spi_driver已經注冊的時候，如果總線match成功，
  639.     則會調用spi_driver的 probe函數(shù)，這個將在后邊進行分析。
  640.     */
  641.     list_for_each_entry(bi, &board_list, list)//遍歷每個boardinfo管理的spi_board_info，如果設備的總線號與控制器的總線好相等，則創(chuàng)建新設備
  642.         spi_match_master_to_boardinfo(master, &bi->board_info);
  643.     mutex_unlock(&board_lock);

  645.     status = 0;
  646.     /* Register devices from the device tree */
  647.     of_register_spi_devices(master);
  648. done:
  649.     return status;
  650. }

  652. static void spi_match_master_to_boardinfo(struct spi_master *master,struct spi_board_info *bi)
  653. {
  654.     struct spi_device *dev;

  656.     if (master->bus_num != bi->bus_num)//要在同一個spi總線上
  657.         return;
  658.     
  659.     //向spi控制器添加spi device
  660.     dev = spi_new_device(master, bi);
  661.     if (!dev)
  662.         dev_err(master->dev.parent, "can't create new device for %s\n",bi->modalias);
  663. }

  665. struct spi_device *spi_new_device(struct spi_master *master,struct spi_board_info *chip)
  666. {
  667.     struct spi_device    *proxy;
  668.     int            status;

  670.     //分配spi_device，并初始化spi->dev的一些字段
  671.     proxy = spi_alloc_device(master);
  672.     if (!proxy)
  673.         return NULL;

  675.     WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
  676.     //初始化spi_device的各個字段
  677.     proxy->chip_select = chip->chip_select;//片選號
  678.     proxy->max_speed_hz = chip->max_speed_hz;
  679.     proxy->mode = chip->mode;
  680.     proxy->irq = chip->irq;
  681.     strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));//spi設備的名字
  682.     proxy->dev.platform_data = (void *) chip->platform_data;
  683.     proxy->controller_data = chip->controller_data;
  684.     proxy->controller_state = NULL;
  685.     
  686.     //添加spi設備
  687.     status = spi_add_device(proxy);
  688.     if (status < 0) {
  689.         spi_dev_put(proxy);
  690.         return NULL;
  691.     }

  693.     return proxy;
  694. }

  696. int spi_add_device(struct spi_device *spi)
  697. {
  698.     static DEFINE_MUTEX(spi_add_lock);
  699.     struct device *dev = spi->master->dev.parent;
  700.     struct device *d;
  701.     int status;

  703.     //spi設備的片選號不能超過spi控制器的片選數(shù)量
  704.     if (spi->chip_select >= spi->master->num_chipselect) {
  705.         dev_err(dev, "cs%d >= max %d\n",spi->chip_select,spi->master->num_chipselect);
  706.         return -EINVAL;
  707.     }

  709.     //這里設置是spi_device在Linux設備驅動模型中的name，也就是spi0.0
  710.     dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),spi->chip_select);
  711.     mutex_lock(&spi_add_lock);

  713.     //如果總線上掛的設備已經有這個名字，則設置狀態(tài)忙碌，并退出
  714.     d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev));
  715.     if (d != NULL) {
  716.         dev_err(dev, "chipselect %d already in use\n",spi->chip_select);
  717.         put_device(d);
  718.         status = -EBUSY;
  719.         goto done;
  720.     }

  722.     //對spi_device進行設置
  723.     status = spi_setup(spi);
  724.     if (status < 0) {
  725.         dev_err(dev, "can't setup %s, status %d\n",dev_name(&spi->dev), status);
  726.         goto done;
  727.     }

  729.     //添加到內核,在sysfs文件系統(tǒng)下創(chuàng)建相應的屬性文件（設備文件dev文件不會在這里創(chuàng)建，下邊注冊spi device驅動時會創(chuàng)建dev文件）
  730.     status = device_add(&spi->dev);
  731.     if (status < 0)
  732.         dev_err(dev, "can't add %s, status %d\n",dev_name(&spi->dev), status);
  733.     else
  734.         dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));

  736. done:
  737.     mutex_unlock(&spi_add_lock);
  738.     return status;
  739. }

  741. int spi_setup(struct spi_device *spi)
  742. {
  743.     unsigned    bad_bits;
  744.     int        status;

  746.     bad_bits = spi->mode & ~spi->master->mode_bits;
  747.     if (bad_bits) {
  748.         dev_err(&spi->dev, "setup: unsupported mode bits %x\n",bad_bits);
  749.         return -EINVAL;
  750.     }
  751.     
  752.     if (!spi->bits_per_word)
  753.         spi->bits_per_word = 8;

  755.     status = spi->master->setup(spi);//調用davinci_spi_setup

  757.     dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
  758.                 "%u bits/w, %u Hz max --> %d\n",
  759.             (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
  760.             (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
  761.             (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
  762.             (spi->mode & SPI_3WIRE) ? "3wire, " : "",
  763.             (spi->mode & SPI_LOOP) ? "loopback, " : "",
  764.             spi->bits_per_word, spi->max_speed_hz,
  765.             status);

  767.     return status;
  768. }

  770. static int davinci_spi_setup(struct spi_device *spi)
  771. {
  772.     int retval = 0;
  773.     struct davinci_spi *dspi;
  774.     struct davinci_spi_platform_data *pdata;
  775.     
  776.     //從spi master的私有數(shù)據(jù)中取出davinci_spi
  777.     dspi = spi_master_get_devdata(spi->master);
  778.     pdata = dspi->pdata;

  780.     //設置了每字長的位數(shù)，發(fā)送速度
  781.     if (!spi->bits_per_word)
  782.         spi->bits_per_word = 8;

  784.     //設置spi片選管腳
  785.     if (!(spi->mode & SPI_NO_CS)) {
  786.         if ((pdata->chip_sel == NULL) ||(pdata->chip_sel[spi->chip_select] == SPI_INTERN_CS))
  787.             set_io_bits(dspi->base + SPIPC0, 1 << spi->chip_select);
  788.     }

  790.     //使能spi控制器
  791.     if (spi->mode & SPI_READY)
  792.         set_io_bits(dspi->base + SPIPC0, SPIPC0_SPIENA_MASK);

  794.     //是否使能內部loop-back測試模式
  795.     if (spi->mode & SPI_LOOP)
  796.         set_io_bits(dspi->base + SPIGCR1, SPIGCR1_LOOPBACK_MASK);
  797.     else
  798.         clear_io_bits(dspi->base + SPIGCR1, SPIGCR1_LOOPBACK_MASK);

  800.     return retval;
  801. }

  803. 5.spi device的驅動注冊，并創(chuàng)建設備節(jié)點
  804. static struct spi_driver ads7846_driver = {
  805.     .driver = {
  806.         .name    = "ads7846",
  807.         .bus    = &spi_bus_type,
  808.         .owner    = THIS_MODULE,
  809.     },
  810.     .probe        = ads7846_probe,
  811.     .remove        = __devexit_p(ads7846_remove),
  812.     .suspend    = ads7846_suspend,
  813.     .resume        = ads7846_resume,
  814. };

  816. static int __init ads7846_init(void)
  817. {
  818.     return spi_register_driver(&ads7846_driver);
  819. }

  821. //驅動與設備匹配成功后，會調用ads7846_probe函數(shù)，此函數(shù)會創(chuàng)建spi設備的字符設備，設備節(jié)點，這里創(chuàng)建的是/dev/input/event0

本站僅提供存儲服務，所有內容均由用戶發(fā)布，如發(fā)現(xiàn)有害或侵權內容，請點擊舉報。
打開APP，閱讀全文并永久保存 查看更多類似文章
猜你喜歡
類似文章
linux內核SPI總線驅動分析
spi子系統(tǒng)分析
spi驅動框架分板(上)
通過mtd讀寫flash
linux中probe函數(shù)傳遞參數(shù)的尋找（下）
Linux下spi驅動開發(fā)（1）
更多類似文章 >>
生活服務
分享 收藏 導長圖 關注 下載文章
綁定賬號成功
后續(xù)可登錄賬號暢享VIP特權！
如果VIP功能使用有故障，
可點擊這里聯(lián)系客服！

聯(lián)系客服