深入浅出spi驱动之控制器驱动(二)

1010阅读　0评论2015-07-31　hushup
分类：LINUX

Allein.Cao原创作品，转载请注明出处：

http://blog.csdn.net/alleincao/article/details/7523169

内核版本：2.6.32.2

硬件：S3C2440

控制器驱动是与SOC密切相关的一个模块，在linux中，一般都会采用设备驱动和控制器驱动分离的思想，两者通过一个core进行关联，这样能够最大程度保证代码的可移植性，具体可以参考《linux设备驱动开发详解》


上面提到设备驱动和控制器驱动通过core进行关联，更具体地来说，它是通过一个自己的bus来实现的，在spi中，是通过core文件中注册的spi_bus_type实现，在i2c中，则是通过core中的i2c_bus_type实现(其实spi和i2c子系统是比较相像的)，具体到spi的驱动中，这个core就是spi.c文件，所以在此我们简单看一下spi.c。

[csharp]
  1. struct bus_type spi_bus_type = {        //spi_device和spi_driver都向其注册 
  2.     .name       = "spi", 
  3.     .dev_attrs  = spi_dev_attrs, 
  4.     .match      = spi_match_device, //总线的match函数 
  5.     .uevent     = spi_uevent, 
  6.     .suspend    = spi_suspend, 
  7.     .resume     = spi_resume, 
  8. }; 
  9.  
  10. static int __init spi_init(void)        //初始化函数 
  11. { 
  12.     int status; 
  13.  
  14.     buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL); 
  15.     if (!buf) { 
  16.         status = -ENOMEM; 
  17.         goto err0; 
  18.     } 
  19.  
  20.     status = bus_register(&spi_bus_type);           //注册spi_bus_type 
  21.     if (status < 0) 
  22.         goto err1; 
  23.  
  24.     status = class_register(&spi_master_class);     //创建spi_master_class类 
  25.     if (status < 0) 
  26.         goto err2; 
  27.     return 0; 
  28.  
  29. err2: 
  30.     bus_unregister(&spi_bus_type); 
  31. err1: 
  32.     kfree(buf); 
  33.     buf = NULL; 
  34. err0: 
  35.     return status; 
  36. } 


根据前面分析，我们知道控制器驱动对应文件spi_s3c24xx.c，其完成的主要工作就是从BSP中取出master controller的信息(通过系统platform_bus)，产生master controller并注册到spi_bus_type，接着扫描BSP中注册的设备链表产生spi_device并一并将它们注册到spi_bus_type，这样，当spi_driver注册到spi_bus_type时就可以与spi_device进行匹配(具体是首先通过spi_bus_type的match函数(一般是通过比较两者的名字实现)，进一步通过spi_driver的probe函数实现)，看其初始化函数

[csharp]
  1. static struct platform_driver s3c24xx_spi_driver = { 
  2.     .remove     = __exit_p(s3c24xx_spi_remove), 
  3.     .driver     = { 
  4.         .name   = "s3c2410-spi", 
  5.         .owner  = THIS_MODULE, 
  6.         .pm = S3C24XX_SPI_PMOPS, 
  7.     }, 
  8. }; 
  9. static int __init s3c24xx_spi_init(void) 
  10. { 
  11.         return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe); 
  12. } 


Master controller设备需要在BSP中向platfor_bus注册，具体是在/arch/arm/plat-s3c24xx/devs.c中定义：


