linux spi驱动开发学习(三)-----spi_bitbang.c详解

经过了前面两节的学习,现在到了这个环节了,spi驱动的完整工作过程渐渐明朗起来
不多说废话了,直接进主题,大家共同学习,共同进步

首先,还是先唠叨以下,以方便接下来对bitbang机制的学习,那就是spi 的工作时序,这里直接转载自己看到的一篇文章
http://www.52rd.com/Blog/Detail_RD.Blog_yuwenxin_21678.html?#Flag_Comment
这里也同时感谢楼主的分享

SPI时序图详解

(2009-10-18 21:49)

SPI接口在模式0下输出第一位数据的时刻

SPI接口有四种不同的数据传输时序，取决于CPOL和CPHL这两位的组合。图1中表现了这四种时序，
时序与CPOL、CPHL的关系也可以从图中看出。

图1

CPOL是用来决定SCK时钟信号空闲时的电平，CPOL＝0，空闲电平为低电平，CPOL＝1时，

空闲电平为高电平。CPHA是用来决定采样时刻的，CPHA=0，在每个周期的第一个时钟沿采样，

CPHA＝1，在每个周期的第二个时钟沿采样。

由于我使用的器件工作在模式0这种时序（CPOL＝0，CPHA＝0），所以将图1简化为图2，
只关注模式0的时序。

图2

我们来关注SCK的第一个时钟周期，在时钟的前沿采样数据（上升沿，第一个时钟沿），
在时钟的后沿输出数据（下降沿，第二个时钟沿）。首先来看主器件，主器件的输出口（MOSI）输出的数据bit1，
在时钟的前沿被从器件采样，那主器件是在何时刻输出bit1的呢？bit1的输出时刻实际上在SCK信号有效以前，
比 SCK的上升沿还要早半个时钟周期。bit1的输出时刻与SSEL信号没有关系。再来看从器件，
主器件的输入口MISO同样是在时钟的前沿采样从器件输出的bit1的，那从器件又是在何时刻输出bit1的呢。
从器件是在SSEL信号有效后，立即输出bit1，尽管此时SCK信号还没有起效。关于上面的主器件
和从器件输出bit1位的时刻，可以从图3、4中得到验证。

图3

注意图3中，CS信号有效后（低电平有效，注意CS下降沿后发生的情况），故意用延时程序
延时了一段时间，之后再向数据寄存器写入了要发送的数据，来观察主器件输出bit1的情况（MOSI）。
可以看出，bit1（值为1）是在SCK信号有效之前的半个时钟周期的时刻开始输出的（与CS信号无关），
到了SCK的第一个时钟周期的上升沿正好被从器件采样。

图4

图4中，注意看CS和MISO信号。我们可以看出，CS信号有效后，从器件立刻输出了bit1（值为1）。

通常我们进行的spi操作都是16位的。图5记录了第一个字节和第二个字节间的相互衔接的过程。
第一个字节的最后一位在SCK的上升沿被采样，随后的SCK下降沿，从器件就输出了第二个字节的第一位。

图5

熟悉了spi 的工作时序,接着往下说

注意:

CPOL是用来决定SCK时钟信号空闲时的电平，CPOL＝0，空闲电平为低电平，CPOL＝1时，空闲电平为高电平。
CPHA是用来决定采样时刻的，
CPHA=0，在每个周期的第一个时钟沿采样，
CPHA＝1，在每个周期的第二个时钟沿采样。

linux的SPI模型中重要的有如下几个结构体,位置include/linux/spi/spi.h

struct spi_device {}  //Master side proxy for an SPI slave device

struct spi_driver {}  //Host side "protocol" driver

struct spi_master {}  //interface to SPI master controller

struct spi_transfer{}  //a read/write buffer pair

在这几个结构体中，我们只注意一下device结构体

1. struct spi_device
   
2. {
   
3. .....
   
4. #define SPI_CPHA 0x01 /* clock phase 同步*/
   
5. #define SPI_CPOL 0x02 /* clock polarity */
   
6. #define SPI_MODE_0 (0|0) /* (original MicroWire) */
   
7. #define SPI_MODE_1 (0|SPI_CPHA)
   
8. #define SPI_MODE_2 (SPI_CPOL|0)
   
9. #define SPI_MODE_3 (SPI_CPOL|SPI_CPHA)
   
10. .....
    
11. }

注意如上定义的 SPI_CPHA和SPI_CPOL

