linux spi驱动分析(基于STM32)

linux kernel 版本2.6.30, spi驱动基于platform_device, platform_driver驱动模型来编写.

SPI分为主从设备,一个主设备下可心挂接多个从设备,linux驱动中使用struct spi_master结构来表示一个主设备,
使用struct spi_device表示一个从设备.从设备通过spi_device->master指针来表示挂接到哪个主设备下.

一个CPU中一般都会有多个SPI主设备,SPI不同的主设备通过spi_master->bus_num来区分.
一般在定义platform_device的时候,通过platform_device->id来指定SPI主设备的bus_num号(在probe函数中,
spi_master->bus_num = platform_device->id).

总的来说,linux下的spi驱动可以分为两部分,
 一个是SPI主控器的驱动(主设备),这部分的驱动主要负责将数据一个字节一个字节的从SPI总线上传出去,或从SPI总线上
一个字节一个字节的读回来,它不用去理解几个字节组合起来是什么意思.
 另一部分驱动是从设备的驱动,因为从设备不同,驱动也不一样,主设备的驱动可以只有一个,但是如果从设备有好几个,那么
从设备的驱动也可能有好几个.如一个SPI主设备下挂有一个1M的SPI Flash,一个SPI的时钟芯片.对SPI Flash来说,往0xFFFFF地址
写数据,协议可能是这样:
字节0 字节1 字节2 字节3 字节4
地址0 地址1 地址2 地址3 数据
而往SPI时钟芯片写数据,协议可能是这样:
字节0        字节1
寄存器地址   寄存器值
所以从设备驱动就必须理解几个字节组合起来时,表示什么意思.如拿上面的SPI Flash来举例,从设备写5个数据,那前4个字节表示
SPI Flash的地址,最后一个字节表示往这个地址写的数据.从设备驱动写这5个字节时,最后会通过主设备驱动写到SPI总线上的(主
从驱动通过struct spi_message传输数据),SPI主设备驱动并不知道5个字节是什么意思,它只需要将从设备驱动传给它的这5个字
节写到SPI总线上就可以了.

platform_device驱动:
static struct platform_device spi_stm32_dev1 = {
 .name           = "spi_stm32",
 .id             = 0,
 .num_resources  = ARRAY_SIZE(spi_stm32_dev1_resources),
 .resource       = spi_stm32_dev1_resources,
};

static struct platform_device spi_stm32_dev2 = {
 .name           = "spi_stm32",
 .id             = 1,
 .num_resources  = ARRAY_SIZE(spi_stm32_dev2_resources),
 .resource       = spi_stm32_dev2_resources,
};

platform_device->id区别不同的spi主设备.
  
  platform_device_register(&spi_stm32_dev1); // 注册platform_device
  
  // 以下的信息是从设备驱动的信息
  // spi flash分区信息
  static struct mtd_partition
 |---------> spi_stm32_flash_partitions__stm32f4_som[] = {
 |  {
 |   .name = "spi_flash_part0",
 |   .size = FLASH_JFFS2_OFFSET__STM32F4_SOM,
 |   .offset = 0,
 |  },
 |  {
 |   .name = "spi_flash_part1",
 |   .size = FLASH_SIZE__STM32F4_SOM -
 |    FLASH_JFFS2_OFFSET__STM32F4_SOM,
 |   .offset = FLASH_JFFS2_OFFSET__STM32F4_SOM,
 |  },
 | };
 | // 分区信息和从设备驱动名称, 会有一个对应的从设备驱动(.name也="m25p32")
 | static struct flash_platform_data
 |  spi_stm32_flash_data__stm32f4_som = {      <---------|
 |  .name = "m25p32",       |
 -------------.parts =  spi_stm32_flash_partitions__stm32f4_som,  |
   .nr_parts =         |
   ARRAY_SIZE(spi_stm32_flash_partitions__stm32f4_som),    |
   .type = "m25p32",       |
  };          |
            |
  static struct spi_stm32_slv       |
 |-------> spi_stm32_flash_slv__stm32f4_som  = {    |
 |  .cs_gpio = SPI_FLASH_CS_GPIO__STM32F4_SOM,   |
 |  .timeout = 3,        |
 | };          |
 | static struct spi_board_info       |
 |  spi_stm32_flash_info__stm32f4_som = {    |
 |           |
 |  .modalias = "m25p32",      |
 |  .platform_data = &spi_stm32_flash_data__stm32f4_som, ----
 |  .max_speed_hz = 25000000,
 |  .bus_num = 4,
 |  .chip_select = 0,
 --------------.controller_data = &spi_stm32_flash_slv__stm32f4_som,
   .mode = SPI_MODE_3,
  };
  
  //注册从设备信息, 只将spi_board_info挂到全局链表board_list
  //struct spi_board_info 结构包含了从设备的所有信息
  spi_register_board_info(&spi_stm32_flash_info__stm32f4_som,
   sizeof(spi_stm32_flash_info__stm32f4_som) /
   sizeof(struct spi_board_info));

