驱动专题：第三章 Spi及spiflash驱动 5. Linux下的spi驱动

内核版本：linux2.6.32.2 
硬件资源：s3c2440
参考：  韦东山SPI视频教程


内容概括：
    1、I2C 驱动框架回顾
    2、SPI 框架简单介绍
    3、master 驱动框架
        3.1 驱动侧
        3.2 设备侧

    4、SPI 设备驱动框架

         4.1 设备册
        4.2 驱动侧

    5、设备驱动程序实例

1、I2C 驱动框架回顾
    在前面学习 I2C 驱动程序的时候我们知道，I2C 驱动框架分为两层，一层是控制器驱动程序 i2c_adapter，它一般是由芯片厂商写好的，主要提供一个 algorithm 底层的 i2c 协议的收发函数。i2c_adapter 驱动是基于 platform 模型，在driver侧的probe函数里，取出资源信息进行设置，最后将adapter注册到i2c_bus_type，注册时会调用 i2c_scan_static_board_info，扫描并使用 i2c_new_device 创建设备（设备层的设备）。我们还提到了4种创建device的方式。

    另一层是设备驱动层，基于 i2c_bus_type ，这个就很简单了，在设备驱动层 device 只需要提供一个从设备地址和名字，在 driver 里使用 i2c_smbus_read_byte_data 等类似的函数进行收发即可了，i2c_smbus_read_byte_data 等函数最终就会调用到 我们的 i2c_adapter->algorithm 里的收发函数进行收发。

2、SPI 框架简单介绍
    对于SPI的大框架，与I2C是完全一致的，也分为两层，控制器驱动程序层叫 spi_master ，主要提供transfer函数，进行spi协议的收发。spi_master 也是基于 Platform 模型的，注册 spi_master 时也会扫描一个链表进行注册设备，简直太相似了。

    另一层是设备驱动层，基于 spi_bus_type，相比 i2c 在device中需要提供的信息多一些，需要有名字、片选、最大速率、模式、中断号等等，在driver里则使用spi_read、spi_writer 等函数，最终也会调用到 master->transfer 函数进行发送接收。

    相比 I2C ，SPI驱动的框架是要简单的，因为它少了两种注册device的方式，另外它不需要像I2C一样去发送Start信号和设备地址去探测设备，SPI只需要片选选中就行了。但是它的底层收发的控制，相对I2C要复杂一点，毕竟4根线。

3、master 驱动框架
    之前，分析的驱动程序都是 S3C2410\S3C2440 平台的，由于我的开发板 Mini2440 没有SPI设备，因此厂商带的内核里关于 SPI 驱动部分不完整，而且在s3c23xx_spi_probe函数里注册master的时候写的十分复杂，干扰信息太多，不适合分析学习，因此，我搜索了一下其他平台的代码，发现 atmel_spi.c (drivers\spi)，里 atmel 实现的底层控制器驱动简单清晰多了，因此就拿它开刀，分析Master驱动框架。

  3.1 驱动侧

    前面简介里，我提到 master 驱动框架是基于 platform 平台的（我分析的这俩都是，其它的不清楚），那么肯定就要注册platform_driver了，下面我们就开看看。

分配一个platfrom_driver结构

1. static struct platform_driver atmel_spi_driver = {
2. .driver = {
3. .name = "atmel_spi",
4. .owner = THIS_MODULE,
5. },
6. .suspend = atmel_spi_suspend,
7. .resume = atmel_spi_resume,
8. .remove = __exit_p(atmel_spi_remove),
9. };

    将 atmel_spi_driver 注册到 platform_bus_type ，匹配设备 probe

1. static int __ init atmel_spi_init(void)
2. {
3. return platform_driver_probe(&atmel_spi_driver, atmel_spi_probe);
4. }

    我们之前都是将 probe 函数，直接放在driver结构体里，这里不是，而是调用了 platform_driver_probe ，就不贴代码了，还看段函数介绍，大致了解下什么意思。
