Chinaunix首页 | 论坛 | 博客

oops

首页　| 　博文目录　| 　关于我

王贤才

  • 博客访问： 1177251
  • 博文数量： 573
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 66
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-28 16:21
文章分类

全部博文（573）

文章存档

2018年（3）

2016年（48）

2015年（522）

我的朋友
最近访客
推荐博文
相关博文
linux下 SPI驱动

分类： LINUX

2015-12-04 17:15:35

驱动代码
makefile文件

点击(此处)折叠或打开

  1. # File: Makefile
  2. # wangxiancai

  4. MODEXT = ko
  5. # INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.13/wxc/driver/chardriver/ko
  6. INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.30/wxc/driver/chardriver/ko
  7. # CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-
  8. CROSS=/home/wangxc/linux/toolchain/crosstools_4.4.3_softfloat/bin/arm-linux-
  9. # KERNELDIR=/home/wangxc/linux/kernel/kernel-2.6.13
  10. KERNELDIR=/home/wangxc/linux/kernel/kerner-2.6.30

  12. CC= $(CROSS)gcc
  13. LD= $(CROSS)ld

  15. #############################################################################
  16. # Compiler Flags
  17. #############################################################################
  18. EXTRA_CFLAGS += -I$(KERNELDIR)/include
  19. #############################################################################
  20. # Make Targets
  21. #############################################################################
  22. obj-m := spi_tq2440_info.o
  23. obj-m += oled_drv.o
  24. obj-m += flash_drv.o
  25. obj-m += spi_master.o
  26. default:
  27.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
  28. # Otherwise we were called directly from the command line; invoke the kernel build system.

  30. install: default
  31.     rm -rf $(INSTALLDIR)/spi_tq2440_info.$(MODEXT)
  32.     cp -rf $(PWD)/spi_tq2440_info.$(MODEXT) $(INSTALLDIR)
  33.     rm -rf $(INSTALLDIR)/oled_drv.$(MODEXT)
  34.     cp -rf $(PWD)/oled_drv.$(MODEXT) $(INSTALLDIR)
  35.     rm -rf $(INSTALLDIR)/flash_drv.$(MODEXT)
  36.     cp -rf $(PWD)/flash_drv.$(MODEXT) $(INSTALLDIR)
  37.     rm -rf $(INSTALLDIR)/spi_master.$(MODEXT)
  38.     cp -rf $(PWD)/spi_master.$(MODEXT) $(INSTALLDIR)

  40. clean:
  41.     rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions *.bak modules.order Module.symvers
spi_tq2440_info.c文件

点击(此处)折叠或打开

  1. /*不知道怎么入手的时候，就参考别人的代码，从内核中寻找
  2. *模仿这个程序 : arch/blackfin/mach-bf527/boards/cm-bf527.c
  3. */

  5. /*
  6. TQ2440有2个SPI控制器:
  7. SPICLK0 : GPE13
  8. SPIMOSI0 : GPE12
  9. SPIMISO0 : GPE11

  11. SPICLK1 : GPG13
  12. SPIMOSI1 : GPG12
  13. SPIMISO1 : GPG11
  14. */
  15. #include <linux/module.h>
  16. #include <linux/device.h>
  17. #include <linux/platform_device.h>
  18. #include <linux/spi/spi.h>
  19. #include <linux/irq.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/jiffies.h>
  22. #include <linux/delay.h>
  23. #include <linux/io.h>

  25. #include <mach/regs-gpio.h>

  27. /*
  28. *单板相关的信息 : 需要定义一个 spi_board_info 结构体
  29. *比如 : 片选引脚，波特率，模式A/B,其他平台相关的数据
  30. *如果只有1个设备，则这个数组只有1项，有2个设备，则这个数组有2项
  31. */
  32. static struct spi_board_info spi_info_TQ2440[] = {
  33.         {
  34.               .modalias = "myoled", /* 对应的spi_driver名字也是"oled", 一旦名字匹配就会调用probe函数*/
  35.               .max_speed_hz = 10000000,    /* max spi clock (SCK) speed in HZ : 10MHZ 是10进制数*/
  36.               .bus_num = 0, /* TQ2440里OLED接在SPI CONTROLLER 0 */
  37.               .mode = SPI_MODE_0, /* SPI传输格式A:SPI_MODE_0 格式B:SPI_MODE_1 格式C:SPI_MODE_2 格式D:SPI_MODE_3*/
  38.               .chip_select = S3C2410_GPG1, //S3C2410_GPG(1), /*OLED片选引脚 oled_cs : GPG1, 它的含义由spi_master确定 */
  39.               /*在 spi_board_info 结构里面随便找个参数来 存储 OLED命令|数据引脚的信息*/
  40.               .platform_data = (const void *)S3C2410_GPF3, //(const void)S3C2410_GPF(3), /*OLED命令|数据引脚 oled_dc : GPF3, 它在spi_driver里使用 */     
  41.          },
  42.          {
  43.               .modalias = "myspi_flash", /* 对应的spi_driver名字也是"spi_flash" */
  44.               .max_speed_hz = 80000000,    /* max spi clock (SCK) speed in HZ : 80MHz 是10进制数*/
  45.               .bus_num = 0, /* TQ2440里 flash 接在SPI CONTROLLER 0 */
  46.               .mode = SPI_MODE_0, /* SPI传输格式A */
  47.               .chip_select = S3C2410_GPG10, //S3C2410_GPG(10), /*FLASH片选引脚 flash_cs : GPG10, 它的含义由spi_master确定 */
  48.          }
  49. };

  51. static int __init spi_info_TQ2440_init(void)
  52. {
  53. /*
  54. *功能 : 注册 spi_board_info 结构体 //单板相关的信息
  55. *注意 : 3.4.2内核，在 spi_board_info注册之后，如果内核里面有 匹配的spi_master(通过bus_num来匹配),
  56. * 就会自动构造一个 spi_device 结构体。
  57. * 再通过名字modalias 找到同名的对应的 spi_driver 比如spi_oled_drver， spi_flash_driver。
  58. * 或者 spi_oled_drver注册的时候，查找同名的对应的spi_board_info，找到之后，就调用 spi_oled_probe函数。
  59. *但是 : 在2.6.30内核，spi_board_info注册之后，只是把 spi_board_info结构注册到 board_info 链表。
  60. * 在 注册 spi_master 的时候，才通过bus_num来匹配，自动构造一个 spi_device 结构体。
  61. * 所以 : spi_board_info必须先注册，再注册 spi_master。
  62. */
  63.         printk("DEVICE:1_spi_info_TQ2440_init ####################\n");
  64.         spi_register_board_info(spi_info_TQ2440, ARRAY_SIZE(spi_info_TQ2440));
  65.         printk("DEVICE:2_spi_info_TQ2440_init ####################\n");

  67.         return 0;
  68. }

  70. static void __exit spi_info_TQ2440_exit(void)
  71. {
  72.         /*没有对应的unregister函数,这个出口函数可以不要*/
  73.         return;
  74. }

  76. module_init(spi_info_TQ2440_init);
  77. module_exit(spi_info_TQ2440_exit);
  78. MODULE_AUTHOR("WangXiancai");
  79. MODULE_LICENSE("GPL");


  82. /*
  83. struct spi_device {
  84.     struct device        dev;
  85.     struct spi_master    *master;
  86.     u32            max_speed_hz;
  87.     u8            chip_select;
  88.     u8            mode;
  89. #define    SPI_CPHA    0x01            // clock phase
  90. #define    SPI_CPOL    0x02            // clock polarity
  91. #define    SPI_MODE_0    (0|0)            // (original MicroWire)
  92. #define    SPI_MODE_1    (0|SPI_CPHA)
  93. #define    SPI_MODE_2    (SPI_CPOL|0)
  94. #define    SPI_MODE_3    (SPI_CPOL|SPI_CPHA)
  95. #define    SPI_CS_HIGH    0x04            // chipselect active high?
  96. #define    SPI_LSB_FIRST    0x08            // per-word bits-on-wire
  97. #define    SPI_3WIRE    0x10            // SI/SO signals shared
  98. #define    SPI_LOOP    0x20            // loopback mode
  99.     u8            bits_per_word;
  100.     int            irq;
  101.     void            *controller_state;
  102.     void            *controller_data;
  103.     char            modalias[32];

  105.     //
  106.     // likely need more hooks for more protocol options affecting how
  107.     // the controller talks to each chip, like:
  108.     // - memory packing (12 bit samples into low bits, others zeroed)
  109.     // - priority
  110.     // - drop chipselect after each word
  111.     // - chipselect delays
  112.     // - ...
  113.     //
  114. };

  116. */


  119. /*
  120. 编译这个文件会有警告:
  121. WARNING: "spi_register_board_info" [/home/wangxc/linux/rootfs/nfs_2.6.30/wxc/driver/chardriver/spi/spi_info.ko] undefined!
  122. 因为 内核中 spi_register_board_info 函数没有被 EXPORT_SYMBOL_GPL修饰，即没有导出给模块使用。
  123. 所以本文件只能编译进内核了，无法作为模块使用了。


  126. cp spi_tq2440_info.c /work/system/linux-3.4.2/drivers/spi/
  127. 修改drivers/spi/Makefile,添加这行：
  128. obj-$(CONFIG_SPI_S3C24XX) += spi_tq2440_info.o

  130. 本程序没有使用上面的方法，修改了内核:
  131. 在文件\kerner-2.6.30\drivers\spi\spi.c 339行增加下面一行:
  132. EXPORT_SYMBOL_GPL(spi_new_device);
  133. */
oled_drv.c文件