[csharp]
  1. static struct resource s3c_spi0_resource[] = {       
  2.     [0] = { 
  3.         .start = S3C24XX_PA_SPI, 
  4.         .end   = S3C24XX_PA_SPI + 0x1f, 
  5.         .flags = IORESOURCE_MEM, 
  6.     }, 
  7.     [1] = { 
  8.         .start = IRQ_SPI0, 
  9.         .end   = IRQ_SPI0, 
  10.         .flags = IORESOURCE_IRQ, 
  11.     } 
  12.  
  13. }; 
  14.  
  15. static u64 s3c_device_spi0_dmamask = 0xffffffffUL; 
  16.  
  17. struct platform_device s3c_device_spi0 = {              //spi控制器信息 
  18.     .name         = "s3c2410-spi", 
  19.     .id       = 0, 
  20.     .num_resources    = ARRAY_SIZE(s3c_spi0_resource), 
  21.     .resource     = s3c_spi0_resource, 
  22.         .dev              = { 
  23.                 .dma_mask = &s3c_device_spi0_dmamask, 
  24.                 .coherent_dma_mask = 0xffffffffUL 
  25.         } 
  26. }; 


并在/arch/arm/mach-s3c2440/mach-mini2440.c中向platform_bus进行注册

[csharp]
  1. static struct platform_device *mini2440_devices[] __initdata = { 
  2.     &s3c_device_usb, 
  3.     &s3c_device_rtc, 
  4.     &s3c_device_lcd, 
  5.     &s3c_device_wdt, 
  6.     &s3c_device_i2c0, 
  7.     &s3c_device_iis, 
  8.     &mini2440_device_eth, 
  9.     &s3c24xx_uda134x, 
  10.     &s3c_device_nand, 
  11.     &s3c_device_sdi, 
  12.     &s3c_device_usbgadget, 
  13. &s3c_device_spi0， 
  14. }; 
  15.  
  16. static void __init mini2440_machine_init(void) 
  17. { 
  18. #if defined (LCD_WIDTH) 
  19.     s3c24xx_fb_set_platdata(&mini2440_fb_info); 
  20. #endif 
  21.     s3c_i2c0_set_platdata(NULL); 
  22.  
  23.     s3c2410_gpio_cfgpin(S3C2410_GPC(0), S3C2410_GPC0_LEND); 
  24.  
  25.     s3c_device_nand.dev.platform_data = &friendly_arm_nand_info; 
  26.     s3c_device_sdi.dev.platform_data = &mini2440_mmc_cfg; 
  27.     platform_add_devices(mini2440_devices, ARRAY_SIZE(mini2440_devices)); 
  28.     s3c_pm_init(); 
  29. } 
  30.  
  31. MACHINE_START(MINI2440, "FriendlyARM Mini2440 development board") 
  32.     .phys_io    = S3C2410_PA_UART, 
  33.     .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc, 
  34.     .boot_params    = S3C2410_SDRAM_PA + 0x100, 
  35.  
  36.     .init_irq   = s3c24xx_init_irq, 
  37.     .map_io     = mini2440_map_io, 
  38.     .init_machine   = mini2440_machine_init, 
  39.     .timer      = &s3c24xx_timer, 
  40. MACHINE_END 


我们回头看platform_bus_type的match函数:

[csharp]
  1. struct bus_type platform_bus_type = { 
  2.     .name       = "platform", 
  3.     .dev_attrs  = platform_dev_attrs, 
  4.     .match      = platform_match, 
  5.     .uevent     = platform_uevent, 
  6.     .pm     = &platform_dev_pm_ops, 
  7. }; 
  8.  
  9. static int platform_match(struct device *dev, struct device_driver *drv) 
  10. { 
  11.     struct platform_device *pdev = to_platform_device(dev); 
  12.     struct platform_driver *pdrv = to_platform_driver(drv); 
  13.  
  14.     /* match against the id table first */ 
  15.     if (pdrv->id_table) 
  16.         return platform_match_id(pdrv->id_table, pdev) != NULL; 
  17.  
  18.     /* fall-back to driver name match */ 
  19.     return (strcmp(pdev->name, drv->name) == 0); 
  20. }    



分析可知BSP中注册的控制器名字和spi_s3c24xx.c注册的驱动名字可以通过名字进行匹配，紧接着会调用s3c24xx_spi_probe函数：