/**
 * platform_driver_probe - register driver for non-hotpluggable device
 * @drv: platform driver structure
 * @probe: the driver probe routine, probably from an __init section
 *
 * Use this instead of platform_driver_register() when you know the device
 * is not hotpluggable and has already been registered, and you want to
 * remove its run-once probe() infrastructure from memory after the driver
 * has bound to the device.
 *
 * One typical use for this would be with drivers for controllers integrated
 * into system-on-chip processors, where the controller devices have been
 * configured as part of board setup.
 *
 * Returns zero if the driver registered and bound to a device, else returns
 * a negative error code and with the driver not registered.
 */
    1、适用于非热插拔设备
    2、通常Probe位于__init段3、当你知道device是非热拔插的，而且设备已经被注册了，而且你想在probe函数调用一次之后就销毁它节省空间，使用 platform_driver_probe 而非 platform_driver_register。
    4、一个典型的应用是，用在完整的控制器驱动，控制器设备被当作 board setup 的一部分（在板子初始化的时候，设备就已经被注册了，放在board_info里）
    5、返回0 ，如果driver注册成功且匹配到一个device ，以后再也无法被别的device probe了。
    6、否则，返回一个错误，且driver未注册。
    显然，我们写的正式一个控制器驱动程序，设备侧确实是早已注册（后边会讲）。
    疑问：有人说使用 platform_driver_probe 时 driver 只能被一个 device 匹配绑定，之后再也无法被别的device probe，难道说，我有俩spi控制器还需要写两个控制器驱动程序么？我认为这种说法是不对的，我猜大概是driver注册时，会匹配一遍device链表，把能支持的device都probe，之后再有deivce注册进来就不行了。这个有待验证。

    i2c驱动框架里，是在driver->probe 分配设置注册adapter，想必spi也是在driver->probe里分配设置注册master。

1. static int __ init atmel_spi_probe(struct platform_device *pdev)
2. {
3. struct resource *regs;
4. int irq;
5. struct clk *clk;
6. int ret;
7. struct spi_master *master;
8. struct atmel_spi *as;
10. /* 获取 device 侧提供的Io内存以及中断 */
11. regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
12. irq = platform_get_irq(pdev, 0);
14. /* 获取 spi 时钟，一会好使能它 */
15. clk = clk_get(&pdev->dev, "spi_clk");
17. /* 分配一个spi_master结构 额外加上一个 atmel_spi 用来存放其它信息 */
18. master = spi_alloc_master(&pdev->dev, sizeof *as);
20. /* 设置 master */
21. master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH; // 所支持的模式
22. master->bus_num = pdev->id; // 控制器编号，用于分辨外围spi设备是连接在哪一个控制器上
23. master->num_chipselect = 4; // 片选最大值+1,spi设备的片选值要小于它
24. master->setup = atmel_spi_setup; // 一个控制器上可能接有多个spi设备，它们的频率和模式是不一样的，用于设备之间切换时设置这些信息。
25. master->transfer = atmel_spi_transfer; // 最重要的发送函数
26. master->cleanup = atmel_spi_cleanup;
28. /* 将 Master 放入 pdev->dev->p->driver_data 里*/
29. platform_set_drvdata(pdev, master);
31. /* as 指向 master->dev->p->driver_data ,填充多出来那个 atmel_spi 结构 */
32. as = spi_master_get_devdata(master);
33. as->buffer = dma_alloc_coherent(&pdev->dev, BUFFER_SIZE,
34. &as->buffer_dma, GFP_KERNEL);
35. spin_lock_init(&as->lock);
36. INIT_LIST_HEAD(&as-> queue);
37. as->pdev = pdev;
38. as->regs = ioremap(regs->start, (regs->end - regs->start) + 1);
39. as->irq = irq;
40. as->clk = clk;
42. /* 注册中断 使能时钟 */
43. ret = request_irq(irq, atmel_spi_interrupt, 0,
44. dev_name(&pdev->dev), master);
45. clk_enable(clk);
47. /* 设置硬件寄存器 */
48. spi_writel(as, CR, SPI_BIT(SWRST));
49. spi_writel(as, CR, SPI_BIT(SWRST)); /* AT91SAM9263 Rev B workaround */
50. spi_writel(as, MR, SPI_BIT(MSTR) | SPI_BIT(MODFDIS));
51. spi_writel(as, PTCR, SPI_BIT(RXTDIS) | SPI_BIT(TXTDIS));
52. spi_writel(as, CR, SPI_BIT(SPIEN));
54. /* 注册master */
55. ret = spi_register_master(master);
57. return 0;
58. }

    对于master的设置过程注释已经说的很明白了，我们还得看看分配和注册过程。

1. struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
2. {
3. struct spi_master *master;
5. master = kzalloc(size + sizeof *master, GFP_KERNEL);
7. device_initialize(&master->dev); // 初始化设备
8. master->dev.class = &spi_master_class;
9. master->dev.parent = get_device(dev); // 在 sysfs 平台设备xxx目录下创建目录
10. spi_master_set_devdata(master, &master[ 1]);
12. return master;
13. }

    1、spi_alloc_master 实际申请的内存大小为一个struct master + struct atmel_spi,并用master->dev->p->driver_data 指向这个多出来的 struct atmel_spi 空间，用来存放 master 的中断 、寄存器等东西。

    2、初始化 master->dev ，设置它的父设备等。

1. int spi_register_master(struct spi_master *master)
2. {
3. /* 将master注册到内核中去 */
4. dev_set_name(&master->dev, "spi%u", master->bus_num);
5. status = device_add(&master->dev);
7. /* 扫描spi设备信息，创建设备 */
8. scan_boardinfo(master);
9. }

    1、设置 master->dev 的名字，例如 spi0、spi1 ...

    2、device_add 注册设备

    3、扫描spi设备信息：scan_boardinfo(master)

1. static void scan_boardinfo(struct spi_master *master)
2. {
3. struct boardinfo *bi;
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. /* 如果说 board_info 提供的bus_num 和 master—>bus_num 一致，则调用 spi_new_device */
10. for (n = bi->n_board_info; n > 0; n--, chip++) {
11. if (chip->bus_num != master->bus_num)
12. continue;
14. ( void) spi_new_device(master, chip); // 我们放到设备驱动层，在分析它
15. }
16. }
17. mutex_unlock(&board_lock);
18. }

    扫描 board_list ，取出每一个 boardinfo ，比对，如果 boardinfo 里的 bus_num 和 master 的 bus_num 相等，则认为这个spi设备在硬件物理连接上是接到这个控制器的，则使用 spi_new_device 创建 spi 设备。这个过程和i2c是多么的相似。至于在哪里填充的 board_list ，到后边设备层驱动框架时再说不迟。

  3.2 设备侧
    有 platform_driver 必然有 platform_device 与之对应，At91sam9260_devices.c 中定义

1. static struct resource spi0_resources[] = {
2. [ 0] = {
3. .start = AT91SAM9260_BASE_SPI0,
4. .end = AT91SAM9260_BASE_SPI0 + SZ_16K - 1,
5. .flags = IORESOURCE_MEM,
6. },
7. [ 1] = {
8. .start = AT91SAM9260_ID_SPI0,
9. .end = AT91SAM9260_ID_SPI0,
10. .flags = IORESOURCE_IRQ,
11. },
12. };

    资源文件，提供寄存器范围，spi中断。

1. static struct platform_device at91sam9260_spi0_device = {
2. .name = "atmel_spi", // 名字与driver一致
3. .id = 0,
4. .dev = {
5. .dma_mask = &spi_dmamask,
6. .coherent_dma_mask = DMA_BIT_MASK( 32),
7. },
8. .resource = spi0_resources, // 资源文件
9. .num_resources = ARRAY_SIZE(spi0_resources),
10. };

    与 driver 所配对的设备，显然名字是一样的。一般会有两个spi控制器，at91sam9260_spi1_device 和 at91sam9260_spi0_device 一样一样的，这里就不贴代码了。

    既然分配了 platform_device 那么肯定会在某个地方调用 platform_device_register 将它注册到 platform_bus_type , 就是在 at91_add_device_spi 。