这个和一中的CPHA,以及CPOL是对应的，

然后在次基础上定义了MODE?,到此，你是否能相像出SPI接口的数据传输过程？

下面才是刚刚进入真正的主题
以下是spi_bitbang结构体的定义

点击(此处)折叠或打开

1. struct spi_bitbang {
   
2.     struct workqueue_struct    *workqueue;
   
3.     struct work_struct    work;
   
4. 
   
5.     spinlock_t        lock;
   
6.     struct list_head    queue;
   
7.     u8            busy;
   
8.     u8            use_dma;
   
9.     u8            flags;        /* extra spi->mode support */
   
10. 
    
11.     struct spi_master    *master;
    
12. 
    
13.     /* setup_transfer() changes clock and/or wordsize to match settings
    
14.      * for this transfer; zeroes restore defaults from spi_device.
    
15.      */
    
16.     int    (*setup_transfer)(struct spi_device *spi,
    
17.             struct spi_transfer *t);
    
18. 
    
19.     void    (*chipselect)(struct spi_device *spi, int is_on);
    
20. #define    BITBANG_CS_ACTIVE    1    /* normally nCS, active low */
    
21. #define    BITBANG_CS_INACTIVE    0
    
22. 
    
23.     /* txrx_bufs() may handle dma mapping for transfers that don't
    
24.      * already have one (transfer.{tx,rx}_dma is zero), or use PIO
    
25.      */
    
26.     int    (*txrx_bufs)(struct spi_device *spi, struct spi_transfer *t);
    
27. 
    
28.     /* txrx_word[SPI_MODE_*]() just looks like a shift register */
    
29.     u32    (*txrx_word[4])(struct spi_device *spi,
    
30.             unsigned nsecs,
    
31.             u32 word, u8 bits);
    
32. };

这里我们只对加底纹部分做以下说明:
struct work_struct work;
这个让我们想入菲菲--bit bang是按照workqueue队列的形式来工作的吗？

worqueue这个是什么？简单地说，他就是一个队列，里面的每一个work节点代表着一个需要调度的工作。
具体可以百度，这个和tasklet有点相似的。以前自己有用过,经常用于中断的顶半部,底半部机制
既然是worqueue，那么我们可以猜想，spi是在每一个work中实现bit bang的。
事实上确实如此，在/driver/spi/spi_bitbang.c#L267中，我们可以看到如下函数
static void bitbang_work(struct work_struct *work){},
在/driver/spi/spi_bitbang.c中，我们可以发现
int spi_bitbang_start(struct spi_bitbang *bitbang);
这里还是有必要看一下这个方法的实现过程,看他都干了些什么:

点击(此处)折叠或打开

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);
   
9.     spin_lock_init(&bitbang->lock);
   
10.     INIT_LIST_HEAD(&bitbang->queue);
    
11. 
    
12.     if (!bitbang->master->mode_bits)//此处在s3c24xx_spi_probe方法中已定义,采用s3c24xx_spi_probe的设置
    
13.         bitbang->master->mode_bits = SPI_CPOL | SPI_CPHA | bitbang->flags;
    
14. 
    
15.     if (!bitbang->master->transfer)//此处在s3c24xx_spi_probe方法中没有定义,所以使用这里设置的方法
    
16.         bitbang->master->transfer = spi_bitbang_transfer;//之后发送数据的时候会用到这个接口
    
17. 
    
18.     if (!bitbang->txrx_bufs) {//此处在s3c24xx_spi_probe方法中已定义,采用s3c24xx_spi_probe的设置
    
19.         bitbang->use_dma = 0;
    
20.         bitbang->txrx_bufs = spi_bitbang_bufs;
    
21.         if (!bitbang->master->setup) {
    
22.             if (!bitbang->setup_transfer)
    
23.                 bitbang->setup_transfer =
    
24.                      spi_bitbang_setup_transfer;
    
25.             bitbang->master->setup = spi_bitbang_setup;
    
26.             bitbang->master->cleanup = spi_bitbang_cleanup;
    
27.         }
    
28.     } else if (!bitbang->master->setup)//此处在s3c24xx_spi_probe方法中已定义,从这里看来bitbang->master->setup必须定义,不可遗漏
    
29.         return -EINVAL;
    
30. 
    
31.     /* this task is the only thing to touch the SPI bits */
    
32.     bitbang->busy = 0;
    