[csharp]
  1. static int __init s3c24xx_spi_probe(struct platform_device *pdev) 
  2. { 
  3.     struct s3c2410_spi_info *pdata; 
  4.     struct s3c24xx_spi *hw; 
  5.     struct spi_master *master; 
  6.     struct resource *res; 
  7.     int err = 0; 
  8.  
  9.     master = spi_alloc_master(&pdev->dev, sizeof(struct s3c24xx_spi));   //分配spi_master，见下面分析 
  10.     if (master == NULL) { 
  11.         dev_err(&pdev->dev, "No memory for spi_master\n"); 
  12.         err = -ENOMEM; 
  13.         goto err_nomem; 
  14.     } 
  15.  
  16.     hw = spi_master_get_devdata(master);        //获得struct s3c24xx_spi 
  17.     memset(hw, 0, sizeof(struct s3c24xx_spi)); 
  18.  
  19.     hw->master = spi_master_get(master); 
  20.     hw->pdata = pdata = pdev->dev.platform_data;  //获取平台设备信息，需要我们自己在BSP添加 
  21.     hw->dev = &pdev->dev; 
  22.  
  23.     if (pdata == NULL) { 
  24.         dev_err(&pdev->dev, "No platform data supplied\n"); 
  25.         err = -ENOENT; 
  26.         goto err_no_pdata; 
  27.     } 
  28.  
  29.     platform_set_drvdata(pdev, hw); 
  30.     init_completion(&hw->done); 
  31.  
  32.     /* setup the master state. */ 
  33.  
  34.     /* the spi->mode bits understood by this driver: */ 
  35.     master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH; //spi_device.mode flags understood by this controller driver 
  36.     master->num_chipselect = hw->pdata->num_cs;//支持的spi外设个数 
  37.     master->bus_num = pdata->bus_num;         //总线号 
  38.  
  39.     /* setup the state for the bitbang driver */ 
  40.     hw->bitbang.master         = hw->master; 
  41.     hw->bitbang.setup_transfer = s3c24xx_spi_setupxfer; 
  42.     hw->bitbang.chipselect     = s3c24xx_spi_chipsel; 
  43.     hw->bitbang.txrx_bufs      = s3c24xx_spi_txrx; 
  44.  
  45.     hw->master->setup  = s3c24xx_spi_setup; 
  46.     hw->master->cleanup = s3c24xx_spi_cleanup; 
  47.  
  48.     dev_dbg(hw->dev, "bitbang at %p\n", &hw->bitbang); 
  49.  
  50.     /* find and map our resources */ 
  51.  
  52.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);   //获取资源 
  53.     if (res == NULL) { 
  54.         dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n"); 
  55.         err = -ENOENT; 
  56.         goto err_no_iores; 
  57.     } 
  58.  
  59.     hw->ioarea = request_mem_region(res->start, resource_size(res), 
  60.                     pdev->name); 
  61.  
  62.     if (hw->ioarea == NULL) { 
  63.         dev_err(&pdev->dev, "Cannot reserve region\n"); 
  64.         err = -ENXIO; 
  65.         goto err_no_iores; 
  66.     } 
  67.  
  68.     hw->regs = ioremap(res->start, resource_size(res)); 
  69.     if (hw->regs == NULL) { 
  70.         dev_err(&pdev->dev, "Cannot map IO\n"); 
  71.         err = -ENXIO; 
  72.         goto err_no_iomap; 
  73.     } 
  74.  
  75.     hw->irq = platform_get_irq(pdev, 0); 
  76.     if (hw->irq < 0) { 
  77.         dev_err(&pdev->dev, "No IRQ specified\n"); 
  78.         err = -ENOENT; 
  79.         goto err_no_irq; 
  80.     } 
  81.  
  82.     err = request_irq(hw->irq, s3c24xx_spi_irq, 0, pdev->name, hw); //申请中断 
  83.     if (err) { 
  84.         dev_err(&pdev->dev, "Cannot claim IRQ\n"); 
  85.         goto err_no_irq; 
  86.     } 
  87.  
  88.     hw->clk = clk_get(&pdev->dev, "spi"); //获取时钟 
  89.     if (IS_ERR(hw->clk)) { 
  90.         dev_err(&pdev->dev, "No clock for device\n"); 
  91.         err = PTR_ERR(hw->clk); 
  92.         goto err_no_clk; 
  93.     } 
  94.  
  95.     /* setup any gpio we can */ 
  96.  
  97.     if (!pdata->set_cs) {        //设置“设置片选函数”，可以是单独的GPIO，在BSP中配置 
  98.         if (pdata->pin_cs < 0) { 
  99.             dev_err(&pdev->dev, "No chipselect pin\n"); 
  100.             goto err_register; 
  101.         } 
  102.  
  103.         err = gpio_request(pdata->pin_cs, dev_name(&pdev->dev)); 
  104.         if (err) { 
  105.             dev_err(&pdev->dev, "Failed to get gpio for cs\n"); 
  106.             goto err_register; 
  107.         } 
  108.  
  109.         hw->set_cs = s3c24xx_spi_gpiocs; 
  110.         gpio_direction_output(pdata->pin_cs, 1); 
  111.     } else 
  112.         hw->set_cs = pdata->set_cs; 
  113.  
  114.     s3c24xx_spi_initialsetup(hw);//初始化设置寄存器，包括对SPIMOSI,SPIMISO,SPICLK引脚的设置 
  115.  
  116.     /* register our spi controller */ 
  117.  
  118.     err = spi_bitbang_start(&hw->bitbang);       //见下面分析 
  119.     if (err) { 
  120.         dev_err(&pdev->dev, "Failed to register SPI master\n"); 
  121.         goto err_register; 
  122.     } 
  123.  
  124.     return 0; 
  125. …………………………………………………………………………………………………………………………………………………. 
  126. } 


