【OK210试用体验】之eeprom驱动

罗崇军 当前离线 经验 168 窥视卡 雷达卡

罗崇军 ( 楼主 ) 2015-8-21 00:03:59  只看该作者 3164 | 1 倒序浏览

这俩天，趁着闲出来的时间做了eeprom的实验，自己写了eeprom的驱动，在这里与大家分享。
版本说明：
               平台：OK210；
                os ：Linux2.6.35.7
                驱动类型：eeprom

驱动程序如下：

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. #include
   
9. #include
   
10. #include
    
11. #include
    
12. 
    
13. #define CHARDEVICEDRIVER_MAJOR                0
    
14. #define CHARDEVICEDRIVER_MINOR                0
    
15. 
    
16. struct at24cxx_dev
    
17. {
    
18.         struct device *dev_device;
    
19.         struct i2c_client *client;
    
20.         struct cdev cdev;
    
21. };
    
22. 
    
23. struct at24cxx_dev *at24cxx_devp = NULL;
    
24. static struct class *dev_class = NULL;
    
25. static u32 chardevicedriver_major = CHARDEVICEDRIVER_MAJOR;
    
26. static u32 chardevicedriver_minor = CHARDEVICEDRIVER_MINOR;
    
27. 
    
28. 
    
29. 
    
30. static const struct i2c_device_id at24cxx_id[] = {
    
31.     {"at24cxx", 0 }, //该i2c_driver所支持的i2c_client
    
32.     {}
    
33. };
    
34. MODULE_DEVICE_TABLE(i2c,at24cxx_id);
    
35. 
    
36. 
    
37. static ssize_t at24cxx_read(struct file *file, char __user *buf, size_t size, loff_t * offset)
    
38. {
    
39.         unsigned char address;
    
40.         unsigned char data;
    
41.         struct i2c_msg msg[2];
    
42.         int ret;
    
43.         
    
44.         /* address = buf[0]
    
45.          * data    = buf[1]
    
46.          */
    
47.         if (size != 1)
    
48.                 return -EINVAL;
    
49.         
    
50.         copy_from_user(&address, buf, 1);
    
51. 
    
52.         /* 数据传输三要素: 源,目的,长度 */
    
53. 
    
54.         /* 读AT24CXX时,要先把要读的存储空间的地址发给它 */
    
55.         msg[0].addr  = at24cxx_devp->client->addr;  /* 目的 */
    
56.         msg[0].buf   = &address;              /* 源 */
    
57.         msg[0].len   = 1;                     /* 地址=1 byte */
    
58.         msg[0].flags = 0;                     /* 表示写 */
    
59. 
    
60.         /* 然后启动读操作 */
    
61.         msg[1].addr  = at24cxx_devp->client->addr;  /* 源 */
    
62.         msg[1].buf   = &data;                 /* 目的 */
    
63.         msg[1].len   = 1;                     /* 数据=1 byte */
    
64.         msg[1].flags = I2C_M_RD;                     /* 表示读 */
    
65. 
    
66. 
    
67.         ret = i2c_transfer(at24cxx_devp->client->adapter, msg, 2);
    
68.         if (ret == 2)
    
69.         {
    
70.                 copy_to_user(buf, &data, 1);
    
71.                 return 1;
    
72.         }
    
73.         else
    
74.                 return -EIO;
    
75. }
    
76. 
    
77. static ssize_t at24cxx_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
    
78. {
    
79.         unsigned char val[2];
    
80.         struct i2c_msg msg[1];
    
81.         int ret;
    
82.         
    
83.         /* address = buf[0]
    
84.          * data    = buf[1]
    
85.          */
    
86.         if (size != 2)
    
87.                 return -EINVAL;
    
88.         
    
89.         copy_from_user(val, buf, 2);
    
90. 
    
91.         /* 数据传输三要素: 源,目的,长度 */
    
92.         msg[0].addr  = at24cxx_devp->client->addr;  /* 目的 */
    
93.         msg[0].buf   = val;                   /* 源 */
    
94.         msg[0].len   = 2;                     /* 地址+数据=2 byte */
    
95.         msg[0].flags = 0;                     /* 表示写 */
    
96. 
    
97.         ret = i2c_transfer(at24cxx_devp->client->adapter, msg, 1);
    
98.         if (ret == 1)
    
99.                 return 2;
    
100.         else
     
101.                 return -EIO;
     
102. }
     
103. 
     
104. 
     
105. 
     
106. static struct file_operations at24cxx_fops = {
     
107.         .owner        = THIS_MODULE,
     
108.         //.open        = chardevicedriver_open,
     
109.         .read        = at24cxx_read,
     
110.         .write        = at24cxx_write,
     
111.         //.ioctl        = chardevicedriver_ioctl,
     
112.         //.release= chardevicedriver_release,
     
113. };
     
114. 
     
115. // add one cdev and create one device file
     
116. static int chardevicedriver_cdev_add(struct at24cxx_dev *pcdevp, int index)
     
117. {
     
118.         int ret = -EFAULT;
     
119.         dev_t dev = 0;
     
120. 
     
121.         // add cdev object
     
122.         dev = MKDEV( chardevicedriver_major, chardevicedriver_minor + index );
     
123.         cdev_init( &(pcdevp->cdev), &at24cxx_fops);
     
124.         ret = cdev_add( &(pcdevp->cdev), dev, 1 );
     
125. 
     
126. 
     
127.         // create device
     
128.         pcdevp->dev_device = device_create( dev_class, NULL, dev, NULL, "at24cxx%d", MINOR( dev ) );
     
129.         
     
130.         
     
131.         return 0;
     
132. }
     