点击(此处)折叠或打开

  1. /*模仿这个程序 : drivers/input/touchsreen/ad7877.c
  2. */

  4. /*
  5. *本程序功能 : 编写 spi_device 对应的 spi_driver
  6. */
  7. #include <linux/module.h>
  8. #include <linux/device.h>
  9. #include <linux/init.h>
  10. #include <linux/delay.h>
  11. #include <linux/input.h>
  12. #include <linux/interrupt.h>
  13. #include <linux/slab.h>
  14. #include <linux/spi/spi.h>
  15. //#include <linux/spi/ad7877.h>
  16. #include <asm/irq.h>
  17. #include <asm/io.h>

  19. #include <asm/uaccess.h> /*这个头文件中包括 copy_from_user*/

  21. #include <mach/hardware.h>
  22. #include <mach/regs-gpio.h>

  24. static int major;
  25. static struct class *class;

  27. static int spi_oled_dc_pin;            /*oled命令|数据引脚*/
  28. static int spi_oled_chip_pin;        /*oled片选引脚*/
  29. static struct spi_device * spi_oled_dev; /*spi_write函数用*/
  30. static unsigned char * kernel_buf; /*定义一个缓冲区 spi_write函数用*/

  32. /*
  33. *函数功能 : 设置 OLED的命令|数据引脚 0 : 命令引脚 1 : 数据引脚
  34. */
  35. void oled_set_dc(unsigned char val)
  36. {
  37.         s3c2410_gpio_setpin(spi_oled_dc_pin, val);
  38. }

  40. /*
  41. *函数功能 : 设置 OLED片选引脚 0:选中 1:不选中
  42. *注意 : 片选引脚其实不需要我们来管，控制器会帮我们来做片选。
  43. */
  44. void oled_set_cs(unsigned char val)
  45. {
  46.         s3c2410_gpio_setpin(spi_oled_chip_pin, val);
  47. }

  49. /*
  50. *函数功能 : 通过SPI引脚，把命令cmd发送到OLED硬件上面去
  51. */
  52. void oled_write_cmd(unsigned char cmd)
  53. {
  54.         oled_set_dc(0); //设置 OLED的命令|数据引脚，0 : 命令引脚
  55.         oled_set_cs(0); //设置 OLED片选引脚 0:选中 //这里片选可以不做了

  57.         //spi_send_byte(cmd); //通过SPI引脚发送数据
  58.         spi_write(spi_oled_dev, &cmd, 1);

  60.         oled_set_cs(1); //设置 OLED片选引脚 1:不选中
  61.         oled_set_dc(1); //操作完成之后，恢复为 1 : 数据引脚
  62. }

  64. /*
  65. *函数功能 : 通过SPI引脚，把数据data发送到OLED硬件上面去
  66. */
  67. void oled_write_data(unsigned char data)
  68. {
  69.         oled_set_dc(1); //设置 OLED的命令|数据引脚，1 : 数据引脚
  70.         oled_set_cs(0); //设置 OLED片选引脚 0:选中

  72.         //spi_send_byte(data); //通过SPI引脚发送数据
  73.         spi_write(spi_oled_dev, &data, 1);

  75.         oled_set_cs(1); //设置 OLED片选引脚 1:不选中
  76.         oled_set_dc(1); //操作完成之后，继续为 1 : 数据引脚
  77. }

  79. /*
  80. *函数功能 : 设置oled处于页地址模式
  81. *在数据手册的第30页
  82. */
  83. void oled_set_page_addr_mode(void)
  84. {
  85.         oled_write_cmd(0x20);
  86.         oled_write_cmd(0x02);
  87. }

  89. /*
  90. *函数功能 : 找到oled显示屏,设置列地址+页地址。
  91. *函数参数 :
  92. * col : 0到127 列位置
  93. * page : 0到7 页位置
  94. *注意看数据手册 : 第30页+31页,在页模式下，设置页的起始地址
  95. */
  96. void oled_set_addr(unsigned int page, unsigned int col)
  97. {
  98.         oled_write_cmd(0xB0 + page);                //设置页地址

  100.         oled_write_cmd(col & 0xf);                    //先设置低4位列地址
  101.     oled_write_cmd(0x10 + (col >> 4));    //再设置高4位列地址
  102. }

  104. /*
  105. *函数功能 : oled全部点亮
  106. *注意 : 把8页全部写入1即可
  107. */
  108. void oled_all_light(void)
  109. {
  110.         int page, i;
  111.         for (page = 0; page < 8; page ++)
  112.         {
  113.                 oled_set_addr(page, 0);
  114.                 for (i = 0; i < 128; i++)
  115.                 {
  116.                         oled_write_data(1);
  117.                 }
  118.         }
  119. }

  121. /*
  122. *函数功能 : oled清屏
  123. *注意 : 把8页全部写入0即可
  124. */
  125. void oled_clear(void)
  126. {
  127.         int page;
  128.         int i;
  129.         for(page=0; page<8; page++)
  130.         {
  131.                 oled_set_addr(page, 0); //选中第page页，第0列
  132.                 for(i=0; i<128; i++) //128列
  133.                 {
  134.                         oled_write_data(0);
  135.                 }
  136.         }
  137. }

  139. /*
  140. *函数功能 : oled清1页
  141. *注意 : 把这页全部写入0即可
  142. */
  143. void oled_clear_page(int page)
  144. {
  145.         int i;

  147.         oled_set_addr(page, 0); //选中第page页，第0列
  148.         for(i=0; i<128; i++) //128列
  149.         {
  150.                 oled_write_data(0);
  151.         }
  152. }

  154. /*
  155. *函数功能 : OLED芯片的初始化
  156. *在数据手册的第29页，有初始化方法
  157. */
  158. void oled_init(void)
  159. {
  160.         /* 向OLED发命令以初始化 */
  161.     oled_write_cmd(0xAE); //display off
  162.     oled_write_cmd(0x00); //set lower column address
  163.     oled_write_cmd(0x10); //set higher column address
  164.     oled_write_cmd(0x40); //set display start line
  165.     oled_write_cmd(0xB0); //set page address
  166.     oled_write_cmd(0x81); //contract control
  167.     oled_write_cmd(0x66); //128
  168.     oled_write_cmd(0xA1); //set segment remap
  169.     oled_write_cmd(0xA6); //normal / reverse
  170.     oled_write_cmd(0xA8); //multiplex ratio
  171.     oled_write_cmd(0x3F); //duty = 1/64
  172.     oled_write_cmd(0xC8); //Com scan direction
  173.     oled_write_cmd(0xD3); //set display offset
  174.     oled_write_cmd(0x00);
  175.     oled_write_cmd(0xD5); //set osc division
  176.     oled_write_cmd(0x80);
  177.     oled_write_cmd(0xD9); //set pre-charge period
  178.     oled_write_cmd(0x1f);
  179.     oled_write_cmd(0xDA); //set COM pins
  180.     oled_write_cmd(0x12);
  181.     oled_write_cmd(0xdb); //set vcomh
  182.     oled_write_cmd(0x30);
  183.     oled_write_cmd(0x8d); //set charge pump enable
  184.     oled_write_cmd(0x14);

  186.     oled_set_page_addr_mode(); //设置oled处于页地址模式，默认也是处于页地址模式
  187.     oled_clear(); //oled清屏

  189.     oled_write_cmd(0xAF); //display ON
  190. }


  193. /*下面是ioctl识别的宏定义*/
  194. #define OLED_CMD_INIT 0x100001 /*初始化*/
  195. #define OLED_CMD_CLEAR_ALL 0x100002 /*清屏幕*/
  196. #define OLED_CMD_CLEAR_PAGE 0x100003 /*清除某1页*/
  197. #define OLED_CMD_SET_POS 0x100004 /*设置位置*/

  199. //static long oled_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  200. /*为什么视频中可以用上面这个函数？？？
  201. 应用程序 系统调用的 调试 视频要看
  202. */
  203. static int oled_ioctl(struct inode * pinode, struct file * pfile, unsigned int cmd, unsigned long arg)
  204. {
  205.         int page;
  206.         int col;

  208.         switch(cmd)
  209.         {
  210.                 case OLED_CMD_INIT :
  211.                 {
  212.                         oled_init(); /*oled芯片硬件初始化*/
  213.                         printk("[%s][%s][%d] oled_init end\n", __FILE__, __FUNCTION__, __LINE__);
  214.                         break;
  215.                 }
  216.                 case OLED_CMD_CLEAR_ALL :
  217.                 {
  218.                         oled_clear(); /*oled清屏*/
  219.                         break;
  220.                 }
  221.                 case OLED_CMD_CLEAR_PAGE :
  222.                 {
  223.                         page = arg;
  224.                         oled_clear_page(page); /*oled清1页屏*/
  225.                         break;
  226.                 }
  227.                 case OLED_CMD_SET_POS :
  228.                 {
  229.                         /*约定arg 中0到7位是表示page; 8到15位是表示col*/
  230.                         page = arg & 0xff;
  231.                         col = (arg>>8) & 0xff;
  232.                         oled_set_addr(page, col);
  233.                         break;
  234.                 }
  235.                 default:
  236.                 {
  237.                         break;
  238.                 }
  239.         }

  241.         return 0;
  242. }

  244. static ssize_t oled_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
  245. {
  246.         int ret;
  247.         
  248.         if(count > 4096)
  249.         {
  250.                 return -EINVAL;
  251.         }

  253.         ret = copy_from_user(kernel_buf, buf, count); /*用户空间 拷贝到 内核空间*/
  254.         spi_write(spi_oled_dev, kernel_buf, count);

  256.         return 0;
  257. }

  259. static struct file_operations oled_ops = {
  260.         .owner = THIS_MODULE,
  261.         //.unlocked_ioctl = oled_ioctl, //3.4.2内核，为什么可以用这个??
  262.         .ioctl = oled_ioctl,
  263.         .write = oled_write,
  264. };


  267. static int __devinit spi_oled_probe(struct spi_device *spi)
  268. {
  269.         printk("DEVICE:spi_oled_probe ####################\n");
  270.         /*获取2个引脚*/
  271.         spi_oled_dc_pin = (int)spi->dev.platform_data;
  272.         spi_oled_chip_pin = (int)spi->chip_select;

  274.         s3c2410_gpio_cfgpin(spi_oled_dc_pin, S3C2410_GPIO_OUTPUT); /*把oled 命令|数据引脚配置成 输出引脚*/ //#define S3C2410_GPIO_OUTPUT (0xFFFFFFF1)
  275.     s3c2410_gpio_cfgpin(spi_oled_chip_pin, S3C2410_GPIO_OUTPUT); /*把oled 片选引脚配置成 输出引脚*/
  276.         
  277.         /*上面2行，等同于下面2行
  278.         s3c2410_gpio_cfgpin(spi_oled_chip_pin, S3C2410_GPG1_OUTP);    //#define S3C2410_GPG1_OUTP (0x01 << 2)
  279.         s3c2410_gpio_cfgpin(spi_oled_dc_pin, S3C2410_GPF3_OUTP);        //#define S3C2410_GPF3_OUTP (0x01 << 6)
  280.         上面函数执行，相对于设置了GPIO的控制寄存器+GPIO的数据寄存器                                                                                                                        
  281.         */
  282.         spi_oled_dev = spi; /*把 spi_device 保存下来*/
  283.         kernel_buf = kmalloc(4096, GFP_KERNEL); /*分配一个缓冲区*/

  285.         /*注册 file_operations*/
  286.         major = register_chrdev(0, "oled", &oled_ops);

  288.         /*文件系统里面的mdev自动创建设备节点*/
  289.         class = class_create(THIS_MODULE, "oled");
  290.         /* 为了让mdev根据这些信息来创建设备节点 */
  291.         device_create(class, NULL, MKDEV(major, 0), NULL, "oled"); /* /dev/oled */

  293.         return 0;
  294. }

  296. static int __devexit spi_oled_remove(struct spi_device *spi)
  297. {
  298.         device_destroy(class, MKDEV(major, 0));
  299.         class_destroy(class);
  300.         unregister_chrdev(major, "oled");
  301.         
  302.         kfree(kernel_buf);

  304.         return 0;
  305. }

  307. /*
  308. *spi_driver结构体 : 具体的spi接口设备的驱动代码
  309. */
  310. static struct spi_driver spi_oled_driver = {
  311.     .driver = {
  312.         .name    = "myoled", /*这个名字必须和 spi_board_info中的modalias成员相同*/
  313.         .owner    = THIS_MODULE,
  314.     },
  315.     .probe        = spi_oled_probe,
  316.     .remove        = __devexit_p(spi_oled_remove),
  317. };


  320. static int __init spi_oled_init(void)
  321. {
  322. /*
  323. *函数功能 : 注册spi驱动
  324. */
  325.         spi_register_driver(&spi_oled_driver);
  326.         return 0;
  327. }

  329. static void __exit spi_oled_exit(void)
  330. {
  331. /*
  332. *函数功能 : 注销spi驱动
  333. */
  334.         spi_unregister_driver(&spi_oled_driver);
  335. }

  337. module_init(spi_oled_init);
  338. module_exit(spi_oled_exit);
  339. MODULE_AUTHOR("WangXiancai");
  340. MODULE_LICENSE("GPL");
flash_drv.c文件