1. void __ init at91_add_device_spi(struct spi_board_info *devices, int nr_devices)
2. {
3. ...
4. spi_register_board_info(devices, nr_devices);
6. /* Configure SPI bus(es) */
7. if (enable_spi0) {
8. ...
9. platform_device_register(&at91sam9260_spi0_device);
10. }
11. if (enable_spi1) {
12. ...
13. platform_device_register(&at91sam9260_spi1_device);
14. }
15. }

    1、添加 spi 设备信息，这应该是在设备驱动层要说的东西~就是前边的填充 Board_list 链表。

    2、将我们的 master 的设备侧 at91sam9260_spi0_device 注册到 platform_bus_type

    思考：这样做有什么好处呢？

        这样可以保证，master driver 与 device 匹配成功调用 probe 函数 scan_boardinfo 时，spi设备已经被添加到board_list中去~！如果先注册成功了 master 驱动，再添加spi设备信息就无用了。根 i2c 也是一样的。

    至此，Master 驱动的框架就分析完了，至于 master 的那些设置，我们到下篇文件写 master 驱动里细究。

4、SPI 设备驱动框架

    设备驱动层，参考韦东山老师的 SPI Flash 驱动来分析，设备驱动层，device driver 都是注册到spi_bus_type的，因此，我们现在看看 spi_bus_type->match 函数，看看它们如何匹配。

1. static int spi_match_device(struct device *dev, struct device_driver *drv)
2. {
3. const struct spi_device *spi = to_spi_device(dev);
4. const struct spi_driver *sdrv = to_spi_driver(drv);
6. if (sdrv->id_table)
7. return !!spi_match_id(sdrv->id_table, spi);
9. return strcmp(spi->modalias, drv->name) == 0;
10. }

    如果，driver里有id_table，则根据id_table进行匹配，没有就根据 spi->moadlias （设备名），和 driver->name 进行比较了。一样则配对成功。

  4.1 设备层

    设备层比较简单，先来分析它吧，目的只有一个分配 spi_board_info 设置 注册。

1. static struct spi_board_info spi_info_jz2440[] = {
2. {
3. .modalias = "100ask_spi_flash", /* 对应的spi_driver名字也是"oled" */
4. .max_speed_hz = 80000000, /* max spi clock (SCK) speed in HZ */
5. .bus_num = 1, /* jz2440里OLED接在SPI CONTROLLER 1 */
6. .mode = SPI_MODE_0,
7. .chip_select = S3C2410_GPG( 2), /* flash_cs, 它的含义由spi_master确定 */
8. }
9. };

1. static int spi_info_jz2440_init(void)
2. {
3. return spi_register_board_info(spi_info_jz2440, ARRAY_SIZE(spi_info_jz2440)); // list_add_tail(&bi->list, &board_list);
4. }

    注册 list_add_tail(&spi_info_jz2440->list, &board_list) 

    前面我们提到，master注册成功时会扫描 board_list 注册 spi 设备，现在来看看 spi 设备的注册过程,虽然没有啥重要的。

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;
7. proxy = spi_alloc_device(master);
9. proxy->chip_select = chip->chip_select;
10. proxy->max_speed_hz = chip->max_speed_hz;
11. proxy->mode = chip->mode;
12. proxy->irq = chip->irq;
13. strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
14. proxy->dev.platform_data = ( void *) chip->platform_data;
15. proxy->controller_data = chip->controller_data;
16. proxy->controller_state = NULL;
18. status = spi_add_device(proxy);
20. return proxy;
21. }
23. struct spi_device *spi_alloc_device(struct spi_master *master)
24. {
25. struct spi_device *spi;
26. struct device *dev = master->dev.parent;
28. spi = kzalloc( sizeof *spi, GFP_KERNEL);
30. spi->master = master;
31. spi->dev.parent = dev;
32. spi->dev.bus = &spi_bus_type;
33. spi->dev.release = spidev_release;
34. device_initialize(&spi->dev);
35. return spi;
36. }
38. int spi_add_device(struct spi_device *spi)
39. {
40. static DEFINE_MUTEX(spi_add_lock);
41. struct device *dev = spi->master->dev.parent;
42. int status;
44. /* 片选限制 */
45. if (spi->chip_select >= spi->master->num_chipselect) {
46. dev_err(dev, "cs%d >= max %d\n",
47. spi->chip_select,
48. spi->master->num_chipselect);
49. return -EINVAL;
50. }
52. /* Set the bus ID string */
53. dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
54. spi->chip_select);
56. status = spi_setup(spi);
57. /*
58. if (!spi->bits_per_word)
59. spi->bits_per_word = 8;
61. status = spi->master->setup(spi);
62. */
64. status = device_add(&spi->dev);
65. }

    有一点，需要留意的吧，我们在写 master 驱动时，master->num_chipselect 要大于我们将要注册进来的spi设备的 chip_select 。

  4.2 驱动侧