platform_driver驱动:

static int __devinit spi_stm32_probe(struct platform_device *dev)
{
 struct spi_master *m = NULL;
 struct spi_stm32 *c = NULL;
 int bus

 ......

 bus = dev->id;
 // 分配spi_master,sizeof *c为私有数据的大小, 通过spi_master_get_devdata()获取该私有数据
 m = spi_alloc_master(&dev->dev, sizeof *c);

 c = spi_master_get_devdata(m);
 m->bus_num = bus; // spi主设备id
 
 // 通过workqueue处理实际的数据传输
 c->workqueue = create_singlethread_workqueue(dev_name(&dev->dev));
 INIT_WORK(&c->work, spi_stm32_handle); // spi_stm32_handle将数据通过spi总线上传送 
 
 m->setup = spi_stm32_setup;
 m->cleanup = spi_stm32_cleanup;
 m->transfer = spi_stm32_transfer; // 当有数据传输时,spi设备驱动会调用此函数,该函数会调用queue_work,触发spi_stm32_handle函数进行数据传输
 c->slave = NULL; 
 ret = spi_register_master(m);// 注册spi_master 
}

spi_register_master调用scan_boardinfo函数,将spi设备与spi_master关联

void scan_boardinfo(struct spi_master *master)
{
 list_for_each_entry(bi, &board_list, list) {
  struct spi_board_info *chip = bi->board_info;
  unsigned  n;

  for (n = bi->n_board_info; n > 0; n--, chip++) {
   if (chip->bus_num != master->bus_num) // 设备的bus_num与spi_master的bus_num是否一样
    continue;
   (void) spi_new_device(master, chip);
  }
 }
}

spi_new_device调用spi_alloc_device分配一个struct spi_device, 将spi_device->master指向scan_boardinfo参数master,
这样spi_device与spi_master就关联起来了,spi_alloc_device还将spi_board_info信息copy过来.

下面来看一下从设备驱动
从设备驱动在/driver/mtd/devices/m25p80.c中

static struct spi_driver m25p80_driver = {
 .id_table = m25p_ids,
 .probe = m25p_probe,
 .remove = __devexit_p(m25p_remove),
}

m25p_ids中有"m25p32",当内核初始化时检查到与spi_board_info->modalias相等时,调用m25p_probe函数,
该函数中主要工作:

1.  注册spi_device的操作函数
 flash->mtd.erase = m25p80_erase;
 flash->mtd.read = m25p80_read;
 flash->mtd.write = m25p80_write;
2.     调用add_mtd_partitions注册分区信息

该函数中有一个结构struct m25p, 该结构中有:
 struct spi_device *spi;
 struct mtd_info mtd;
 这样spi_device和mtd设备就可以关联起来了.
 
拿m25p80_write来举例:
......
 struct m25p *flash = mtd_to_m25p(mtd);
 struct spi_transfer t[2];
 struct spi_message m; // 从设备驱动与主设备驱动以struct spi_message结构来交互数据

 // t[0]传输的是write命令和地址
 t[0].tx_buf = flash->command;
 t[0].len = m25p_cmdsz(flash);
 spi_message_add_tail(&t[0], &m);
 // t[1]传输的是要写进去的数据
 t[1].tx_buf = buf; // 传进来的数据缓冲区和长度
 t[1].len    = len;
 spi_message_add_tail(&t[1], &m);
 
 flash->command[0] = OPCODE_PP; // program命令
 m25p_addr2cmd(flash, to, flash->command);  //地址存到flash->command[1], flash->command[2], flash->command[3], to为要写到spi flash中的地址
 
 //设置好命令和数据之后,调用spi_sync传输数据
 spi_sync(flash->spi, &m);

 spi_sync调用spi_async, spi_async调用spi_master->transfer来将数据传给主设备驱动.

 spi_master->transfer=spi_stm32_transfer:
 //该函数只是简单的将struct spi_message结挂到c->queue队列上,然后调用queue_work函数
 list_add_tail(&msg->queue, &c->queue);
 queue_work(c->workqueue, &c->work);

 调用queue_work之后,内核会在某一时候调用spi_stm32_handle,这部分属于内核工作队列的内容,可以找相关资料看一下.
 spi_stm32_handle最终会调用spi_stm32_hw_txfifo_put函数,将数据写到spi总线上.