点击(此处)折叠或打开

  1. /* 参考:
  2.  * drivers\mtd\devices\mtdram.c
  3.  * drivers/mtd/devices/m25p80.c
  4.  */
  5. #include <linux/module.h>
  6. #include <linux/device.h>
  7. #include <linux/spi/spi.h>
  8. #include <asm/uaccess.h> /*这个头文件中包括 copy_from_user*/
  9. #include <mach/hardware.h>
  10. #include <mach/regs-gpio.h>

  12. #include <linux/types.h>
  13. #include <linux/kernel.h>
  14. #include <linux/string.h>
  15. #include <linux/ioport.h>
  16. #include <linux/platform_device.h>
  17. #include <linux/delay.h>
  18. #include <linux/err.h>
  19. #include <linux/slab.h>
  20. #include <linux/clk.h>
  21. #include <linux/cpufreq.h>
  22. #include <asm/io.h>

  24. #include <sound/core.h>
  25. #include <linux/spi/spi.h>
  26. #include <linux/timer.h>

  28. #include <linux/slab.h>
  29. #include <linux/ioport.h>
  30. #include <linux/vmalloc.h>
  31. #include <linux/init.h>

  33. #include <linux/mtd/compatmac.h>
  34. #include <linux/mtd/mtd.h>
  35. #include <linux/mtd/mtdram.h>
  36. #include <linux/mtd/partitions.h>

  38. /* 本程序基本流程:
  39.  * 首先: 构造注册spi_driver
  40.  * 然后: 在spi_driver的probe函数里构造注册mtd_info
  41.  */

  43. static int spi_flash_chip_pin;        /*flash片选引脚*/
  44. static struct spi_device * spi_flash_dev; /*spi_write函数会用到它*/

  46. /*定义一个mtd信息 的结构体
  47. 块设备，都需要定义这个结构体，nandflash,norflash驱动里面也定义了这样一个结构体，但是用法不一样。*/
  48. static struct mtd_info my_mtd_info; /*定义成实例，就不需要再分配内存了*/


  51. /*
  52. *函数功能 : 选中flash的地址
  53. *注意 : 我们使用的W25Q16DV芯片，flash内存是16Mbit=2M字节，共需要21根地址线来寻址
  54. * 这里使用 3个字节的地址来表示flash芯片的地址，先发送3个字节地址的最高位，最后发送最低位
  55. */
  56. void flash_select_addr(unsigned int addr)
  57. {
  58.         unsigned char tx_buf[3];    /*要发送的数据*/
  59.         tx_buf[0] = addr >> 16;
  60.         tx_buf[1] = addr >> 8;
  61.         tx_buf[2] = addr & 0xff;
  62.         /*
  63.         spi_send_byte(addr >> 16); //这个函数会截取参数的低8位
  64.         spi_send_byte(addr >> 8);
  65.         spi_send_byte(addr & 0xff);
  66.         */
  67.         spi_write(spi_flash_dev, tx_buf, 3); /*发送3个字节 整个发送过程中，这里都只有1次片选*/
  68. }

  70. /*
  71. *函数功能 : 设置 flash片选引脚 0:选中 1:不选中
  72. **注意 : 片选引脚其实不需要我们来管，控制器会帮我们来做片选。
  73. */
  74. void flash_set_cs(unsigned char val)
  75. {
  76.         s3c2410_gpio_setpin(spi_flash_chip_pin, val);
  77. /*
  78.         if(val == 1) //让 OLED的命令|数据引脚 输出高电平
  79.         {
  80.                 GPGDAT |= (1<<10); //GPG10输出高电平
  81.         }
  82.         else if(val == 0) //让 OLED的命令|数据引脚 输出低电平
  83.         {
  84.                 GPGDAT &= (~(1<<10)); //GPG10输出低电平
  85.         }
  86. */
  87. }

  89. /*
  90. *函数功能 : 读取flash芯片的厂家ID(0xef)，设备ID(0x14)
  91. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 52页
  92. */
  93. void flash_read_id(unsigned char * mid, unsigned char * did)
  94. {
  95.         unsigned char tx_buf[4]; /*要发送的数据*/
  96.         unsigned char rx_buf[2];    /*收到的数据*/
  97.         tx_buf[0] = 0x90;
  98.         tx_buf[1] = 0;
  99.         tx_buf[2] = 0;
  100.         tx_buf[3] = 0;
  101.     
  102.         //flash_set_cs(0); //选中spi flash //可以不要片选了
  103.         
  104.         //spi_send_byte(0x90); //发出90命令
  105.         //flash_select_addr(0); //选中flash的0地址
  106.         //spi_write(spi_flash_dev, tx_buf, 4); /*之所以把上面2句合并:因为读取过程中，只能有1次片选*/

  108.         //m_id = spi_recv_byte(); //第1次读取厂家ID
  109.         //d_id = spi_recv_byte(); //第2次读取设备ID
  110.         
  111.         /*函数功能 : 先写:发送指定的字节数，再读:接受指定的字节数
  112.         *之所以把上面2句合并:因为写入+读取过程中，只能有1次片选,spi_master会做片选的事
  113.         */
  114.         spi_write_then_read(spi_flash_dev, tx_buf, 4, rx_buf, 2);
  115.         
  116.         //*mid = m_id;
  117.         //*did = d_id;
  118.         *mid = rx_buf[0];
  119.         *did = rx_buf[1];

  121.         //uart_printf("MID=[0x%x]\n", m_id); //0xEF
  122.         //uart_printf("DID=[0x%x]\n", d_id); //0x14

  124.         //flash_set_cs(1);
  125. }

  127. /*
  128. *函数功能 : flash芯片写入使能
  129. *函数参数 : enable 1 : 写使能 0 : 写禁止
  130. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 23 24页
  131. */
  132. void flash_write_enable(unsigned int enable)
  133. {
  134.         unsigned char tx_val;    /*要发送的数据*/        
  135.         tx_val = enable ? 0x06 : 0x04;
  136.         spi_write(spi_flash_dev, &tx_val, 1);
  137. /*
  138.         if(enable == 1) //写使能
  139.         {
  140.                 //flash_set_cs(0); //选中spi flash
  141.                 //spi_send_byte(0x06); //发出06命令
  142.                 spi_write(spi_flash_dev, &tx_val, 1);
  143.                 //flash_set_cs(1);
  144.         }
  145.         else if(enable == 0) //写禁止
  146.         {
  147.                 //flash_set_cs(0); //选中spi flash
  148.                 //spi_send_byte(0x04); //发出04命令
  149.                 spi_write(spi_flash_dev, &tx_val, 1);
  150.                 //flash_set_cs(1);
  151.         }
  152. */
  153. }

  155. /*
  156. *函数功能 : 读取flash芯片的状态寄存器1
  157. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 25页
  158. */
  159. unsigned char flash_read_status_reg1(void)
  160. {
  161.         unsigned char tx_val = 0x05;
  162.         unsigned char rx_val;
  163.     
  164.         //flash_set_cs(0); //选中spi flash
  165.         
  166.         //spi_send_byte(0x05); //发出05命令
  167.         //val = spi_recv_byte();
  168.         //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  169.         spi_write_then_read(spi_flash_dev, &tx_val, 1, &rx_val, 1);
  170.         //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);

  172.         //flash_set_cs(1);
  173.         
  174.         return rx_val;
  175. }

  177. /*
  178. *函数功能 : 读取flash芯片的状态寄存器2
  179. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 25页
  180. */
  181. unsigned char flash_read_status_reg2(void)
  182. {
  183.         unsigned char tx_val = 0x35;
  184.         unsigned char rx_val;
  185.     
  186.         //flash_set_cs(0); //选中spi flash
  187.         //spi_send_byte(0x35); //发出35命令
  188.         //val = spi_recv_byte();
  189.         spi_write_then_read(spi_flash_dev, &tx_val, 1, &rx_val, 1);

  191.         //flash_set_cs(1);
  192.         
  193.         return rx_val;        
  194. }

  196. /*
  197. *函数功能 : flash擦除+写入时，需要一定处理时间，这里判断是否操作完成
  198. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 16页
  199. *注意 : 判断状态寄存器1的bit0:busy(0:内部操作完成,空闲 1:内部操作正在进行,忙)
  200. */
  201. void flash_wait_for_busy(void)
  202. {
  203.         unsigned char reg1_val;
  204.         
  205.         while(1) /*死循环，对cpu资源的浪费很大 : 应该采用休眠,因为休眠时，交出cpu的控制权*/
  206.         {
  207.                 reg1_val = flash_read_status_reg1(); //保存状态寄存器1中的值,注意:这一句一定要放在循环里面，刚开始没有放在循环里面，排错排了很久
  208.                 
  209.                 //uart_printf("****** reg1_val=[0x%x]*******\n", reg1_val);
  210.                 
  211.                 if((reg1_val & 0x1) == 0) //等待bit0=0:内部操作完成
  212.                 {
  213.                         break;
  214.                 }
  215.         /*函数功能 : 设置当前进程的状态
  216.         *TASK_INTERRUPTIBLE : 中断
  217.         */
  218.                 set_current_state(TASK_INTERRUPTIBLE);
  219.                 
  220.                 /* 休眠一段时间 */
  221.         /* 扇区擦除耗时时间 Sector erase time : 60ms
  222.          * 页写耗时时间 Page program time : 0.7ms
  223.          * 读状态寄存器耗时时间 Write status reg time : 10ms
  224.          */
  225.         schedule_timeout(HZ/100); /* HZ时长是1秒，休眠10MS后再次判断 */
  226.         }
  227.         //while((reg1_val & 0x1) == 1); //等待bit0=0,是1则一直循环
  228. }

  230. /*
  231. *函数功能 : 写flash芯片的状态寄存器
  232. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 25+26页
  233. *注意 : 写状态寄存器之前，也要 先让flash芯片写使能 + 去除状态寄存器的保护 15页
  234. * 工厂出厂默认状态是 : 写使能之后，SRP1=0，SRP0=0， 就可以写状态寄存器了。我们这里还是重新设置一下
  235. * 写flash芯片的状态寄存器耗时大概是 10ms W25Q16DV-具有SPI接口的flash芯片 67页
  236. */
  237. void flash_write_status_reg(unsigned char reg1_val, unsigned char reg2_val)
  238. {
  239.         unsigned char tx_buf[3];    /*要发送的数据*/
  240.         tx_buf[0] = 0x01;
  241.         tx_buf[1] = reg1_val;
  242.         tx_buf[2] = reg2_val;
  243.     
  244.         flash_write_enable(1); //flash芯片写使能
  245.     
  246.         //flash_set_cs(0); //选中spi flash
  247.         //spi_send_byte(0x01); //发出01命令
  248.         //spi_send_byte(reg1_val); //写寄存器1
  249.         //spi_send_byte(reg2_val); //写寄存器2
  250.         spi_write(spi_flash_dev, tx_buf, 3);

  252.         //flash_set_cs(1);

  254.         flash_wait_for_busy(); //等待写数据完成
  255. }

  257. /*
  258. *函数功能 : 去除状态寄存器的写保护，去保护之后，才可以写状态寄存器
  259. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 15 16页
  260. *工厂出厂默认状态是 : 写使能之后，SRP1=0，SRP0=0， 就可以写状态寄存器了。我们这里还是重新设置一下
  261. */
  262. void flash_clean_protect_for_status_reg(void)
  263. {
  264.         unsigned char reg1_val = 0;
  265.         unsigned char reg2_val = 0;

  267.         reg1_val = flash_read_status_reg1(); //保存状态寄存器1中的值
  268.         reg2_val = flash_read_status_reg2(); //保存状态寄存器2中的值
  269.         
  270.         //状态寄存器1 的bit7:SRP0 要清0
  271.         reg1_val &= (~(1<<7));
  272.     
  273.         //状态寄存器2 的bit0:SRP1 要清0
  274.         reg2_val &= (~(1<<0));

  276.         flash_write_status_reg(reg1_val, reg2_val);
  277. }

  279. /*
  280. *函数功能 : 去除整个存储区间的写保护，去保护之后，才可以写flash存储空间
  281. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 16+17页
  282. *CMP=0, BP2=0, BP1=0, BP0=0
  283. */
  284. void flash_clean_protect_for_memory(void)
  285. {
  286.         unsigned char reg1_val = 0;
  287.         unsigned char reg2_val = 0;
  288.         
  289.         reg1_val = flash_read_status_reg1(); //保存状态寄存器1中的值
  290.         reg2_val = flash_read_status_reg2(); //保存状态寄存器2中的值
  291.         
  292.         //状态寄存器1 的bit4:BP2 bit3:BP1, bit2:BP0 要清0
  293.         reg1_val &= (~(1<<4));
  294.         reg1_val &= (~(1<<3));
  295.         reg1_val &= (~(1<<2));

  297.         //状态寄存器2 的bit6:CMP 要清0
  298.         reg2_val &= (~(1<<6));

  300.         flash_write_status_reg(reg1_val, reg2_val);
  301. }

  303. /*
  304. *函数功能 : flash擦除1个扇区的内存空间
  305. *函数参数 :
  306. * addr : 将擦除的地址
  307. * 1, 这个地址值，只有前21位有效
  308. * 2, 因为是扇区擦除指令，所以一次最多擦除4K, 如果地址不是4K对齐，比如4094，
  309. * 则会擦除整个扇区空间，不是只擦除本扇区剩余的2个字节。绝对不会擦除接下来的扇区的空间
  310. * 即:会擦除 addr 所在的整个扇区4k空间
  311. * 3, 地址最好4K对齐
  312. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 43页
  313. *注意 : 我们使用的W25Q16DV芯片，flash内存是16Mbit=2M字节，共需要21根地址线来寻址
  314. * 用扇区擦除指令，每次可以擦除16页; 每个扇区=16页=4K字节; 整个flash共512个扇区
  315. * 擦除耗时大概是60ms W25Q16DV-具有SPI接口的flash芯片 67页
  316. */
  317. void flash_erase_memory(unsigned int addr)
  318. {
  319.         unsigned char tx_buf[4]; /*要发送的数据*/
  320.         tx_buf[0] = 0x20;
  321.         tx_buf[1] = addr >> 16;
  322.         tx_buf[2] = addr >> 8;
  323.         tx_buf[3] = addr & 0xff;
  324.     
  325.         flash_write_enable(1); //flash芯片写使能
  326.     
  327.         //flash_set_cs(0); //选中spi flash
  328.         //spi_send_byte(0x20); //发出20命令:扇区擦除指令
  329.         //flash_select_addr(addr); //发出地址
  330.         spi_write(spi_flash_dev, tx_buf, 4); /*发送命令 地址时，片选要一直维持低电平*/

  332.         //flash_set_cs(1);
  333.         
  334.         flash_wait_for_busy(); //等待擦除完成
  335. }

  337. /*
  338. *函数功能 : 向flash存储空间写数据
  339. *函数参数 :
  340. * addr : 将写入的地址
  341. * 1, 这个地址值，只有前21位有效
  342. * 2, 因为是页编程指令，所以一次最多可写1页, 如果地址不是页对齐256字节，比如254，则只写本页剩余的2个字节。绝对不会连续写到下面的页
  343. * 3, 写入的地址最好256字节对齐
  344. * buf : 将写入的数据
  345. * len : 将写入的数据的长度
  346. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 41页
  347. * 写flash存储空间耗时大概是 0.7ms W25Q16DV-具有SPI接口的flash芯片 67页

  349. 一个 spi_message 可能是由 多个 transfers 组成的
  350. static inline int
  351. spi_write(struct spi_device *spi, const u8 *buf, size_t len)
  352. {
  353.     struct spi_transfer    t = {
  354.             .tx_buf        = buf,
  355.             .len        = len,
  356.         };
  357.     struct spi_message    m;

  359.     spi_message_init(&m);
  360.     spi_message_add_tail(&t, &m);
  361.     return spi_sync(spi, &m);
  362. }
  363. */
  364. void flash_write_memory(unsigned int addr, char * buf, int len)
  365. {
  366.         //int i = 0;
  367.         unsigned char tx_buf[4]; /*要发送的数据*/
  368.         
  369.         struct spi_transfer    t[] = { /*这里初始化2个spi_transfer*/
  370.                 {        /*先发送4个字节*/
  371.                         .tx_buf        = tx_buf,
  372.                         .len        = 4,
  373.                 },
  374.                 {        /*再发出数据*/
  375.                         .tx_buf        = buf,
  376.                         .len        = len,
  377.                 },
  378.         };
  379.         struct spi_message    m;
  380.         
  381.         tx_buf[0] = 0x02;
  382.         tx_buf[1] = addr >> 16;
  383.         tx_buf[2] = addr >> 8;
  384.         tx_buf[3] = addr & 0xff;
  385.     
  386.         flash_write_enable(1); //flash芯片写使能
  387.         
  388.         spi_message_init(&m);                            /*初始化这个spi_message*/
  389.         spi_message_add_tail(&t[0], &m);    /*把 spi_transfer[0] 添加到 spi_message*/
  390.         spi_message_add_tail(&t[1], &m);    /*把 spi_transfer[1] 添加到 spi_message*/
  391.         spi_sync(spi_flash_dev, &m);            /*启动传输:发送spi_message*/

  393.         /*也可以把要发送的4个字节+buf，放到一个大的buffer中,再一起发送出去*/
  394.         /*
  395.         flash_set_cs(0); //选中spi flash
  396.         spi_send_byte(0x02); //发出02命令, 页编程指令，每次可编程256个字节；即使用页写命令，每次可写1页
  397.         flash_select_addr(addr); //发出地址
  398.         
  399.         for(i=0; i<len; i++)
  400.         {
  401.                 spi_send_byte(buf[i]); //一次写入一个字节的数据
  402.         }
  403.         
  404.         flash_set_cs(1);
  405.         */

  407.         flash_wait_for_busy(); //等待写数据完成
  408. }

  410. /*
  411. *函数功能 : 读取flash存储空间的数据
  412. *函数参数 :
  413. * addr : 将写入的地址
  414. * buf : 将写入的数据
  415. * len : 将写入的数据的长度
  416. *芯片手册 : W25Q16DV-具有SPI接口的flash芯片 27页

  418.     spi_write_then_read规定了tx_cnt+rx_cnt < 32
  419.     所以对于大量数据的读取，不能使用该函数

  421. */
  422. void flash_read_memory(unsigned int addr, char * buf, int len)
  423. {
  424.         unsigned char tx_buf[4]; /*要发送的数据*/
  425.         
  426.         struct spi_transfer    t[] = { /*这里初始化2个spi_transfer*/
  427.                 {        /*先发送4个字节*/
  428.                         .tx_buf        = tx_buf,
  429.                         .len        = 4,
  430.                 },
  431.                 {        /*再接受数据*/
  432.                         .rx_buf        = buf,
  433.                         .len        = len,
  434.                 },
  435.         };
  436.         struct spi_message    m;
  437.         
  438.         tx_buf[0] = 0x03;
  439.         tx_buf[1] = addr >> 16;
  440.         tx_buf[2] = addr >> 8;
  441.         tx_buf[3] = addr & 0xff;
  442.     
  443.         flash_write_enable(1); //flash芯片写使能
  444.         
  445.         spi_message_init(&m);                            /*初始化这个spi_message*/
  446.         spi_message_add_tail(&t[0], &m);    /*把 spi_transfer[0] 添加到 spi_message*/
  447.         spi_message_add_tail(&t[1], &m);    /*把 spi_transfer[1] 添加到 spi_message*/
  448.         spi_sync(spi_flash_dev, &m);            /*启动传输:发送spi_message*/
  449.         
  450.         /*
  451.         int i = 0;
  452.         //flash_set_cs(0); //选中spi flash
  453.         spi_send_byte(0x03); //发出03命令
  454.         flash_select_addr(addr); //发出地址
  455.         
  456.         for(i=0; i<len; i++)
  457.         {
  458.                 buf[i] = spi_recv_byte(); //一次读取一个字节的数据
  459.         }
  460.         
  461.         //flash_set_cs(1);
  462.         */
  463. }


  466. /*
  467. *函数功能 : flash初始化函数
  468. */
  469. void flash_init(void)
  470. {
  471.         unsigned char reg1_val;

  473.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  474.         reg1_val = flash_read_status_reg1(); //保存状态寄存器1中的值
  475.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  476.         flash_clean_protect_for_status_reg(); //去除状态寄存器的保护
  477.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  478.         flash_clean_protect_for_memory(); //去除整个存储区间的写保护
  479.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  480. }


  483. /********************************************************
  484. 上面是和裸机驱动很像的功能函数
  485. 下面才是linux驱动相关的函数
  486. *********************************************************/
  487. /*
  488. *函数功能 : spi flash的擦除函数
  489. *instr : 擦除信息结构体
  490. * instr->addr : 要擦除的起始地址
  491. * instr->len : 要擦除的长度
  492. */
  493. static int my_spi_flash_erase(struct mtd_info *mtd, struct erase_info *instr)
  494. {
  495.         unsigned int addr = instr->addr; /*要擦除的起始地址*/
  496.         unsigned int i = 0;

  498.         /* 判断参数的地址是否对齐 */
  499.         if((addr & (my_mtd_info.erasesize - 1)) || (instr->len & (my_mtd_info.erasesize - 1)))
  500.         {
  501.                 printk("addr/len is not aligned\n");
  502.                 return -EINVAL;
  503.         }

  505.         for(i=0; i<instr->len; i+=4096) /*扇区擦除指令:1次擦除4K*/
  506.         {
  507.                 flash_erase_memory(addr); /*逐个扇区的擦除 : addr所在的扇区剩余的字节空间，都会擦除*/
  508.                 addr += 4096;
  509.         }

  511.         instr->state = MTD_ERASE_DONE;
  512.         mtd_erase_callback(instr);
  513.         return 0;
  514. }

  516. static int my_spi_flash_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
  517. {
  518.         /*
  519.         from : 读取的地址
  520.         buf : 读取的数据，保存的位置
  521.         len : 读取的数据的长度
  522.         */
  523.         flash_read_memory(from, buf, len);
  524.         *retlen = len;

  526.         return 0;
  527. }

  529. /*
  530. *函数功能 : spi flash的写入函数
  531. *函数参数 :
  532. * to : 要写入的起始地址
  533. * len : 要写入的长度
  534. * retlen : 要写入的长度
  535. * buf : 要写入的数据
  536. */
  537. static int my_spi_flash_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
  538. {
  539.         unsigned int addr = to;        /*要写入的起始地址*/
  540.         unsigned int i = 0;        
  541.         
  542.         /* 判断参数的地址是否对齐 */
  543.         if((to & (my_mtd_info.erasesize - 1)) || (len & (my_mtd_info.erasesize - 1)))
  544.         {
  545.                 printk("addr/len is not aligned\n");
  546.                 return -EINVAL;
  547.         }
  548.         
  549.         for(i=0; i<len; i+=256) /*多个页，要多次才可以写入*/
  550.         {
  551.                 flash_write_memory(addr, (unsigned char *)buf, 256); /*逐页的写 : 页编程指令，所以一次最多可写1页(256字节)*/
  552.                 addr += 256;    //写入的起始地址
  553.                 buf += 256;        //要写入的数据
  554.         }
  555.         
  556.         *retlen = len; /*要写入的起始地址*/
  557.         return 0;
  558. }

  560. static int __devinit spi_flash_probe(struct spi_device *spi)
  561. {
  562.         unsigned char mid = 0;
  563.         unsigned char did = 0;
  564.         
  565.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  566.         spi_flash_dev = spi; /*把 spi_device 保存下来*/
  567.         spi_flash_chip_pin = (int)spi->chip_select; /*获取片选引脚*/
  568.         s3c2410_gpio_cfgpin(spi_flash_chip_pin, S3C2410_GPIO_OUTPUT); /*把oled 片选引脚配置成 输出引脚*/

  570.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  571.         flash_init(); /*要先设置片选引脚，才可以做初始化的工作*/
  572.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  573.         flash_read_id(&mid, &did);
  574.         printk("SPI Flash ID: [0x%02x] [0x%02x]\n", mid, did);

  576.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  577.         memset(&my_mtd_info, 0, sizeof(my_mtd_info));        
  578.         /* Setup the MTD structure */
  579.         my_mtd_info.name = "my_spi_flash";
  580.         my_mtd_info.type = MTD_NORFLASH; /*内存类型*/
  581.         my_mtd_info.flags = MTD_CAP_NORFLASH;
  582.         my_mtd_info.size = 0x200000; /* flash的大小:2M 字节*/
  583.         my_mtd_info.writesize = 1; /*写的最小单位:1个字节*/
  584.         //my_mtd_info.writebufsize = 4096; /* 没有用到 */
  585.         my_mtd_info.erasesize = 4096; /* 擦除的最小单位:扇区=16页=4K字节 */

  587.         my_mtd_info.owner = THIS_MODULE;
  588.         my_mtd_info.erase = my_spi_flash_erase;
  589.         my_mtd_info.read = my_spi_flash_read;
  590.         my_mtd_info.write = my_spi_flash_write;

  592.         /* 添加分区 */
  593.         //add_mtd_partitions(my_mtd_info, my_spimtd_parts, 4);
  594.         //mtd_device_register(&my_mtd_info, NULL, 0); /*2.6.30内核，没有这个函数*/
  595.         
  596.         /*下面这个函数功能:就是把整个spiflash的空间，当做一个分区。*/
  597.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);
  598.         add_mtd_device(&my_mtd_info);
  599.         //printk("[%s][%s][%d] spi_flash_probe\n", __FILE__, __FUNCTION__, __LINE__);

  601.         return 0;
  602. }

  604. static int __devexit spi_flash_remove(struct spi_device *spi)
  605. {
  606.     //mtd_device_unregister(&spi_flash_dev);
  607.     del_mtd_partitions(&my_mtd_info);    /*对应 : add_mtd_partitions*/
  608.     return 0;
  609. }

  611. /*
  612. *spi_driver结构体 : 具体的spi接口设备的驱动代码
  613. */
  614. static struct spi_driver spi_flash_driver = {
  615.         .driver =
  616.         {
  617.                 .name    = "myspi_flash", /*这个名字必须和 spi_board_info中的modalias成员相同*/
  618.                 .owner    = THIS_MODULE,
  619.         },
  620.         .probe        = spi_flash_probe,
  621.         .remove        = __devexit_p(spi_flash_remove),
  622. };

  624. static int __init spi_flash_init(void)
  625. {
  626. /*
  627. *函数功能 : 注册spi驱动
  628. */
  629.         //printk("[%s][%s][%d] spi_flash_init\n", __FILE__, __FUNCTION__, __LINE__);
  630.         spi_register_driver(&spi_flash_driver);
  631.         //printk("[%s][%s][%d] spi_flash_init\n", __FILE__, __FUNCTION__, __LINE__);
  632.         return 0;
  633. }

  635. static void __exit spi_flash_exit(void)
  636. {
  637. /*
  638. *函数功能 : 注销spi驱动
  639. */
  640.         spi_unregister_driver(&spi_flash_driver);
  641. }

  643. module_init(spi_flash_init);
  644. module_exit(spi_flash_exit);
  645. MODULE_AUTHOR("WangXiancai");
  646. MODULE_LICENSE("GPL");

  648. /*
  649. 测试 :
  650. 0, # ls -lrt /dev/mtd* //说明新内核还没有nandflash，spiflash驱动
  651. ls: /dev/mtd*: No such file or directory

  653. 1, 安装驱动
  654. # insmod spi_tq2440_info.ko
  655. # insmod spi_master.ko
  656. # insmod flash_drv.ko
  657. SPI Flash ID: [0xef] [0x14]
  658. # ls -lrt /dev/mtd* //已经创建了1个mtd分区
  659. brw-rw---- 1 root root 31, 0 May 29 04:32 /dev/mtdblock0
  660. crw-rw---- 1 root root 90, 1 May 29 04:32 /dev/mtd0ro
  661. crw-rw---- 1 root root 90, 0 May 29 04:32 /dev/mtd0

  663. 2, # mkfs.vfat /dev/mtdblock0 //把该设备格式化成fat32文件系统

  665. # mkfs.ext3 /dev/sda6 注：把该设备格式化成ext3文件系统
  666. # mke2fs -j /dev/sda6 注：把该设备格式化成ext3文件系统
  667. # mkfs.ext2 /dev/sda6 注：把该设备格式化成ext2文件系统
  668. # mke2fs /dev/sda6 注：把该设备格式化成ext2文件系统
  669. # mkfs.reiserfs /dev/sda6 注：把该设备格式化成reiserfs文件系统
  670. # mkfs.vfat /dev/sda6 注：把该设备格式化成fat32文件系统
  671. # mkfs.msdos /dev/sda6 注：把该设备格式化成fat16文件系统,msdos文件系统就是fat16；
  672. # mkdosfs /dev/sda6 注：把该设备格式化成fat16文件系统，同mkfs.msdos

  674. 3, # mount -t vfat /dev/mtdblock0 /mnt //挂载块设备到 /mnt目录
  675. # cd /mnt
  676. # ls
  677. # touch 1.c
  678. # echo wangxiancai >> 1.c
  679. # l
  680. -rwxr-xr-x 1 root root 12 May 29 05:48 1.c
  681. # cat 1.c
  682. wangxiancai

  684. 4,
  685. # cd /
  686. # umount /mnt                             //卸载磁盘

  688. 5,重启 内核

  690. 6, 重安装驱动
  691. # insmod spi_tq2440_info.ko
  692. # insmod spi_master.ko
  693. # insmod flash_drv.ko
  694. SPI Flash ID: [0xef] [0x14]

  696. # cd /mnt
  697. # l //发现什么都没有
  698. # ls -lrt /dev/mtd* //已经创建了1个mtd分区
  699. brw-rw---- 1 root root 31, 0 May 29 04:32 /dev/mtdblock0
  700. crw-rw---- 1 root root 90, 1 May 29 04:32 /dev/mtd0ro
  701. crw-rw---- 1 root root 90, 0 May 29 04:32 /dev/mtd0

  703. # mount -t vfat /dev/mtdblock0 /mnt //挂载块设备到 /mnt目录
  704. # cd /mnt
  705. # ls //发现还有数据:这个说明磁盘设备里面已经有数据，flash块设备已经起到作用了
  706. */


  709. /*
  710. struct mtd_info {
  711.     u_char type;
  712.     uint32_t flags;
  713.     uint64_t size;     // Total size of the MTD

  715.     uint32_t erasesize;
  716.     uint32_t writesize;

  718.     uint32_t oobsize; // Amount of OOB data per block (e.g. 16)
  719.     uint32_t oobavail; // Available OOB bytes per block

  721.     unsigned int erasesize_shift;
  722.     unsigned int writesize_shift;
  723.     unsigned int erasesize_mask;
  724.     unsigned int writesize_mask;

  726.     const char *name;
  727.     int index;

  729.     struct nand_ecclayout *ecclayout;

  731.     int numeraseregions;
  732.     struct mtd_erase_region_info *eraseregions;

  734.     int (*erase) (struct mtd_info *mtd, struct erase_info *instr);
  735.     int (*point) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, void **virt, resource_size_t *phys);
  736.     void (*unpoint) (struct mtd_info *mtd, loff_t from, size_t len);
  737.     unsigned long (*get_unmapped_area) (struct mtd_info *mtd, unsigned long len, unsigned long offset, unsigned long flags);

  739.     struct backing_dev_info *backing_dev_info;


  742.     int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
  743.     int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
  744.     int (*panic_write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
  745.     int (*read_oob) (struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops);
  746.     int (*write_oob) (struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops);

  748.     int (*get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
  749.     int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
  750.     int (*get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
  751.     int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
  752.     int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
  753.     int (*lock_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len);
  754.     int (*writev) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, size_t *retlen);
  755.     void (*sync) (struct mtd_info *mtd);
  756.     int (*lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
  757.     int (*unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);

  759.     int (*suspend) (struct mtd_info *mtd);
  760.     void (*resume) (struct mtd_info *mtd);
  761.     int (*block_isbad) (struct mtd_info *mtd, loff_t ofs);
  762.     int (*block_markbad) (struct mtd_info *mtd, loff_t ofs);
  763.     struct notifier_block reboot_notifier;
  764.     struct mtd_ecc_stats ecc_stats;
  765.     int subpage_sft;

  767.     void *priv;

  769.     struct module *owner;
  770.     struct device dev;
  771.     int usecount;

  773.     int (*get_device) (struct mtd_info *mtd);
  774.     void (*put_device) (struct mtd_info *mtd);
  775. };

  777. */