1. static struct spi_driver spi_flash_drv = {
2. .driver = {
3. .name = "100ask_spi_flash",
4. .owner = THIS_MODULE,
5. },
6. .probe = spi_flash_probe,
7. .remove = __devexit_p(spi_flash_remove),
8. };

    分配一个 spi_driver ，没有 id_table ，要根据名字进行匹配了，显然跟前面的设备是一样的。

1. static int spi_flash_init(void)
2. {
3. return spi_register_driver(&spi_flash_drv);
4. }

    注册到 spi_bus_type ,匹配成功好调用 probe 函数，韦东山老师是将spi flash 作为一个mtd设备来使用的，因此在probe函数中分配、设置、注册 mtd_info 

1. static int __ devinit spi_flash_probe(struct spi_device *spi)
2. {
3. int mid, did;
5. spi_flash = spi;
7. s3c2410_gpio_cfgpin(spi->chip_select, S3C2410_GPIO_OUTPUT);
8. SPIFlashInit();
9. SPIFlashReadID(&mid, &did);
10. printk( "SPI Flash ID: %02x %02x\n", mid, did);
11. memset(&spi_flash_dev, 0, sizeof(spi_flash_dev));
12. /* 构造注册一个mtd_info
13. * mtd_device_register(master, parts, nr_parts)
14. *
15. */
17. /* Setup the MTD structure */
18. spi_flash_dev.name = "100ask_spi_flash";
19. spi_flash_dev.type = MTD_NORFLASH;
20. spi_flash_dev.flags = MTD_CAP_NORFLASH;
21. spi_flash_dev.size = 0x200000; /* 2M */
22. spi_flash_dev.writesize = 1;
23. spi_flash_dev.writebufsize = 4096; /* 没有用到 */
24. spi_flash_dev.erasesize = 4096; /* 擦除的最小单位 */
26. spi_flash_dev.owner = THIS_MODULE;
27. spi_flash_dev._erase = spi_flash_erase;
28. spi_flash_dev._read = spi_flash_read;
29. spi_flash_dev._write = spi_flash_write;
31. mtd_device_register(&spi_flash_dev, NULL, 0);
33. return 0;
34. }

    在 i2c 设备驱动程序中，我们使用 i2c_read 等函数调用 adapter 里的底层收发函数进行与i2c设备通信，spi肯定也有相应的函数，例如 spi_read、spi_write ，下面我们来仔细看看，这个很重要~不然我们怎么写设备驱动呢，光写个框架不能收发那不白扯么。

1. static inline int spi_write(struct spi_device *spi, const u8 *buf, size_t len)
2. {
3. struct spi_transfer t = {
4. .tx_buf = buf,
5. .len = len,
6. };
7. struct spi_message m;
9. spi_message_init(&m);
10. spi_message_add_tail(&t, &m);
11. return spi_sync(spi, &m);
12. }

    以 spi_write 为例，看看它是如何调用到底层收发函数的。它构造了一个 spi_message 并由 spi_transfer组成，然后调用 spi_sync(spi, &m)->spi_async(spi,&m)->master->transfer(spi, &m).过程我们了解了，那么如何组织 spi_messgae ，它对应于时序图怎样的一个过程我们还不明白。

    还记得，i2c 是通过构造 i2c_msg ，然后传递多个 i2c_msg 给底层的发送函数，多个i2c_msg 组成start信号和p信号之间的发送过程，每一个i2c_msg 都有一个start信号。大概 i2c_msg 就类比于spi里的 spi_transfer ，但是通常情况下，整个 spi_messgae 传输过程我们只片选一次就够了。下面看个实例分析。

    上图是 spi flash 读取任意字节的时序图，片选选中之后，我们要先发送一个0x03 命令（1字节），再发送24bit（3字节）地址（先发送高位），然后读取len，最后取消片选。