其中：

[csharp]
  1. struct spi_master *spi_alloc_master(struct device *dev, unsigned size) 
  2. { 
  3.     struct spi_master   *master; 
  4.  
  5.     if (!dev) 
  6.         return NULL; 
  7.  
  8.     master = kzalloc(size + sizeof *master, GFP_KERNEL);    //分配空间 
  9.     if (!master) 
  10.         return NULL; 
  11.  
  12.     device_initialize(&master->dev); 
  13.     master->dev.class = &spi_master_class; 
  14.     master->dev.parent = get_device(dev); 
  15.     spi_master_set_devdata(master, &master[1]);// master[1]即struct s3c24xx_spi，作为spi_master的私有数据，可以通过spi_master_get_devdata(master)获得其指针。 
  16.  
  17.     return master; 
  18. } 


spi_bitbang_start主要实现master->hw->bitbang的初始化设置，包括初始化bitbang中的work_struct、建立工作队列、注册master等等：

[csharp]
  1. int spi_bitbang_start(struct spi_bitbang *bitbang) 
  2. { 
  3.     int status; 
  4.  
  5.     if (!bitbang->master || !bitbang->chipselect) 
  6.         return -EINVAL; 
  7.  
  8.     INIT_WORK(&bitbang->work, bitbang_work);//初始化bitbang->work，其工作函数是bitbang_work 
  9.     spin_lock_init(&bitbang->lock);  //初始化操作 
  10.     INIT_LIST_HEAD(&bitbang->queue); 
  11.  
  12.     if (!bitbang->master->mode_bits) 
  13.         bitbang->master->mode_bits = SPI_CPOL | SPI_CPHA | bitbang->flags; 
  14.  
  15.     if (!bitbang->master->transfer) 
  16.         bitbang->master->transfer = spi_bitbang_transfer;//真正的数据传输函数 
  17.     if (!bitbang->txrx_bufs) {       //此处为 s3c24xx_spi_txrx，见s3c24xx_spi_probe函数 
  18.         bitbang->use_dma = 0; 
  19.         bitbang->txrx_bufs = spi_bitbang_bufs; 
  20.         if (!bitbang->master->setup) { 
  21.             if (!bitbang->setup_transfer) 
  22.                 bitbang->setup_transfer = 
  23.                      spi_bitbang_setup_transfer; 
  24.             bitbang->master->setup = spi_bitbang_setup; 
  25.             bitbang->master->cleanup = spi_bitbang_cleanup; 
  26.         } 
  27.     } else if (!bitbang->master->setup) 
  28.         return -EINVAL; 
  29.  
  30.     /* this task is the only thing to touch the SPI bits */ 
  31.     bitbang->busy = 0; 
  32.     bitbang->workqueue = create_singlethread_workqueue(  //建立工作队列 
  33.             dev_name(bitbang->master->dev.parent)); 
  34.     if (bitbang->workqueue == NULL) { 
  35.         status = -EBUSY; 
  36.         goto err1; 
  37.     } 
  38.  
  39.     /* driver may get busy before register() returns, especially
  40.      * if someone registered boardinfo for devices
  41.      */ 
  42.     status = spi_register_master(bitbang->master);   //将spi master注册到spi_bus_type，见下面分析 
  43.     if (status < 0) 
  44.         goto err2; 
  45.  
  46.     return status; 
  47.  
  48. err2: 
  49.     destroy_workqueue(bitbang->workqueue); 
  50. err1: 
  51.     return status; 
  52. } 