spi_master.c文件

点击(此处)折叠或打开

  1. /*
  2. 参考文件:linux/drivers/spi/spi_s3c24xx.c
  3. */

  5. /*
  6. *注意 : spi_master可以选择使用内核提供的代码，也可以自己编写，我们这里先使用内核提供的代码测试一下，
  7. *再使用自己编写的代码

  9. 使用内核提供的代码，要进行必要的检查:
  10. 检查代码，spi_master: drivers\spi\spi-s3c24xx.c
  11. 1,它注册了名为"s3c2410-spi"的platform_driver
  12.     需要有同名的platform_device
  13.     修改arch\arm\mach-s3c24xx\mach-smdk2440.c
  14. static struct platform_device *smdk2440_devices[] __initdata = {
  15.     &s3c_device_ohci,
  16.     &s3c_device_lcd,
  17.     &s3c_device_wdt,
  18.     &s3c_device_i2c0,
  19.     &s3c_device_iis,
  20. +    &s3c_device_spi0, //设备资源的定义在文件 : \kerner-2.6.30\arch\arm\plat-s3c24xx\devs.c
  21. +    &s3c_device_spi1,
  22. };

  24. 重新编译内核，启动开发板之后，
  25. 内核里面就有同名的 platform_device 和 platform_driver
  26. 就会导致 文件 drivers\spi\spi-s3c24xx.c 中 s3c24xx_spi_probe 函数被调用。
  27. 分析文件:\drivers\spi\spi_s3c24xx.c : s3c24xx_spi_probe函数。
  28. //通过下面一行发现:这个platform_data没有，需要重新定义, 在文件:\arch\arm\plat-s3c24xx\devs.c中定义
  29.     hw->pdata = pdata = pdev->dev.platform_data;
  30.     
  31. 2, 给platform_dev添加platform_data
  32.    arch\arm\plat-samsung\devs.c
  33.    
  34. 3, 编译安装驱动
  35. 内核提供的主控驱动是 : \kerner-2.6.30\drivers\spi\spi_s3c24xx.c
  36. 想利用主控驱动，就要配置内核，这个驱动肯定有对应的配置项
  37. makefile里面有 obj-$(CONFIG_SPI_S3C24XX)        += spi_s3c24xx.o
  38. make menuconfig /CONFIG_SPI_S3C24XX 就可以找到对应的配置项。

  40.    Symbol: SPI_S3C24XX [=n] //语法
  41.    Prompt: Samsung S3C24XX series SPI //提示
  42.       Defined at drivers/spi/Kconfig:183 //定义
  43.       Depends on: SPI && SPI_MASTER && ARCH_S3C2410 && EXPERIMENTAL
  44.       //依赖于 这几个选择被选中，才会出现 Samsung S3C24XX series SPI。如果没有被选中，我们还需要手工去选中，才可以继续下面的步骤。
  45.       Location: //具体位置
  46.         -> Device Drivers
  47.          -> SPI support (SPI [=y])
  48.       Selects: SPI_BITBANG
  49. <*> Samsung S3C24XX series SPI //把这个选上，内核就会编译这个驱动了
  50. 编译如果差头文件，还要去找其对应的头文件。

  52. */

  54. /*
  55. 功能 : 自己注册 spi_master
  56. 注意 : 对于每一个spi控制器，都要注册一个 spi_master。
  57. */


  60. #include <linux/init.h>
  61. #include <linux/spinlock.h>
  62. #include <linux/workqueue.h>
  63. #include <linux/interrupt.h>
  64. #include <linux/delay.h>
  65. #include <linux/errno.h>
  66. #include <linux/err.h>
  67. #include <linux/clk.h>
  68. #include <linux/platform_device.h>
  69. #include <linux/gpio.h>

  71. #include <linux/spi/spi.h>
  72. #include <linux/spi/spi_bitbang.h>
  73. #include <plat/regs-spi.h>

  75. #include <asm/io.h>
  76. #include <asm/dma.h>
  77. #include <mach/hardware.h>
  78. #include <mach/regs-gpio.h>

  80. /*用作私有数据*/
  81. struct my_spi_data{
  82.         unsigned int reg_base;                            /*spi相关寄存器的虚拟基地址*/
  83.         int irq_no;                                                    /*中断号*/
  84.         struct spi_transfer * cur_transfer; /*当前的一次传输*/
  85.         int cur_count;                                            /*当前已经传输的长度*/
  86.         struct completion complet; /*完成量completion接口*/
  87.         /*完成量|等待队列|信号量 有什么区别？*/
  88.         struct platform_device * pdev; /*平台设备*/
  89. };

  91. /*
  92. *函数功能 : 设置频率 oled最大是10Mhz， flash最大是80Mhz。
  93. * 设置传输模式
  94. */
  95. static int my_spi_setup(struct spi_device *spi)
  96. {
  97.         struct my_spi_data * spi_data = NULL; /*私有数据*/
  98.         struct clk * pclk = NULL; /*函数功能 : 取得PCLK时钟*/

  100.         int SPCON_cpol = 0; //SPCON0[2]位
  101.         int SPCON_cpha = 0; //SPCON0[1]位

  103.         int div; //SPPRE0[7:0]位 预分频值

  105.         spi_data = spi_master_get_devdata(spi->master); /*私有数据*/
  106.         if(spi_data == NULL)
  107.         {
  108.                 printk("[%s][%s][%d] spi_master_get_devdata err\n", __FILE__, __FUNCTION__, __LINE__);
  109.         }
  110.         pclk = clk_get(NULL, "pclk"); /*函数功能 : 取得PCLK时钟*/
  111.         clk_enable(pclk);
  112.         if(pclk == NULL)
  113.         {
  114.                 printk("[%s][%s][%d] clk_get err\n", __FILE__, __FUNCTION__, __LINE__);
  115.         }

  117.         //printk("[%s][%s][%d] spi->mode=[%d]\n", __FILE__, __FUNCTION__, __LINE__, spi->mode);
  118.         /* SPI的传输模式 : 由 SPCON0[2:1]=CPOL+CPHA2个位共同决定 */
  119.         if (spi->mode & 1)
  120.         {
  121.                 SPCON_cpha = 1;
  122.         }
  123.         if (spi->mode & 2)
  124.         {
  125.                 SPCON_cpol = 1;
  126.         }

  128.     /* 写入SPI控制寄存器 SPCON0*/
  129.     /*[6:5] : 01, 中断模式
  130.     * [4] : 1 = enable 使能时钟
  131.     * [3] : 1 = master 主机控制器
  132.     * [2] : CPOL位 0 = 高电平有效，在没有SPI的操作时，时钟线的电平
  133.     * [1] : CPHA位 0 = format A 格式A
  134.     * [0] : 0 = normal mode
  135.     */
  136.     /* 函数功能 : 向寄存器中写值 */
  137.         writeb((1<<5) | (1<<4) | (1<<3) | (SPCON_cpol << 2) | (SPCON_cpha << 1), spi_data->reg_base + S3C2410_SPCON);
  138.         //printk("[%s][%s][%d] SPCON=[0x%x]\n", __FILE__, __FUNCTION__, __LINE__, (*(volatile unsigned char *)(spi_data->reg_base + S3C2410_SPCON)));

  140.         /* 设置最大传输频率 : max_speed_hz */
  141.     /* 波特率寄存器 SPPRE0*/
  142.         /* OLED : 100ns, 10MHz //SPEC UG-2864TMBEG01 --OLED成品的数据手册 4线spi 17页
  143.     * FLASH : 104MHz 3.3V //W25Q16DV-具有SPI接口的flash芯片 66页
  144.     * 取10MHz PCLK=50M
  145.     * 10 = PCLK / 2 / (Prescaler value + 1) //2440最大提供25M频率
  146.     * Prescaler value = 1.5 取 2
  147.     * Baud rate = 50/2/3=8.3MHz //真实波特率
  148.     */
  149.     /*#define DIV_ROUND_UP(x,y) (((x) + ((y) - 1)) / (y)) //(x+y-1)/y
  150.     *宏的功能 : 实现x/y向上取整
  151.     */
  152.     //printk("[%s][%s][%d] clk_get_rate(pclk)=[%ld]\n", __FILE__, __FUNCTION__, __LINE__, clk_get_rate(pclk));
  153.         //printk("[%s][%s][%d] spi->max_speed_hz=[%d]\n", __FILE__, __FUNCTION__, __LINE__, spi->max_speed_hz);
  154.         div = DIV_ROUND_UP(clk_get_rate(pclk), (spi->max_speed_hz) * 2) - 1;
  155.         //printk("[%s][%s][%d] div=[%d]\n", __FILE__, __FUNCTION__, __LINE__, div);
  156.         if(div > 255)
  157.         {
  158.                 div = 255;
  159.         }
  160.         
  161.         /* 函数功能 : 向SPPRE0寄存器 中写 div预分频值 */
  162.         writeb(div, spi_data->reg_base + S3C2410_SPPRE);
  163.         //printk("[%s][%s][%d] my_spi_setup\n", __FILE__, __FUNCTION__, __LINE__);
  164.         clk_put(pclk);

  166.     return 0;
  167. }

  169. /*
  170. *函数功能 : spi中断服务程序
  171. *中断的触发 : 每完成发送一个数据 或者 每成功接收完成一个数据，就会触发一次中断。
  172. *
  173. *编程心得 : 之前，这个中断函数一直不能触发，找了很久的原因，
  174. * 拍错的过程非常的艰苦:1，怀疑 pclk 或者 spiclk 没有启动
  175. * 2，怀疑GPIO引脚设置出错
  176. * 3，怀疑spi相关控制器的寄存器设置出错
  177. * 4，怀疑中断注册失败
  178. * 最后发现居然是个很低级的错误，只是 if(spi_tran == NULL)的判断，在
  179. * 语句 spi_data = spi_master_get_devdata(master); 之前，肯定为空啊，所以感觉老是不能触发，
  180. * 写代码，要相信自己，大方向不会错，错的都是细节。
  181. */
  182. static irqreturn_t s3c2440_spi_interrupt(int irq, void *dev_id)
  183. {
  184.     struct spi_master *master = NULL;
  185.     struct my_spi_data * spi_data = NULL;                /*私有数据*/
  186.     struct spi_transfer * spi_tran = NULL;            /*当前的一次传输*/

  188.     master = (struct spi_master *)dev_id;
  189.     spi_data = spi_master_get_devdata(master);    /*私有数据*/
  190.     spi_tran = spi_data->cur_transfer;                    /*当前的一次传输*/
  191.     
  192.     if(spi_tran == NULL) /* 误触发 */
  193.     {
  194.             printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  195.                 return IRQ_HANDLED;
  196.     }
  197.         //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  198.     /* 处理 当前的一次传输 spi_tran */
  199.     if(spi_tran->tx_buf) /* 是发送 */
  200.     {
  201.         (spi_data->cur_count)++; /*发送完一个数据*/
  202.         
  203.         if(spi_data->cur_count < spi_tran->len)/* 没发完? */
  204.         {
  205.                 //printk("[%s][%s][%d] len=[%d] tx_buf[%d]=[0x%x]\n", __FILE__, __FUNCTION__, __LINE__, spi_tran->len, spi_data->cur_count, ((unsigned char *)(spi_tran->tx_buf))[spi_data->cur_count]);
  206.             writeb(((unsigned char *)(spi_tran->tx_buf))[spi_data->cur_count], spi_data->reg_base + S3C2410_SPTDAT);
  207.         }
  208.         else /*本次 spi_transfer 处理完毕*/
  209.         {
  210.                 /*函数功能 : complete只会唤醒一个等待线程*/
  211.             complete(&(spi_data->complet)); /* 本次 tx_buf 中数据全部发送完毕，则唤醒 */

  213.             //tran_end = 1; /* 睡眠函数的第2个参数为真 */
  214.                        //wake_up_interruptible(&tran_waitq); /* 唤醒休眠的进程 */

  216.             //printk("[%s][%s][%d] complete ok\n", __FILE__, __FUNCTION__, __LINE__);
  217.         }
  218.     }
  219.     else /* 接收 */
  220.     {
  221.         /* 读/存数据 */
  222.         ((unsigned char *)spi_tran->rx_buf)[spi_data->cur_count] = (unsigned char)readb(spi_data->reg_base + S3C2410_SPRDAT);
  223.         (spi_data->cur_count)++;
  224.                 //printk("[%s][%s][%d] \n", __FILE__, __FUNCTION__, __LINE__);
  225.         if(spi_data->cur_count < spi_tran->len)/* 没收完? */
  226.         {
  227.                 //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  228.             writeb(0xff, spi_data->reg_base + S3C2410_SPTDAT); /*再次随便发送一个数据*/
  229.         }
  230.         else /*本次 spi_transfer 处理完毕*/
  231.         {
  232.                         //tran_end = 1; /* 睡眠函数的第2个参数为真 */
  233.                        //wake_up_interruptible(&tran_waitq); /* 唤醒休眠的进程 */
  234.                         //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  235.             complete(&(spi_data->complet)); /* 唤醒 */
  236.         }
  237.     }
  238.     //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  239.         return IRQ_HANDLED;
  240. }

  242. /*
  243. *函数功能 : spi总线收发函数
  244. *注意 : 1个 spi_transfer，是一个不可以打断的spi传输过程。
  245. * 应用程序write时，会调用oled驱动的oled_write函数，再调用spi_write,最终会调用本函数:my_spi_transfer
  246. * 每向oled写一个命令，spi_write写的长度是0， spi_message 里面只有一个 spi_transfer,里面传输长度是1，中断会触发1次
  247. * 每向oled写一个字符，spi_write写的长度是8(写2次共16个字模)，spi_message 里面也只有一个 spi_transfer,里面传输长度是8，中断会触发8次
  248. */
  249. static int my_spi_transfer(struct spi_device *spi, struct spi_message *mesg)
  250. {
  251.         struct spi_master *master = spi->master;
  252.         struct spi_transfer    * spi_tran = NULL;
  253.         struct my_spi_data * spi_data = spi_master_get_devdata(spi->master); /*私有数据*/

  255.         /* 1,选中芯片 */
  256.         s3c2410_gpio_setpin(spi->chip_select, 0); /* 默认为低电平选中 */
  257.         
  258.         /* 2,发送数据 */
  259.         /* 2.1 发送第1个 transfers 之前 要调用setup */
  260.         master->setup(spi);

  262.         /* 2.2 注意 : 一个 spi_message 可能是由 多个 transfers 组成的。
  263.         * 所以 : 从spi_message中逐个取出 transfers,处理它。
  264.         *          注意 : spi_transfer 结构有 transfer_list成员。
  265.         */
  266.         //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  267.         list_for_each_entry (spi_tran, &(mesg->transfers), transfer_list)
  268.         {
  269.                 /* 处理这个 spi_tran */
  270.                 spi_data->cur_transfer = spi_tran; /*保存当前的 spi_tran*/
  271.                 spi_data->cur_count = 0; /*当前处理数据个数*/

  273.                 /*函数功能 : 初始化完成量*/
  274.                 //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  275.                 init_completion(&(spi_data->complet));

  277.         if(spi_tran->tx_buf) /* 发送缓冲区存在 */
  278.         {
  279.                 //printk("[%s][%s][%d] tx_buf[0]=[0x%x]\n", __FILE__, __FUNCTION__, __LINE__, ((unsigned char *)(spi_tran->tx_buf))[0]);
  280.             writeb(((unsigned char *)(spi_tran->tx_buf))[0], spi_data->reg_base + S3C2410_SPTDAT); /* 它会触发中断 */
  281.             //printk("[%s][%s][%d] SPTDAT=[0x%x]\n", __FILE__, __FUNCTION__, __LINE__, (*(volatile unsigned char *)(spi_data->reg_base + S3C2410_SPTDAT)));
  282.             /*注意 : 如果 tx_buf 中有100个值，我这里只是把第1个值送到了寄存器中，其他值由中断服务程序来传输*/
  283.             
  284.             //wait_event_interruptible(tran_waitq, tran_end);
  285.             //tran_end = 0;
  286.             /*函数功能 : 注意wait_for_completion会产生一个非中断的等待，如果没有人来完成该任务，
  287.             则会产生一个不可杀的进程。所以这个要小心使用。
  288.             */
  289.             wait_for_completion(&(spi_data->complet)); /* 休眠阻塞 : 在中断处理程序中，当complete执行之后再唤醒这里，解除阻塞*/
  290.         }
  291.         else if(spi_tran->rx_buf) /* 接收缓冲区存在 */
  292.         {
  293.                 //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  294.             writeb(0xff, spi_data->reg_base + S3C2410_SPTDAT); /* 它会触发中断 */
  295.             //writeb(0xff, spi_data->reg_base + S3C2410_SPRDAT); //刚开始用这个，排错排了很久
  296.                         //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  297.                         //wait_event_interruptible(tran_waitq, tran_end);
  298.             //tran_end = 0;
  299.             wait_for_completion(&(spi_data->complet)); /* 休眠阻塞 : 在中断处理程序中，当complete执行之后再唤醒这里，解除阻塞*/
  300.         }
  301.     }
  302.     
  303.         /* 2.3 唤醒等待的进程 */
  304.         mesg->status = 0; /*0:表示成功*/
  305.         mesg->complete(mesg->context);
  306.         
  307.         /* 3,取消片选 */
  308.         s3c2410_gpio_setpin(spi->chip_select, 1); /* 默认为高电平取消选中 */

  310.         return 0;
  311. }

  313. /*
  314. *函数功能 : SPI硬件控制器的初始化
  315. *函数参数 : 0:控制器0 1:控制器1
  316. */
  317. static void spi_controler_init(int which)
  318. {
  319.         struct clk * clk = NULL;
  320.         clk = clk_get(NULL, "spi");
  321.         if(clk != NULL)
  322.         {
  323.                 printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  324.         }

  326.         /* 使能spi 控制器 0/1的时钟 */
  327.         clk_enable(clk);
  328.         clk_put(clk);

  330.         /* GPIO */
  331.         if(which == 0) /* SPI 控制器 0 */
  332.         {
  333.         /*
  334.                  *时钟引脚 : GPE13,设置为 10:SPICLK0 引脚
  335.                  *主机数据输出引脚 : GPE12,设置为 10:SPIMOSI 引脚
  336.                  *主机数据输入引脚 : GPE11,设置为 10:SPIMISO 引脚
  337.          */
  338.         s3c2410_gpio_cfgpin(S3C2410_GPE11, (0x02 << (2*11)));
  339.         s3c2410_gpio_cfgpin(S3C2410_GPE12, (0x02 << (2*12)));
  340.         s3c2410_gpio_cfgpin(S3C2410_GPE13, (0x02 << (2*13)));
  341.     }
  342.     else if(which == 1) /* SPI 控制器 1 */
  343.     {
  344.         /*
  345.          * GPG5 SPIMISO
  346.          * GPG6 SPIMOSI
  347.          * GPG7 SPICLK
  348.          */
  349.         s3c2410_gpio_cfgpin(S3C2410_GPG5, (0x02 << (2*5)));
  350.         s3c2410_gpio_cfgpin(S3C2410_GPG6, (0x02 << (2*6)));
  351.         s3c2410_gpio_cfgpin(S3C2410_GPG7, (0x02 << (2*7)));
  352.     }
  353. }

  355. static struct spi_master * spi_master0;
  356. //static struct spi_master * spi_master1;

  358. static int __init spi_master_init(void)
  359. {
  360.         int rc;
  361.         int status;
  362.         
  363.         struct my_spi_data * spi_data0 = NULL; /*私有数据*/
  364.         //struct my_spi_data * spi_data1 = NULL;
  365.         struct platform_device * pdev0 = NULL;
  366.         //struct platform_device * pdev1 = NULL;
  367.         
  368.         /*函数功能 : 构造一个 platform_device 结构*/
  369.         pdev0 = platform_device_alloc("s3c2440_spi_0", 0); /*第2个参数可以随便写*/
  370.         //pdev1 = platform_device_alloc("s3c2440_spi_1", 1); /*第2个参数可以随便写*/
  371.         /*函数功能 : 分配了平台设备之后，就要加入到设备链表中,才可以使用*/
  372.     platform_device_add(pdev0);
  373.     //platform_device_add(pdev1);
  374.         /*
  375.         *1，函数功能 : 分配 spi_master 结构
  376.         *注意 : 这个分配函数，会在分配 spi_master结构体的空间之后，再分配一段空间。
  377.         * 这个多余分配出来的空间，可以用来存放自己定义的私有数据。第2个参数可以表示这个私有数据的大小。
  378.         */
  379.         spi_master0 = spi_alloc_master(&(pdev0->dev), sizeof(struct my_spi_data));
  380.         if(!spi_master0)
  381.         {
  382.                 printk("[%s][%s][%d] spi_alloc_master err\n", __FILE__, __FUNCTION__, __LINE__);
  383.                 return -ENOMEM;
  384.         }
  385.         //spi_master1 = spi_alloc_master(&(pdev1->dev), sizeof(struct my_spi_data));

  387.         /*2, 设置 spi_master */
  388.         spi_master0->bus_num = 0; /*会跟spi_board_info中的bus_num比较*/
  389.         //spi_master1->bus_num = 1;
  390.         
  391.         spi_master0->num_chipselect = 0xffff; /*最大片选数*/
  392.         //spi_master1->num_chipselect = 0xffff;
  393.         //spi_master0->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
  394.         //spi_master1->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;

  396.         spi_master0->setup = my_spi_setup; /*设置 oled最大是10Mhz， flash最大是80Mhz*/
  397.         //spi_master1->setup = my_spi_setup;
  398.         spi_master0->transfer = my_spi_transfer; /*spi总线收发函数*/
  399.         //spi_master1->transfer = my_spi_transfer;

  401.         /*3, 设置私有数据 */
  402.         //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  403.         spi_data0 = spi_master_get_devdata(spi_master0);
  404.         //printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  405.         //spi_data1 = spi_master_get_devdata(spi_master1);
  406.         spi_data0->reg_base = (unsigned int)ioremap(0x59000000, 0x18);
  407.         //spi_data1->reg_base = (unsigned int)ioremap(0x59000020, 0x18);
  408.         spi_data0->irq_no = IRQ_SPI0;
  409.         //spi_data1->irq_no = IRQ_SPI1;
  410.         spi_data0->pdev = pdev0;
  411.         //spi_data1->pdev = pdev1;

  413.         /*4, 硬件 SPI 控制器 引脚 初始化 */
  414.         spi_controler_init(spi_master0->bus_num);
  415.         //spi_controler_init(spi_master1->bus_num);

  417.         /*5, 安装SPI中断处理函数 : SPI通过中断来传输数据
  418.         #define IRQ_EINT1            5
  419.         #define IRQ_EINT2            6
  420.         #define IRQ_EINT3            7
  421.         */ //0x20
  422.         rc = request_irq(spi_data0->irq_no, s3c2440_spi_interrupt, 0, "s3c2440_spi_0", spi_master0);
  423.         if(rc)
  424.         {
  425.                 printk("[%s][%s][%d] request_irq err\n", __FILE__, __FUNCTION__, __LINE__);
  426.                 return rc;
  427.         }
  428.         /*
  429.         rc = request_irq(spi_data1->irq_no, s3c2440_spi_interrupt, 0x20, "s3c2440_spi_1", spi_master1);
  430.         printk("[%s][%s][%d] rc=[%d]\n", __FILE__, __FUNCTION__, __LINE__, rc);
  431.         if(rc)
  432.         {
  433.                 printk("[%s][%s][%d] request_irq err\n", __FILE__, __FUNCTION__, __LINE__);
  434.                 return rc;
  435.         }
  436.         */

  438.         /*6, 注册 spi_master */
  439.         printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);
  440.         status = spi_register_master(spi_master0);
  441.         //status = spi_register_master(spi_master1);
  442.         if(status < 0)
  443.         {
  444.                 printk("[%s][%s][%d] spi_register_master err\n", __FILE__, __FUNCTION__, __LINE__);
  445.                 return status;
  446.         }
  447.         printk("[%s][%s][%d]\n", __FILE__, __FUNCTION__, __LINE__);

  449.         return 0;
  450. }

  452. static void __exit spi_master_exit(void)
  453. {
  454.         struct my_spi_data * spi_data0; /*私有数据*/
  455.         //struct my_spi_data * spi_data1;
  456.         
  457.         /*取得私有数据 */
  458.         spi_data0 = spi_master_get_devdata(spi_master0);
  459.         //spi_data1 = spi_master_get_devdata(spi_master1);
  460.         
  461.         /*1, 注销 spi_master 对应 spi_register_master */
  462.         spi_unregister_master(spi_master0);
  463.         //spi_unregister_master(spi_master1);
  464.         
  465.         /*5, 释放 platform_device 对应 platform_device_alloc */
  466.         platform_device_del(spi_data0->pdev);
  467.     platform_device_put(spi_data0->pdev);
  468.     //platform_device_del(spi_data1->pdev);
  469.     //platform_device_put(spi_data1->pdev);
  470.         /*2, 释放 中断 对应 request_irq */
  471.         free_irq(spi_data0->irq_no, spi_master0);
  472.         //free_irq(spi_data1->irq_no, spi_master1);
  473.         /*3, 虚拟地址释放 对应 ioremap */
  474.     iounmap((void *)(spi_data0->reg_base));
  475.     //iounmap((void *)(spi_data1->reg_base));
  476.     /*4, 释放 spi_master 对应 spi_alloc_master */
  477.     kfree(spi_master0);
  478.         //kfree(spi_master1);

  480. }

  482. module_init(spi_master_init);
  483. module_exit(spi_master_exit);
  484. MODULE_AUTHOR("WangXiancai");
  485. MODULE_LICENSE("GPL");

  487. /*
  488. 测试 :
  489. 1, 内核里面有自带的 spi_master 驱动程序，这里要先去掉
  490.    \kerner-2.6.30\drivers\spi\Makefile
  491.    32行 # obj-$(CONFIG_SPI_S3C24XX)        += spi_s3c24xx.o
  492.    也可以通过 make menuconfig 来 去掉 CONFIG_SPI_S3C24XX 选项，如果单板相关的信息可以单独注册。
  493. 2, 注意 : spi_board_info必须先注册，再注册 spi_master。
  494. # insmod spi_tq2440_info.ko
  495. DEVICE:1_spi_info_TQ2440_init ####################
  496. DEVICE: 1_spi_register_board_info at [drivers/spi/spi.c][373][spi_register_board_info]!
  497. DEVICE: 2_spi_register_board_info at [drivers/spi/spi.c][378][spi_register_board_info]!
  498. DEVICE:2_spi_info_TQ2440_init ####################
  499. # insmod spi_master.ko
  500. # insmod oled_drv.ko
  501. DEVICE:spi_oled_probe ####################
  502. # ls -lrt /dev/oled
  503. crw-rw---- 1 root root 252, 0 May 27 04:41 /dev/oled
  504. */






  511. /*
  512. struct spi_master {
  513.     struct device    dev;
  514.     s16            bus_num;
  515.     u16            num_chipselect;
  516.     u16            dma_alignment;
  517.     int            (*setup)(struct spi_device *spi);
  518.     int            (*transfer)(struct spi_device *spi,
  519.                         struct spi_message *mesg);
  520.     void            (*cleanup)(struct spi_device *spi);
  521. };

  523. struct spi_message
  524. {
  525.         struct list_head    transfers;
  526.         struct spi_device    *spi;
  527.         unsigned        is_dma_mapped:1;

  529.         void            (*complete)(void *context);
  530.         void            *context;
  531.         unsigned        actual_length;
  532.         int            status;

  534.         struct list_head    queue;
  535.         void            *state;
  536. };

  538. struct spi_transfer {
  539.     const void    *tx_buf;
  540.     void        *rx_buf;
  541.     unsigned    len;

  543.     dma_addr_t    tx_dma;
  544.     dma_addr_t    rx_dma;

  546.     unsigned    cs_change:1;
  547.     u8        bits_per_word;
  548.     u16        delay_usecs;
  549.     u32        speed_hz;

  551.     struct list_head transfer_list;
  552. };

  554. #define list_for_each_entry(pos, head, member)                \
  555. for(pos = list_entry((head)->next, typeof(*pos), member), prefetch(pos->member.next);
  556.         &pos->member != (head);
  557.         pos = list_entry(pos->member.next, typeof(*pos), member),    prefetch(pos->member.next))

  559. */


  562. /*
  563. 内核编程中常见的一种模式是，在当前线程之外初始化某个活动，然后等待该活动的结束。
  564. 这个活动可能是，创建一个新的内核线程或者新的用户空间进程、对一个 已有进程的某个请求，
  565. 或者某种类型的硬件动作，等等。在这种情况下，我们可以使用信号量来同步这两个任务。
  566. 然而，内核中提供了另外一种机制 --completion接口。Completion是一种轻量级的机制，
  567. 他允许一个线程告诉另一个线程某个工作已经完成。

  569. 1, 结构与初始化
  570. Completion在内核中的实现基于等待队列（关于等待队列理论知识在前面的文章中有介绍），
  571. completion结构很简单：
  572.    
  573. struct completion
  574. {
  575.     unsigned int done; //用于同步的原子量
  576.     wait_queue_head_t wait; //等待事件队列
  577. };
  578.    
  579. 和信号量一样，初始化分为静态初始化和动态初始化两种情况：
  580.    
  581. 静态初始化：
  582. #define COMPLETION_INITIALIZER（work）{ 0, __WAIT_QUEUE_HEAD_INITIALIZER（（work）。wait）}
  583. #define DECLARE_COMPLETION（work）struct completion work = COMPLETION_INITIALIZER（work）

  585. 动态初始化：
  586. static inline void init_completion（struct completion *x）
  587. {
  588.         x->done = 0;
  589.         init_waitqueue_head（&x->wait）；
  590. }
  591. 可见，两种初始化都将用于同步的done原子量置位了0,后面我们会看到，该变量在wait相关函数中减一，
  592. 在complete系列函数中加一。

  594. 2, 实现
  595.    
  596. 同步函数一般都成对出现，completion也不例外，我们看看最基本的两个complete和wait_for_completion
  597. 函数的实现。
  598.    
  599. wait_for_completion最终由下面函数实现：
  600.    
  601. static inline long __sched do_wait_for_common（struct completion *x, long timeout, int state）
  602. {
  603.     if（！x->done）
  604.     {
  605.          DECLARE_WAITQUEUE（wait, current）；
  606.          wait.flags |= WQ_FLAG_EXCLUSIVE;
  607.          __add_wait_queue_tail（&x->wait, &wait）；
  608.         
  609.          do
  610.          {
  611.                  if （signal_pending_state（state, current））
  612.                  {
  613.                          timeout = -ERESTARTSYS;
  614.                         
  615.                          break;
  616.                  }
  617.                  __set_current_state（state）；
  618.                  spin_unlock_irq（&x->wait.lock）；
  619.                  timeout = schedule_timeout（timeout）；
  620.                  spin_lock_irq（&x->wait.lock）；
  621.          }
  622.          while （！x->done && timeout）；
  623.          __remove_wait_queue（&x->wait, &wait）；
  624.          if （！x->done）
  625.              {
  626.                  return timeout;
  627.              }
  628.     }
  629.     x->done--;
  630.     return timeout ?: 1;
  631. }
  632.    
  633. 而complete实现如下：
  634.    
  635. void complete（struct completion *x）
  636. {
  637.     unsigned long flags;
  638.     spin_lock_irqsave（&x->wait.lock, flags）；
  639.     x->done++;
  640.     __wake_up_common（&x->wait, TASK_NORMAL, 1, 0, NULL）；
  641.     spin_unlock_irqrestore（&x->wait.lock, flags）；
  642. }
  643.    
  644. 不看内核实现的源代码我们也能想到他的实现，不外乎在wait函数中循环等待done变为可用（正），
  645. 而另一边的complete函数为唤醒函数，当然是将done加一，唤醒待处理的函数。是的，从上面的代码看到，
  646. 和我们想的一样。内核也是这样做的。

  648. */