1. void SPIFlashRead(unsigned int addr, unsigned char *buf, int len)
2. {
3. unsigned char tx_buf[ 4];
4. struct spi_transfer t[] = {
5. {
6. .tx_buf = tx_buf,
7. .len = 4,
8. },
9. {
10. .rx_buf = buf,
11. .len = len,
12. },
13. };
14. struct spi_message m;
16. tx_buf[ 0] = 0x03;
17. tx_buf[ 1] = addr >> 16;
18. tx_buf[ 2] = addr >> 8;
19. tx_buf[ 3] = addr & 0xff;
21. spi_message_init(&m);
22. spi_message_add_tail(&t[ 0], &m);
23. spi_message_add_tail(&t[ 1], &m);
24. spi_sync(spi_flash, &m);
25. }

    韦老大的程序里，构造一个 struct spi_transfer 类型的数组，两个成员，第一个有一个tx_buf（表示写），长度为4，用来发送1字节命令和3字节地址。第二个成员 有一个rx_buf（表示读），长度由参数决定，用来读取长度len字节的内容。然后分配一个struct spi_message 并使用 spi_message_init 进行初始化，然后将 spi_transfer 数组成员依次添加到 spi_message 中去，最后 spi_sync(spi_flash, &m)

    纸上谈兵一大堆，现在来看看，我们在写一个spi设备驱动的时候需要做哪些工作。
    设备侧：
      1、分配一个 spi_board_info 结构体
      2、设置 spi_board_info 里的名字、最大频率、控制器编号、模式、片选
      3、注册 spi_register_board_info 
    驱动侧：
      1、分配一个 spi_driver 结构
      2、设置名字、probe等函数
      3、注册 spi_register_driver
      4、使用spi_write等系统调用，搞明白 spi_transfer spi_message ，会使用它们进行收发
   一个 spi_message 对应于一个不可打断的spi传输过程，可以理解为片选选中直到取消选中的过程（特殊情况下，一个spi_message里面是可以取消片选再选中的），而 spi_message 由 spi_transfer 组成，根据 tx_buf  rx_buf 是否为空来判断是 写还是读 操作。

    至此，整个 spi 的框架分析完毕

5、设备驱动程序实例