spi_register_master函数:

[csharp]
  1. int spi_register_master(struct spi_master *master) 
  2. { 
  3.     static atomic_t     dyn_bus_id = ATOMIC_INIT((1<<15) - 1); 
  4.     struct device       *dev = master->dev.parent; 
  5.     int         status = -ENODEV; 
  6.     int         dynamic = 0; 
  7.  
  8.     if (!dev) 
  9.         return -ENODEV; 
  10.  
  11.     /* even if it's just one always-selected device, there must
  12.      * be at least one chipselect
  13.      */ 
  14.     if (master->num_chipselect == 0) 
  15.         return -EINVAL; 
  16.  
  17.     /* convention:  dynamically assigned bus IDs count down from the max */ 
  18.     if (master->bus_num < 0) { 
  19.         /* FIXME switch to an IDR based scheme, something like
  20.          * I2C now uses, so we can't run out of "dynamic" IDs
  21.          */ 
  22.         master->bus_num = atomic_dec_return(&dyn_bus_id); 
  23.         dynamic = 1; 
  24.     } 
  25.  
  26.     /* register the device, then userspace will see it.
  27.      * registration fails if the bus ID is in use.
  28.      */ 
  29.     dev_set_name(&master->dev, "spi%u", master->bus_num); 
  30.     status = device_add(&master->dev);   //将spi master注册到spi_bus_type 
  31.     if (status < 0) 
  32.         goto done; 
  33.     dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev), 
  34.             dynamic ? " (dynamic)" : ""); 
  35.  
  36.     /* populate children from any spi device tables */ 
  37.     scan_boardinfo(master);  //扫描设备链表，产生spi_device并注册到spi_bus_type 
  38.     status = 0; 
  39. done: 
  40.     return status; 
  41. } 


scan_boardinfo函数：

[csharp]
  1. static void scan_boardinfo(struct spi_master *master) 
  2. { 
  3.     struct boardinfo    *bi; 
  4.  
  5.     mutex_lock(&board_lock); 
  6.     list_for_each_entry(bi, &board_list, list) {    //遍历board_list链表中的每个boardinfo结构 
  7.         struct spi_board_info   *chip = bi->board_info; 
  8.         unsigned        n; 
  9.         //读取每个boardinfo中的n_board_info个spi_board_info信息分别产生一个spi_device 
  10.         for (n = bi->n_board_info; n > 0; n--, chip++) { 
  11.             if (chip->bus_num != master->bus_num)  //判断是否由当前spi master控制 
  12.                 continue; 
  13.             /* NOTE: this relies on spi_new_device to
  14.              * issue diagnostics when given bogus inputs
  15.              */ 
  16.             (void) spi_new_device(master, chip);    //产生spi device并注册到spi_bus_type 
  17.         } 
  18.     } 
  19.     mutex_unlock(&board_lock); 
  20. } 