应用程序
makefile文件

点击(此处)折叠或打开

  1. # CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-gcc
  2. CROSS=/home/wangxc/linux/toolchain/crosstools_4.4.3_softfloat/bin/arm-linux-gcc
  3. all:spitest
  4. spitest:spitest.c
  5.     $(CROSS) -o spitest spitest.c
  6. clean:
  7.     rm -vf spitest.o spitest
spitest.c文件

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <sys/types.h>
  4. #include <fcntl.h>
  5. #include <sys/ioctl.h>
  6. #include <stdlib.h>
  7. #include <errno.h>

  9. #include "oled_font.h"

  11. /*下面是ioctl识别的宏定义 和内核中定义的一样*/
  12. #define OLED_CMD_INIT 0x100001
  13. #define OLED_CMD_CLEAR_ALL 0x100002
  14. #define OLED_CMD_CLEAR_PAGE 0x100003
  15. #define OLED_CMD_SET_POS 0x100004

  17. /* 命令行参数如下:
  18.  * spitest init                    //oled初始化
  19.  * spitest clear                //oled清屏
  20.  * spitest clear <page>    //oled清屏某一页
  21.  * spitest <page> <col> <string> //从指定的行+列，写一个字符串
  22.  */

  24. void print_usage(char *cmd);
  25. void oled_fix_put_char(int fd, unsigned int page, unsigned int col, unsigned char val);
  26. void oled_print(int fd, unsigned int page, unsigned int col, char * str);

  28. int main(int argc, char **argv)
  29. {
  30.     int do_init = 0;
  31.     int do_clear = 0;
  32.     int do_show = 0;
  33.     int page = -1;
  34.     int col;

  36.     int fd;
  37.         
  38.         /*判断参数的合法性*/
  39.     if (argc == 2 && !strcmp(argv[1], "init"))
  40.     {
  41.                 do_init = 1;
  42.                 printf("init:\n");
  43.     }
  44.     else if ((argc == 2) && !strcmp(argv[1], "clear"))
  45.     {
  46.                 do_clear = 1;
  47.                 printf("clear all:\n");
  48.     }
  49.     else if ((argc == 3) && !strcmp(argv[1], "clear"))
  50.     {
  51.                 do_clear = 1;
  52.                 page = strtoul(argv[2], NULL, 0);
  53.                 printf("clear page:\n");
  54.     }
  55.     else if (argc == 4)
  56.     {
  57.                 do_show = 1;
  58.                 page = strtoul(argv[1], NULL, 0);
  59.                 col = strtoul(argv[2], NULL, 0);
  60.                 
  61.                 printf("page=[%d]\n", page);
  62.                 printf("col=[%d]\n", col);
  63.     }
  64.     else
  65.     {
  66.                 print_usage(argv[0]);
  67.                 return -1;
  68.     }
  69.         
  70.         /*打开oled文件*/
  71.         printf("open begin:\n");
  72.     fd = open("/dev/oled", O_RDWR);
  73.     if(fd < 0)
  74.     {
  75.         printf("can't open /dev/oled\n");
  76.         return -1;
  77.     }
  78.     printf("open succ!\n");

  80.     if(do_init > 0) //oled初始化
  81.     {
  82.             printf("app:ioctl OLED_CMD_INIT begin:\n");
  83.         ioctl(fd, OLED_CMD_INIT);
  84.         printf("app:ioctl OLED_CMD_INIT succ!\n");
  85.     }
  86.     else if(do_clear > 0)
  87.     {
  88.         if (page == -1)
  89.         {
  90.             ioctl(fd, OLED_CMD_CLEAR_ALL); //oled清屏
  91.         }
  92.         else
  93.         {
  94.             if (page < 0 || page > 7)
  95.             {
  96.                 printf("page is 0,1,...,7\n");
  97.                 return -1;
  98.             }
  99.             ioctl(fd, OLED_CMD_CLEAR_PAGE, page); //oled清屏某一页
  100.         }
  101.     }
  102.     else if(do_show > 0)
  103.     {
  104.         if (page < 0 || page > 7)
  105.         {
  106.             printf("page is 0,1,...,7\n");
  107.             return -1;
  108.         }
  109.         if (col < 0 || col > 127)
  110.         {
  111.             printf("col is 0,1,...,127\n");
  112.             return -1;
  113.         }
  114.         oled_print(fd, page, col, argv[3]); //从指定的行+列，写一个字符串
  115.     }
  116.     return 0;
  117. }


  120. void print_usage(char *cmd)
  121. {
  122.     printf("Usage:\n");
  123.     printf("%s init\n", cmd);
  124.     printf("%s clear\n", cmd);
  125.     printf("%s clear \n", cmd);
  126.     printf("%s \n", cmd);
  127.     printf("page is 0,1,...,7\n");
  128.     printf("col is 0,1,...,127\n");
  129. }


  132. /*
  133. *函数功能 : 向oled显示屏,指定的列地址+页地址，显示一个字符。
  134. *函数参数 :
  135. * col : 0到127 val表示的字符，将要显示的列位置
  136. * page : 0到7 val表示的字符，将要显示的页位置
  137. *注意 : 一个字模跨2个page
  138. */
  139. void oled_fix_put_char(int fd, unsigned int page, unsigned int col, unsigned char val)
  140. {
  141.         int i;
  142.         /*得到字模*/
  143.         const unsigned char *zifu = oled_asc2_8x16[val - ' ']; //val - ' ' : 字符在字模数组中对应的下标

  145.         /*发给oled*/
  146.         //uart_printf("oled_fix_put_char page = [%d], col = [%d], val = [%c]\n\n", page, col, val);
  147.         //oled_set_addr(page, col); //设置位置,字符所占的第1个page
  148.         ioctl(fd, OLED_CMD_SET_POS, page | (col << 8));
  149.     /* 发出8字节数据 */
  150.     /*
  151.     for (i = 0; i < 8; i++)
  152.         {
  153.         oled_write_data(zifu[i]); //连续写，列地址就自动加1
  154.         }
  155.         */
  156.         write(fd, &zifu[0], 8);

  158.     //oled_set_addr(page+1, col); //1个字符占2页,字符所占的第2个page
  159.     /*约定第3个参数 中0到7位是表示page; 8到15位是表示col*/
  160.     ioctl(fd, OLED_CMD_SET_POS, (page+1) | (col << 8));
  161.     
  162.     /* 发出8字节数据 */
  163.     /*
  164.     for (i = 0; i < 8; i++)
  165.        {
  166.         oled_write_data(zifu[i+8]);
  167.         }
  168.         */
  169.         write(fd, &zifu[8], 8);
  170. }


  173. /*
  174. *函数功能 : 向oled显示屏，打印一个字符串,从指定的行，列开始打印，会自动换行
  175. *函数参数 :
  176. * col : 0到127 起始存放的 第1个字符的列
  177. * page : 0到7 起始存放的 第1个字符所在的页
  178. *注意 :
  179. * 1, 我们使用的OLED的分辨率=128*64 0:表示像素熄灭， 1:表示像素点亮
  180. * 2, 显存大小 = 128*64位=1K字节
  181. * 3, OLED主控芯片数据手册,SSD1306(36页)10.1.3节，设置显存的地址模式，提供了3种地址模式，
  182. * 最常用的是 : 页地址模式。
  183. * 4, 页地址模式:
  184. * 64行分为8页，每页对应8行。可以选中指定的页，再选中指定的列，再向里面写数据，
  185. * 每写1列，列地址就自动加1,1页写完之后，继续写，会自动跳到下一页开头位置继续写。
  186. * 5, 约定一个数字|英文字符的大小是 8*16， 宽:8列, 高:16行。
  187. * 这样,这个OLED屏，可以显示8行，每行8个字符
  188. */
  189. void oled_print(int fd, unsigned int page, unsigned int col, char * str)
  190. {
  191.         char * tmp;
  192.         tmp = str;
  193.         
  194.         ioctl(fd, OLED_CMD_CLEAR_PAGE, page); //oled清屏某一页
  195.         ioctl(fd, OLED_CMD_CLEAR_PAGE, page+1); //oled清屏某一页
  196.         while((*tmp) != '\0')
  197.         {
  198.                 //uart_printf("oled_print *tmp = [%c]\n\n", *tmp);
  199.                 oled_fix_put_char(fd, page, col, *tmp);
  200.                 col += 8; //每个字符占8列
  201.                 if(col > 127) //一行写满，自动换行
  202.                 {
  203.                         col = 0;
  204.                         page += 2; //每个字符占16行，跨2页
  205.                         if(page > 7) //8页都写满，再从最开始的位置，再写。
  206.                         {
  207.                                 page = 0;
  208.                         }
  209.                         ioctl(fd, OLED_CMD_CLEAR_PAGE, page); //oled清屏某一页
  210.                         ioctl(fd, OLED_CMD_CLEAR_PAGE, page+1); //oled清屏某一页
  211.                 }
  212.                 tmp++;        
  213.         }
  214. }


  217. /*
  218. 测试 :
  219. 1， 刚才开始的测试的时候，由于open函数使用的是 RDONLY 只读打开，驱动函数 write不能调用，
  220. 使用 O_RDWR 可读可写方式打开，才能正确
  221. 2，
  222. # ./iictest
  223. ./iictest r|R addr
  224. ./iictest w|W addr val
  225. # ./iictest w 100 56 //向100地址中写入数据56
  226. write address [100] with data [56]
  227. # ./iictest r 100 //从100地址中读取数据
  228. read address = [100]
  229. data = [56]
  230. # ./spitest init                    //oled初始化
  231. # ./spitest clear                //oled清屏
  232. # ./spitest clear 0    //oled清屏某一页
  233. # ./spitest 0 0 WangXiancai //从指定的行+列，写一个字符串
  234. */