133. 
     
134. 
     
135. static int at24cxx_probe(struct i2c_client *client, const struct i2c_device_id *id)
     
136. {
     
137.         int ret;
     
138.         dev_t dev = 0;
     
139. 
     
140.         // register device number
     
141.         if( chardevicedriver_major ) { // static device number
     
142.                 dev = MKDEV( chardevicedriver_major, chardevicedriver_minor );
     
143.                 ret = register_chrdev_region( dev, 1, "at24cxx" );
     
144.         }
     
145.         else { // dynamic device number
     
146.                 ret = alloc_chrdev_region( &dev, chardevicedriver_minor, 1, "at24cxx" );
     
147.                 chardevicedriver_major = MAJOR( dev );
     
148.         }
     
149.         
     
150.         at24cxx_devp = kmalloc( sizeof( struct at24cxx_dev ), GFP_KERNEL );
     
151. 
     
152.         memset(at24cxx_devp, 0, sizeof(struct at24cxx_dev));
     
153.         at24cxx_devp->client = client;
     
154.         
     
155.         dev_class = class_create( THIS_MODULE, "at24cxx" );
     
156. 
     
157.         
     
158.         chardevicedriver_cdev_add(at24cxx_devp,0);
     
159.         
     
160.         return 0;
     
161. }
     
162. 
     
163. static int __devexit at24cxx_remove(struct i2c_client *client)
     
164. {
     
165.         device_destroy( dev_class, MKDEV( chardevicedriver_major, 0 ) );
     
166. 
     
167.         cdev_del( &( at24cxx_devp->cdev ) );
     
168.         
     
169.         // destroy device class
     
170.         class_destroy( dev_class );
     
171.         // free memory for private struct
     
172.         kfree( at24cxx_devp );
     
173.         at24cxx_devp = NULL;
     
174. 
     
175.         // unregister device number
     
176.         unregister_chrdev_region( MKDEV( chardevicedriver_major, chardevicedriver_minor ), 1 );
     
177.         return 0;
     
178. }
     
179. 
     
180. /* 1. 分配一个i2c_driver结构体 */
     
181. /* 2. 设置i2c_driver结构体 */
     
182. static struct i2c_driver at24cxx_driver = {
     
183.         .driver = {
     
184.                 .name        = "at24cxx",
     
185.                 .owner = THIS_MODULE,
     
186.         },
     
187.         .probe=at24cxx_probe,
     
188.         .remove=__devexit_p(at24cxx_remove),
     
189.         .id_table=at24cxx_id,
     
190. };
     
191. 
     
192. static int __init at24cxx_init(void)
     
193. {
     
194.         i2c_add_driver(&at24cxx_driver);
     
195.         return 0;
     
196. }
     
197. 
     
198. static void __exit at24cxx_exit(void)
     
199. {
     
200.         i2c_del_driver(&at24cxx_driver);
     
201. }
     
202. 
     
203. module_init(at24cxx_init);
     
204. module_exit(at24cxx_exit);
     
205. 
     
206. MODULE_LICENSE("GPL");
     

复制代码

makefile文件如下

1. all:
   
2.         make -C $(SRC_PATH)/kernel M=`pwd` modules
   
3.         cp at24cxx.ko $(SRC_PATH)/system/modules/ -av
   
4. clean:
   
5.         make -C $(SRC_PATH)/kernel M=`pwd` modules clean
   
6.         rm -rf modules.order *.o *.ko *.mod.* Module.*
   
7. 
   
8. obj-m        += at24cxx.o
   

复制代码

测试程序如下

1. 
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. 
   
9. 
   
10. /* i2c_test r addr
    
11. * i2c_test w addr val
    
12. */
    
13. 
    
14. void print_usage(char *file)
    
15. {
    
16.         printf("%s r addrn", file);
    
17.         printf("%s w addr valn", file);
    
18. }
    
19. 
    
20. int main(int argc, char **argv)
    
21. {
    
22.         int fd;
    
23.         unsigned char buf[2];
    
24.         
    
25.         if ((argc != 3) && (argc != 4))
    
26.         {
    
27.                 print_usage(argv[0]);
    
28.                 return -1;
    
29.         }
    
30. 
    
31.         fd = open("/dev/at24cxx0", O_RDWR);
    
32.         if (fd < 0)
    
33.         {
    
34.                 printf("can't open /dev/at24cxxn");
    
35.                 return -1;
    
36.         }
    
37. 
    
38.         if (strcmp(argv[1], "r") == 0)
    
39.         {
    
40.                 buf[0] = strtoul(argv[2], NULL, 0);
    
41.                 read(fd, buf, 1);
    
42.                 printf("data: %c, %d, 0x%2xn", buf[0], buf[0], buf[0]);
    
43.         }
    
44.         else if (strcmp(argv[1], "w") == 0)
    
45.         {
    
46.                 buf[0] = strtoul(argv[2], NULL, 0);
    
47.                 buf[1] = strtoul(argv[3], NULL, 0);
    
48.                 write(fd, buf, 2);
    
49.         }
    
50.         else
    
51.         {
    
52.                 print_usage(argv[0]);
    
53.                 return -1;
    
54.         }
    
55.         
    
56.         return 0;
    
57. }
    

复制代码

连续发了好几篇驱动程序，还有大概俩个实验，就准备发项目的了，由于我也是初学者，程序中难免有错误和bug，还请各位i大神多多包涵。

沙发

低调de炫耀爱 发表于 2015-8-21 10:46:20

七夕的深夜还在默默的写试用体验 也是蛮拼的啊 加油加油