现在问题出来了，既然是扫描board_list链表产生spi device，那么是在哪里往board_list注册信息的呢？答案是BSP中通过调用spi.c中的spi_register_board_info函数实现的，见下面分析。

[csharp]
  1. int __init 
  2. spi_register_board_info(struct spi_board_info const *info, unsigned n) 
  3. { 
  4.     struct boardinfo    *bi; 
  5.  
  6.     bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL); //添加n个spi_board_info信息 
  7.     if (!bi) 
  8.         return -ENOMEM; 
  9.     bi->n_board_info = n; 
  10.     memcpy(bi->board_info, info, n * sizeof *info); 
  11.  
  12.     mutex_lock(&board_lock); 
  13.     list_add_tail(&bi->list, &board_list);   //添加到board_list列表 
  14.     mutex_unlock(&board_lock); 
  15.     return 0; 
  16. } 


spi_new_device函数用于读取已经注册的spi设备信息，产生spi_device并注册到spi_bus_type：

[csharp]
  1. struct spi_device *spi_new_device(struct spi_master *master, 
  2.                   struct spi_board_info *chip) 
  3. { 
  4.     struct spi_device   *proxy; 
  5.     int         status; 
  6.  
  7.     /* NOTE:  caller did any chip->bus_num checks necessary.
  8.      *
  9.      * Also, unless we change the return value convention to use
  10.      * error-or-pointer (not NULL-or-pointer), troubleshootability
  11.      * suggests syslogged diagnostics are best here (ugh).
  12.      */ 
  13.  
  14.     proxy = spi_alloc_device(master);   //分配spi_device，总线类型为spi_bus_type，见下面分析 
  15.     if (!proxy) 
  16.         return NULL; 
  17.  
  18.     WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias)); 
  19.     // 根据BSP信息，设置spi_device对应字段 
  20.     proxy->chip_select = chip->chip_select; 
  21.     proxy->max_speed_hz = chip->max_speed_hz; 
  22.     proxy->mode = chip->mode; 
  23.     proxy->irq = chip->irq; 
  24.     strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias)); 
  25.     proxy->dev.platform_data = (void *) chip->platform_data; 
  26.     proxy->controller_data = chip->controller_data; 
  27.     proxy->controller_state = NULL; 
  28.  
  29.     status = spi_add_device(proxy); 
  30.     if (status < 0) { 
  31.         spi_dev_put(proxy); 
  32.         return NULL; 
  33.     } 
  34.  
  35.     return proxy; 
  36. } 


spi_alloc_device函数

[csharp]
  1. struct spi_device *spi_alloc_device(struct spi_master *master) 
  2. { 
  3.     struct spi_device   *spi; 
  4.     struct device       *dev = master->dev.parent; 
  5.  
  6.     if (!spi_master_get(master)) 
  7.         return NULL; 
  8.  
  9.     spi = kzalloc(sizeof *spi, GFP_KERNEL); 
  10.     if (!spi) { 
  11.         dev_err(dev, "cannot alloc spi_device\n"); 
  12.         spi_master_put(master); 
  13.         return NULL; 
  14.     } 
  15.  
  16.     spi->master = master; 
  17.     spi->dev.parent = dev; 
  18.     spi->dev.bus = &spi_bus_type;    //在spi.c注册的spi_bus_type 
  19.     spi->dev.release = spidev_release; 
  20.     device_initialize(&spi->dev); 
  21.     return spi; 
  22. } 


spi_add_device函数，用于将spi_device注册到spi_bus_type