oled_font.h文件

点击(此处)折叠或打开

  1. #ifndef _OLEDFONT_H_
  2. #define _OLEDFONT_H_

  4. /*
  5. 注意 : 下面的对2维数组的定义，每个元素都被赋值了，即为对象已经分配内存了，则不能在多个文件中包含这个头文件。
  6. 如果仅仅是一些声明，是可以在多个文件中包含这个头文件的。

  8. 注意 : 对象必须有且只有1个定义，但是它可以有多extern声明。
  9. */

  11. /*
  12. *字模 : 8*16像素 = 宽:8位 + 高:16位
  13. *注意 : 下面列出来的字符是按照ascii码从空格开始，按照顺序列出来，这么做是为了方便取码
  14. *下面理解成 : 1维数组，这个数组的每个元素又是1维数组
  15. *在oled屏幕中的位置:
  16. * 比如字符A : 在数组中的下标是33, 则oled_asc2_8x16[33]可以表示1个1维数组名，这个1维数组可以取出16个字符
  17. * {0x00,0x00,0xC0,0x38,0xE0,0x00,0x00,0x00,0x20,0x3C,0x23,0x02,0x02,0x27,0x38,0x20},//A33
  18. *
  19. * 上面页，8列，从最左1列开始，依次对应上面16个字符的前面8个字符 : 0x00,0x00,0xC0,0x38,0xE0,0x00,0x00,0x00
  20. *
  21. * 下面模拟OLED的1个字符的显示 像素=8*16
  22. * |0|0|0|0|0|0|0|0| 字符的最低位
  23. * |0|0|0|0|0|0|0|0|
  24. * |0|0|0|0|0|0|0|0|
  25. * |0|0|0|1|0|0|0|0|
  26. * |0|0|0|1|0|0|0|0|
  27. * |0|0|0|1|1|0|0|0|
  28. * |0|0|1|0|1|0|0|0|
  29. * _____|0|0|1|0|1|0|0|0|_____ 字符的最高位
  30. * |0|0|1|0|0|1|0|0| 字符的最低位
  31. * |0|0|1|1|1|1|0|0|
  32. * |0|1|0|0|0|1|0|0|
  33. * |0|1|0|0|0|0|1|0|
  34. * |0|1|0|0|0|0|1|0|
  35. * |1|1|1|0|0|1|1|1|
  36. * |0|0|0|0|0|0|0|0|
  37. *          |0|0|0|0|0|0|0|0| 字符的最高位
  38. * 下面页，8列，从最左1列开始，依次对应上面16个字符的后面8个字符 ; 0x20,0x3C,0x23,0x02,0x02,0x27,0x38,0x20
  39. * 说明 : 所有标1的地方，看起来是不是很像大写的字符A ？？？
  40. */
  41. const unsigned char oled_asc2_8x16[95][16]=
  42. {
  43.     {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},// 0 数组下标 = 对应字符的asc2码 - 空格的asc码
  44.     {0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x30,0x00,0x00,0x00},//!1
  45.     {0x00,0x10,0x0C,0x06,0x10,0x0C,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},//






阅读(1110) | 评论(0) | 转发(0) |
0

上一篇：DMA 驱动

下一篇：I2C总线学习—查缺补漏—对数据有效性的思考

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6