33.     bitbang->workqueue = create_singlethread_workqueue(
    
34.             dev_name(bitbang->master->dev.parent));
    
35.     if (bitbang->workqueue == NULL) {
    
36.         status = -EBUSY;
    
37.         goto err1;
    
38.     }
    
39. 
    
40.     /* driver may get busy before register() returns, especially
    
41.      * if someone registered boardinfo for devices
    
42.      */
    
43.     status = spi_register_master(bitbang->master);
    
44.     if (status < 0)
    
45.         goto err2;
    
46. 
    
47.     return status;
    
48. 
    
49. err2:
    
50.     destroy_workqueue(bitbang->workqueue);
    
51. err1:
    
52.     return status;
    
53. }
    
54. EXPORT_SYMBOL_GPL(spi_bitbang_start);

看看spi_register_master的实现过程:

点击(此处)折叠或打开

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);//添加设备
    
31.     if (status < 0)
    
32.         goto done;
    
33.     dev_dbg(dev, "registered master %s%sn", dev_name(&master->dev),
    
34.             dynamic ? " (dynamic)" : "");
    
35. 
    
36.     /* populate children from any spi device tables */
    
37.     scan_boardinfo(master);
    
38.     status = 0;
    
39. done:
    
40.     return status;
    
41. }
    
42. EXPORT_SYMBOL_GPL(spi_register_master);

看看scan_boardinfo原型:

点击(此处)折叠或打开

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) {
   
7.         struct spi_board_info    *chip = bi->board_info;
   
8.         unsigned        n;
   
9. 
   
10.         for (n = bi->n_board_info; n > 0; n--, chip++) {
    
11.             if (chip->bus_num != master->bus_num)
    
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);
    
17.         }
    
18.     }
    
19.     mutex_unlock(&board_lock);
    
20. }

点击(此处)折叠或打开

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);
    
15.     if (!proxy)
    
16.         return NULL;
    
17. 
    
18.     WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
    
19. 
    
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. }
    
37. EXPORT_SYMBOL_GPL(spi_new_device);

点击(此处)折叠或打开

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_devicen");
    
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;
    
19.     spi->dev.release = spidev_release;
    
20.     device_initialize(&spi->dev);
    
21.     return spi;
    
22. }
    
23. EXPORT_SYMBOL_GPL(spi_alloc_device);

点击(此处)折叠或打开

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) {
   
9.         dev_err(dev, "cs%d >= max %dn",
   
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. 
    
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 usen",
    
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 %dn",
    
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);
    
47.     if (status < 0)
    
48.         dev_err(dev, "can't %s %s, status %dn",
    
49.                 "add", dev_name(&spi->dev), status);
    
50.     else
    
51.         dev_dbg(dev, "registered child %sn", dev_name(&spi->dev));
    
52. 
    
53. done:
    
54.     mutex_unlock(&spi_add_lock);
    
55.     return status;
    
56. }
    
57. EXPORT_SYMBOL_GPL(spi_add_device);

点击(此处)折叠或打开

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;
   
10.     if (bad_bits) {
    
11.         dev_dbg(&spi->dev, "setup: unsupported mode bits %xn",
    
12.             bad_bits);
    
13.         return -EINVAL;
    
14.     }
    
15. 
    
16.     if (!spi->bits_per_word)
    
17.         spi->bits_per_word = 8;
    
18. 
    
19.     status = spi->master->setup(spi);//这里其实调用的就是s3c24xx_spi_probe里填充的spi->master->setup
    
20. 
    
21.     dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
    
22.                 "%u bits/w, %u Hz max --> %dn",
    
23.             (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
    
24.             (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
    
25.             (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
    
26.             (spi->mode & SPI_3WIRE) ? "3wire, " : "",
    
27.             (spi->mode & SPI_LOOP) ? "loopback, " : "",
    
28.             spi->bits_per_word, spi->max_speed_hz,
    
29.             status);
    
30. 
    
31.     return status;
    
32. }
    
33. EXPORT_SYMBOL_GPL(spi_setup);

点击(此处)折叠或打开

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 staten");
    
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. }

好了，至此spi主控制器(驱动)和板上spi设备注册完毕，以后要使用spi来传输数据的话，只要先获得spi设备结构，然后就可以利用它来和spi驱动打交道了(就好像你要操作一个文件，先要获取文件句柄一样，明白吧^_^)

具体的数据传输过程将在下一节进行,待续.....