[csharp]
  1. int spi_add_device(struct spi_device *spi) 
  2. { 
  3.     static DEFINE_MUTEX(spi_add_lock); 
  4.     struct device *dev = spi->master->dev.parent; 
  5.     int status; 
  6.  
  7.     /* Chipselects are numbered 0..max; validate. */ 
  8.     if (spi->chip_select >= spi->master->num_chipselect) { //设备序号大于master支持的最大值？ 
  9.         dev_err(dev, "cs%d >= max %d\n", 
  10.             spi->chip_select, 
  11.             spi->master->num_chipselect); 
  12.         return -EINVAL; 
  13.     } 
  14.  
  15.     /* Set the bus ID string */ 
  16.     dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev), 
  17.             spi->chip_select); 
  18.  
  19.  
  20.     /* We need to make sure there's no other device with this
  21.      * chipselect **BEFORE** we call setup(), else we'll trash
  22.      * its configuration.  Lock against concurrent add() calls.
  23.      */ 
  24.     mutex_lock(&spi_add_lock); 
  25.     //该设备已经在spi_bus_type中注册？ 
  26.     if (bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev)) 
  27.             != NULL) { 
  28.         dev_err(dev, "chipselect %d already in use\n", 
  29.                 spi->chip_select); 
  30.         status = -EBUSY; 
  31.         goto done; 
  32.     } 
  33.  
  34.     /* Drivers may modify this initial i/o setup, but will
  35.      * normally rely on the device being setup.  Devices
  36.      * using SPI_CS_HIGH can't coexist well otherwise...
  37.      */ 
  38.     status = spi_setup(spi);    //对设备模式及时钟进行设置，见下面分析 
  39.     if (status < 0) { 
  40.         dev_err(dev, "can't %s %s, status %d\n", 
  41.                 "setup", dev_name(&spi->dev), status); 
  42.         goto done; 
  43.     } 
  44.  
  45.     /* Device may be bound to an active driver when this returns */ 
  46.     status = device_add(&spi->dev);  //将spi_device添加到系统中 
  47.     if (status < 0) 
  48.         dev_err(dev, "can't %s %s, status %d\n", 
  49.                 "add", dev_name(&spi->dev), status); 
  50.     else 
  51.         dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev)); 
  52.  
  53. done: 
  54.     mutex_unlock(&spi_add_lock); 
  55.     return status; 
  56. } 


spi_setup函数：

[csharp]
  1. int spi_setup(struct spi_device *spi) 
  2. { 
  3.     unsigned    bad_bits; 
  4.     int     status; 
  5.  
  6.     /* help drivers fail *cleanly* when they need options
  7.      * that aren't supported with their current master
  8.      */ 
  9.     bad_bits = spi->mode & ~spi->master->mode_bits; //spi master支持该设备的模式位？ 
  10.     if (bad_bits) { 
  11.         dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n", 
  12.             bad_bits); 
  13.         return -EINVAL; 
  14.     } 
  15.  
  16.     if (!spi->bits_per_word) 
  17.         spi->bits_per_word = 8; 
  18.  
  19. //利用master的setup函数进行设置，其值为s3c24xx_spi_setup，在s3c24xx_spi_probe函数中设置 
  20.     status = spi->master->setup(spi); //见下面分析 
  21.  
  22.     dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s" 
  23.                 "%u bits/w, %u Hz max --> %d\n", 
  24.             (int) (spi->mode & (SPI_CPOL | SPI_CPHA)), 
  25.             (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "", 
  26.             (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "", 
  27.             (spi->mode & SPI_3WIRE) ? "3wire, " : "", 
  28.             (spi->mode & SPI_LOOP) ? "loopback, " : "", 
  29.             spi->bits_per_word, spi->max_speed_hz, 
  30.             status); 
  31.  
  32.     return status; 
  33. } 


s3c24xx_spi_setup函数