1. #include <linux/init.h>
2. #include <linux/fs.h>
3. #include <linux/slab.h>
4. #include <linux/module.h>
5. #include <linux/kernel.h>
6. #include <linux/device.h>
7. #include <sound/core.h>
8. #include <linux/spi/spi.h>
9. #include <asm/uaccess.h>
10. #include <linux/timer.h>
12. #include <mach/hardware.h>
13. #include <mach/regs-gpio.h>
15. #include <linux/gpio.h>
16. #include <plat/gpio-cfg.h>
18. #include <linux/mtd/cfi.h>
19. #include <linux/mtd/mtd.h>
20. #include <linux/mtd/partitions.h>
22. /* 参考:
23. * drivers\mtd\devices\mtdram.c
24. * drivers/mtd/devices/m25p80.c
25. */
27. static struct spi_device *spi_flash;
29. /*
30. *
31. */
32. void SPIFlashReadID(int *pMID, int *pDID)
33. {
34. unsigned char tx_buf[ 4];
35. unsigned char rx_buf[ 2];
37. tx_buf[ 0] = 0x90;
38. tx_buf[ 1] = 0;
39. tx_buf[ 2] = 0;
40. tx_buf[ 3] = 0;
42. spi_write_then_read(spi_flash, tx_buf, 4, rx_buf, 2);
44. *pMID = rx_buf[ 0];
45. *pDID = rx_buf[ 1];
46. }
48. static void SPIFlashWriteEnable(int enable)
49. {
50. unsigned char val = enable ? 0x06 : 0x04;
51. spi_write(spi_flash, &val, 1);
52. }
54. static unsigned char SPIFlashReadStatusReg1(void)
55. {
56. unsigned char val;
57. unsigned char cmd = 0x05;
59. spi_write_then_read(spi_flash, &cmd, 1, &val, 1);
61. return val;
62. }
64. static unsigned char SPIFlashReadStatusReg2(void)
65. {
66. unsigned char val;
67. unsigned char cmd = 0x35;
69. spi_write_then_read(spi_flash, &cmd, 1, &val, 1);
71. return val;
72. }
74. static void SPIFlashWaitWhenBusy(void)
75. {
76. while (SPIFlashReadStatusReg1() & 1)
77. {
78. /* 休眠一段时间 */
79. /* Sector erase time : 60ms
80. * Page program time : 0.7ms
81. * Write status reg time : 10ms
82. */
83. set_current_state(TASK_INTERRUPTIBLE);
84. schedule_timeout(HZ/ 100); /* 休眠10MS后再次判断 */
85. }
86. }
88. static void SPIFlashWriteStatusReg(unsigned char reg1, unsigned char reg2)
89. {
90. unsigned char tx_buf[ 4];
92. SPIFlashWriteEnable( 1);
94. tx_buf[ 0] = 0x01;
95. tx_buf[ 1] = reg1;
96. tx_buf[ 2] = reg2;
98. spi_write(spi_flash, tx_buf, 3);
100. SPIFlashWaitWhenBusy();
101. }
103. static void SPIFlashClearProtectForStatusReg(void)
104. {
105. unsigned char reg1, reg2;
107. reg1 = SPIFlashReadStatusReg1();
108. reg2 = SPIFlashReadStatusReg2();
110. reg1 &= ~( 1<< 7);
111. reg2 &= ~( 1<< 0);
113. SPIFlashWriteStatusReg(reg1, reg2);
114. }
116. static void SPIFlashClearProtectForData(void)
117. {
118. /* cmp=0,bp2,1,0=0b000 */
119. unsigned char reg1, reg2;
121. reg1 = SPIFlashReadStatusReg1();
122. reg2 = SPIFlashReadStatusReg2();
124. reg1 &= ~( 7<< 2);
125. reg2 &= ~( 1<< 6);
127. SPIFlashWriteStatusReg(reg1, reg2);
128. }
130. /* erase 4K */
131. void SPIFlashEraseSector(unsigned int addr)
132. {
133. unsigned char tx_buf[ 4];
134. tx_buf[ 0] = 0x20;
135. tx_buf[ 1] = addr >> 16;
136. tx_buf[ 2] = addr >> 8;
137. tx_buf[ 3] = addr & 0xff;
139. SPIFlashWriteEnable( 1);
141. spi_write(spi_flash, tx_buf, 4);
143. SPIFlashWaitWhenBusy();
144. }
146. /* program */
147. void SPIFlashProgram(unsigned int addr, unsigned char *buf, int len)
148. {
149. unsigned char tx_buf[ 4];
150. struct spi_transfer t[] = {
151. {
152. .tx_buf = tx_buf,
153. .len = 4,
154. },
155. {
156. .tx_buf = buf,
157. .len = len,
158. },
159. };
160. struct spi_message m;
162. tx_buf[ 0] = 0x02;
163. tx_buf[ 1] = addr >> 16;
164. tx_buf[ 2] = addr >> 8;
165. tx_buf[ 3] = addr & 0xff;
167. SPIFlashWriteEnable( 1);
169. spi_message_init(&m);
170. spi_message_add_tail(&t[ 0], &m);
171. spi_message_add_tail(&t[ 1], &m);
172. spi_sync(spi_flash, &m);
174. SPIFlashWaitWhenBusy();
175. }
177. void SPIFlashRead(unsigned int addr, unsigned char *buf, int len)
178. {
179. /* spi_write_then_read规定了tx_cnt+rx_cnt < 32
180. * 所以对于大量数据的读取，不能使用该函数
181. */
183. unsigned char tx_buf[ 4];
184. struct spi_transfer t[] = {
185. {
186. .tx_buf = tx_buf,
187. .len = 4,
188. },
189. {
190. .rx_buf = buf,
191. .len = len,
192. },
193. };
194. struct spi_message m;
196. tx_buf[ 0] = 0x03;
197. tx_buf[ 1] = addr >> 16;
198. tx_buf[ 2] = addr >> 8;
199. tx_buf[ 3] = addr & 0xff;
201. spi_message_init(&m);
202. spi_message_add_tail(&t[ 0], &m);
203. spi_message_add_tail(&t[ 1], &m);
204. spi_sync(spi_flash, &m);
205. }
207. static void SPIFlashInit(void)
208. {
209. SPIFlashClearProtectForStatusReg();
210. SPIFlashClearProtectForData();
211. }
213. /* 构造注册一个mtd_info
214. * mtd_device_register(master, parts, nr_parts)
215. *
216. */
218. /* 首先: 构造注册spi_driver
219. * 然后: 在spi_driver的probe函数里构造注册mtd_info
220. */
222. static struct mtd_info spi_flash_dev;
224. static int spi_flash_erase(struct mtd_info *mtd, struct erase_info *instr)
225. {
226. unsigned int addr = instr->addr;
227. unsigned int len = 0;
229. /* 判断参数 */
230. if ((addr & (spi_flash_dev.erasesize - 1)) || (instr->len & (spi_flash_dev.erasesize - 1)))
231. {
232. printk( "addr/len is not aligned\n");
233. return -EINVAL;
234. }
236. for (len = 0; len < instr->len; len += 4096)
237. {
238. SPIFlashEraseSector(addr);
239. addr += 4096;
240. }
242. instr->state = MTD_ERASE_DONE;
243. mtd_erase_callback(instr);
244. return 0;
245. }
247. static int spi_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
248. size_t *retlen, u_char *buf)
249. {
250. SPIFlashRead(from, buf, len);
251. *retlen = len;
252. return 0;
253. }
255. static int spi_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
256. size_t *retlen, const u_char *buf)
257. {
258. unsigned int addr = to;
259. unsigned int wlen = 0;
261. /* 判断参数 */
262. if ((to & (spi_flash_dev.erasesize - 1)) || (len & (spi_flash_dev.erasesize - 1)))
263. {
264. printk( "addr/len is not aligned\n");
265. return -EINVAL;
266. }
268. for (wlen = 0; wlen < len; wlen += 256)
269. {
270. SPIFlashProgram(addr, ( unsigned char *)buf, 256);
271. addr += 256;
272. buf += 256;
273. }
275. *retlen = len;
276. return 0;
277. }
279. static int __ devinit spi_flash_probe(struct spi_device *spi)
280. {
281. int mid, did;
283. spi_flash = spi;
285. s3c2410_gpio_cfgpin(spi->chip_select, S3C2410_GPIO_OUTPUT);
286. SPIFlashInit();
287. SPIFlashReadID(&mid, &did);
288. printk( "SPI Flash ID: %02x %02x\n", mid, did);
289. memset(&spi_flash_dev, 0, sizeof(spi_flash_dev));
290. /* 构造注册一个mtd_info
291. * mtd_device_register(master, parts, nr_parts)
292. *
293. */
295. /* Setup the MTD structure */
296. spi_flash_dev.name = "100ask_spi_flash";
297. spi_flash_dev.type = MTD_NORFLASH;
298. spi_flash_dev.flags = MTD_CAP_NORFLASH;
299. spi_flash_dev.size = 0x200000; /* 2M */
300. spi_flash_dev.writesize = 1;
301. spi_flash_dev.writebufsize = 4096; /* 没有用到 */
302. spi_flash_dev.erasesize = 4096; /* 擦除的最小单位 */
304. spi_flash_dev.owner = THIS_MODULE;
305. spi_flash_dev._erase = spi_flash_erase;
306. spi_flash_dev._read = spi_flash_read;
307. spi_flash_dev._write = spi_flash_write;
309. mtd_device_register(&spi_flash_dev, NULL, 0);
311. return 0;
312. }
314. static int __ devexit spi_flash_remove(struct spi_device *spi)
315. {
316. mtd_device_unregister(&spi_flash_dev);
317. return 0;
318. }
320. static struct spi_driver spi_flash_drv = {
321. .driver = {
322. .name = "100ask_spi_flash",
323. .owner = THIS_MODULE,
324. },
325. .probe = spi_flash_probe,
326. .remove = __devexit_p(spi_flash_remove),
327. };
329. static int spi_flash_init(void)
330. {
331. return spi_register_driver(&spi_flash_drv);
332. }
334. static void spi_flash_exit(void)
335. {
336. spi_unregister_driver(&spi_flash_drv);
337. }
339. module_init(spi_flash_init);
340. module_exit(spi_flash_exit);
341. MODULE_DESCRIPTION( "Flash SPI Driver");
342. MODULE_AUTHOR( "weidongshan@qq.com,www.100ask.net");
343. MODULE_LICENSE( "GPL");
346. <strong style= "color: rgb(255, 0, 0);">
347. </strong>