[csharp]
  1. static int s3c24xx_spi_setup(struct spi_device *spi) 
  2. { 
  3.     struct s3c24xx_spi_devstate *cs = spi->controller_state; 
  4.     struct s3c24xx_spi *hw = to_hw(spi); 
  5.     int ret; 
  6.  
  7.     /* allocate settings on the first call */ 
  8.     if (!cs) { 
  9.         cs = kzalloc(sizeof(struct s3c24xx_spi_devstate), GFP_KERNEL);   
  10.         if (!cs) { 
  11.             dev_err(&spi->dev, "no memory for controller state\n"); 
  12.             return -ENOMEM; 
  13.         } 
  14.  
  15.         cs->spcon = SPCON_DEFAULT; 
  16.         cs->hz = -1; 
  17.         spi->controller_state = cs; 
  18.     } 
  19.  
  20.     /* initialise the state from the device */ 
  21.     ret = s3c24xx_spi_update_state(spi, NULL);  //见下面分析 
  22.     if (ret) 
  23.         return ret; 
  24.  
  25.     spin_lock(&hw->bitbang.lock); 
  26.     if (!hw->bitbang.busy) { 
  27.         hw->bitbang.chipselect(spi, BITBANG_CS_INACTIVE); 
  28.         /* need to ndelay for 0.5 clocktick ? */ 
  29.     } 
  30.     spin_unlock(&hw->bitbang.lock); 
  31.  
  32.     return 0; 
  33. } 



s3c24xx_spi_update_state主要用于根据spi_device或者spi_transfer设置spi_device->controller_state。

[csharp]
  1. static int s3c24xx_spi_update_state(struct spi_device *spi, 
  2.                     struct spi_transfer *t) 
  3. { 
  4.     struct s3c24xx_spi *hw = to_hw(spi); 
  5.     struct s3c24xx_spi_devstate *cs = spi->controller_state; 
  6.     unsigned int bpw; 
  7.     unsigned int hz; 
  8.     unsigned int div; 
  9.     unsigned long clk; 
  10.     //transfer存在，则以其作为设置标准 
  11.     bpw = t ? t->bits_per_word : spi->bits_per_word;  
  12.     hz  = t ? t->speed_hz : spi->max_speed_hz; 
  13.  
  14.     if (!bpw) 
  15.         bpw = 8; 
  16.  
  17.     if (!hz) 
  18.         hz = spi->max_speed_hz; 
  19.  
  20.     if (bpw != 8) { 
  21.         dev_err(&spi->dev, "invalid bits-per-word (%d)\n", bpw); 
  22.         return -EINVAL; 
  23.     } 
  24.  
  25.     if (spi->mode != cs->mode) { 
  26.         u8 spcon = SPCON_DEFAULT; 
  27.  
  28.         if (spi->mode & SPI_CPHA) 
  29.             spcon |= S3C2410_SPCON_CPHA_FMTB; 
  30.  
  31.         if (spi->mode & SPI_CPOL) 
  32.             spcon |= S3C2410_SPCON_CPOL_HIGH; 
  33.  
  34.         cs->mode = spi->mode; 
  35.         cs->spcon = spcon; 
  36.     } 
  37.  
  38.     if (cs->hz != hz) { 
  39.         clk = clk_get_rate(hw->clk); 
  40.         div = DIV_ROUND_UP(clk, hz * 2) - 1; 
  41.  
  42.         if (div > 255) 
  43.             div = 255; 
  44.  
  45.         dev_dbg(&spi->dev, "pre-scaler=%d (wanted %d, got %ld)\n", 
  46.             div, hz, clk / (2 * (div + 1))); 
  47.  
  48.         cs->hz = hz; 
  49.         cs->sppre = div; 
  50.     } 
  51.  
  52.     return 0; 
  53. } 



总结：

我们发现在设备驱动侧所有的设备信息都是借助于在BSP中提供的设备信息来创建对应的结构体，其实这是linux中的一种思想，将设备和驱动分离。linux内核这么做是为了提高可移植性，当我们添加一些新的设备的时候，只要在BSP中添加设备信息，当驱动注册的时候，会根据你配置的设备信息产生对应的结构，删除设备亦是如此，整个过程只需要我们改动设备侧而驱动是一模一样的，理所当然提高了驱动的可移植性！

上一篇：转一篇UBOOT调试的
下一篇：Mac与Phy组成原理的简单分析