gpio模拟I2C

开发中经常与i2c打交道，芯片中自带的硬件i2c控制器使用起来并不是很灵活，而且要研究半天的寄存器。所以干脆搞一个软件模拟gpio的通用代码，移植起来也方便，使用灵活

具体代码如下：

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/config.h>
   
4. #include <linux/errno.h>
   
5. #include <linux/miscdevice.h>
   
6. #include <linux/fcntl.h>
   
7. #include <linux/init.h>
   
8. #include <linux/delay.h>
   
9. #include <linux/version.h>
   
10. #include <linux/kernel.h>   
    
11. #include <linux/fs.h>      
    
12. #include <linux/types.h>   
    
13. #include <linux/proc_fs.h>
    
14. #include <asm/uaccess.h>
    
15. #include <asm/system.h>
    
16. #include <asm/rt2880/rt_mmap.h>
    
17. #include <asm/system.h>   
    
18. 
    
19. #include <asm/io.h>
    
20. 
    
21. #include "gpio_i2c.h"
    
22. #include "../ralink_gpio.h"
    
23. 
    
24. 
    
25. #define DELAY(u)                udelay(u*100)
    
26. 
    
27. #define RT2860REG(addr) (*(volatile u32 *)(addr))
    
28. 
    
29. static void gpio_i2c_set_bit(int id, int onoff)
    
30. {       
    
31.         int tmp;
    
32. 
    
33.         if(id<=21&&id>=0)
    
34.         {
    
35.                 tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIODIR));
    
36.                 tmp |= (1<<(id));
    
37.                 *(volatile u32 *)(RALINK_REG_PIODIR) = tmp;
    
38. 
    
39. 
    
40.                 tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIODATA));
    
41.                 tmp = (tmp&~(1<<(id)))|(onoff<<(id));
    
42.                 *(volatile u32 *)(RALINK_REG_PIODATA) = tmp;
    
43.         }
    
44.         else if(id>=22&&id<=27)
    
45.         {
    
46.                 tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIO2722DIR));
    
47.                 tmp |= (1<<(id-22));
    
48.                 *(volatile u32 *)(RALINK_REG_PIO2722DIR) = tmp;
    
49. 
    
50. 
    
51.                 tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIO2722DATA));
    
52.                 tmp = (tmp&~(1<<(id-22)))|(onoff<<(id-22));
    
53.                 *(volatile u32 *)(RALINK_REG_PIO2722DATA) = tmp;
    
54.         }
    
55.         else
    
56.         {
    
57.                 printk("####HU#### %s id %d invalid \r\n",__FUNCTION__,id);
    
58.         }
    
59. }
    
60. 
    
61. static int gpio_i2c_get_bit(int id)
    
62. {       
    
63.         int tmp;
    
64. 
    
65.         if(id<=21&&id>=0)
    
66.         {
    
67.                 tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIODIR));
    
68.                 tmp &= ~(1<<(id));
    
69.                 *(volatile u32 *)(RALINK_REG_PIODIR) = tmp;
    
70. 
    
71. 
    
72.                 tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIODATA));
    
73.                 return (tmp>>id&0x01);
    
74.         }
    
75.         else if(id>=22&&id<=27)
    
76.         {
    
77.                 tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIO2722DIR));
    
78.                 tmp &= ~(1<<(id-22));
    
79.                 *(volatile u32 *)(RALINK_REG_PIO2722DIR) = tmp;
    
80. 
    
81. 
    
82.                 tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIO2722DATA));
    
83.                 return (tmp>>(id-22)&0x01);
    
84.         }
    
85.         else
    
86.         {
    
87.                 printk("####HU#### %s id %d invalid \r\n",__FUNCTION__,id);
    
88.         }
    
89. }
    
90. 
    
91. static void i2c_clk(int onoff)
    
92. {       
    
93.         gpio_i2c_set_bit(2,onoff);
    
94.        
    
95. }
    
96. 
    
97. static void i2c_dat(int onoff)
    
98. {       
    
99.         gpio_i2c_set_bit(1,onoff);
    
100.        
     
101. }
     
102. 
     
103. 
     
104. 
     
105. 
     
106. static unsigned char i2c_data_read(void)
     
107. {
     
108. //        unsigned char tmp;
     
109.        
     
110. //        tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIODIR));
     
111. //        tmp &= ~(1<<(1));
     
112. //        *(volatile u32 *)(RALINK_REG_PIODIR) = tmp;
     
113. //               
     
114. //        //DELAY(1);
     
115. //               
     
116. //        tmp = le32_to_cpu(*(volatile u32 *)(RALINK_REG_PIODATA));
     
117. //        if((tmp&(1<<1)) ！= 0)
     
118. //                return 1;
     
119. //        else
     
120. //                return 0;
     
121. 
     
122.         return gpio_i2c_get_bit(1);
     
123. }
     
124. 
     
125. 
     
126. 
     
127. /*
     
128. * sends a start bit via I2C rountine.
     
129. *
     
130. */
     
131. static void i2c_start_bit(void)
     
132. {
     
133.         DELAY(1);
     
134.         i2c_clk(1);
     
135.                 i2c_dat(1);
     
136.         DELAY(1);
     
137.         i2c_dat(0);
     
138.         DELAY(1);
     
139. }
     
140. 
     
141. /*
     
142. * sends a stop bit via I2C rountine.
     
143. *
     
144. */
     
145. static void i2c_stop_bit(void)
     
146. {
     
147.       
     
148.                 i2c_clk(0);
     
149.         i2c_dat(1);
     
150.         DELAY(1);
     
151.                 i2c_clk(1);
     
152. }
     
153. 
     
154. /*
     
155. * sends a character over I2C rountine.
     
156. *
     
157. * @param  c: character to send
     
158. *
     
159. */
     
160. static void i2c_send_byte(unsigned char c)
     
161. {
     
162.     int i;
     
163.     local_irq_disable();
     
164.         //i2c_clk(1);
     
165.     for (i=0; i<8; i++)
     
166.     {
     
167.         i2c_clk(0);
     
168.                 if (c & (1<<(7-i)))
     
169.             i2c_dat(1);
     
170.         else
     
171.             i2c_dat(0);
     
172.                
     
173.         DELAY(1);
     
174.                
     
175.                 i2c_clk(1);
     
176.                 DELAY(1);
     
177.     }
     
178.    // i2c_dat(1);
     
179.     local_irq_enable();
     
180. }
     
181. 
     
182. /*  receives a character from I2C rountine.
     
183. *
     
184. *  [url=home.php?mod=space&uid=1141835]@Return[/url] value: character received
     
185. *
     
186. */
     
187. static unsigned char i2c_receive_byte(void)
     
188. {
     
189.     int j=0;
     
190.     int i;
     
191.     unsigned char regvalue;
     
192. 
     
193.     local_irq_disable();
     
194. 
     
195.         i2c_data_read();
     
196.     for (i=0; i<8; i++)
     
197.     {
     
198.         i2c_clk(0);
     
199.                 DELAY(1);
     
200. 
     
201.                 i2c_clk(1);
     
202.                
     
203.                 i2c_data_read();
     
204.         if (i2c_data_read())
     
205.             j+=(1<<(7-i));
     
206.                
     
207.         DELAY(1);
     
208.                
     
209.                
     
210.     }
     
211.     local_irq_enable();
     
212.    // i2c_dat(0);
     
213.    // DELAY(1);
     
214. 
     
215.     return j;
     
216. }
     
217. 
     
218. /*  receives an acknowledge from I2C rountine.
     
219. *
     
220. *  @return value: 0--Ack received; 1--Nack received
     
221. *         
     
222. */
     
223. static int i2c_receive_ack(void)
     
224. {
     
225.     int nack;
     
226.    
     
227.     i2c_data_read();
     
228.     i2c_clk(0);
     
229.     DELAY(1);
     
230.         i2c_clk(1);
     
231.        
     
232.         i2c_data_read();
     
233.         nack = i2c_data_read();
     
234.     DELAY(1);
     
235. 
     
236.         i2c_dat(1);
     
237. 
     
238.     if (nack == 0)
     
239.         return 1;
     
240. 
     
241.     return 0;
     
242. }
     
243. 
     
244. /*
     
245. * sends an acknowledge over I2C rountine.
     
246. *
     
247. */
     
248. static void i2c_send_ack(void)
     
249. {
     
250.     i2c_clk(0);
     
251.         i2c_dat(0);
     
252.     DELAY(1);
     
253.        
     
254.     i2c_clk(1);
     
255.         DELAY(1);
     
256.        
     
257. }
     
258. 
     
259. static void si2c_init()
     
260. {
     
261.         RT2860REG(RALINK_REG_GPIOMODE)=RT2860REG(RALINK_REG_GPIOMODE)|(1<<0);
     
262. }
     
263. 
     
264. static void si2c_exit()
     
265. {
     
266.        
     
267. }
     
268. 
     
269. 
     
270. 
     
271. /*  
     
272. *  read data from the I2C bus by GPIO simulated of a device rountine.
     
273. *
     
274. *  @param  devaddress:  address of the device
     
275. *  @param  address: address of register within device
     
276. *   
     
277. *  @return value: data from the device readed
     
278. *
     
279. */
     
280. unsigned char gpio_i2c_read(unsigned char devaddress, unsigned char address)
     
281. {
     
282.     int rxdata;
     
283. 
     
284.         si2c_init();
     
285.        
     
286.     i2c_start_bit();
     
287.     i2c_send_byte((unsigned char)((devaddress<<1)|0));
     
288.     i2c_receive_ack();
     
289.     i2c_send_byte(address);
     
290.     i2c_receive_ack();   
     
291.     i2c_start_bit();
     
292.     i2c_send_byte((unsigned char)((devaddress<<1)|1));
     
293.     i2c_receive_ack();
     
294.     rxdata = i2c_receive_byte();
     
295.     i2c_send_ack();
     
296.     i2c_stop_bit();
     
297.        
     
298.         si2c_exit();
     
299.     return rxdata;
     
300. }
     
301. EXPORT_SYMBOL(gpio_i2c_read);
     
302. 
     
303. 
     
304. /*
     
305. *  writes data to a device on the I2C bus rountine.
     
306. *
     
307. *  @param  devaddress:  address of the device
     
308. *  @param  address: address of register within device
     
309. *  @param  data:   data for write to device
     
310. *
     
311. */
     
312. 
     
313. void gpio_i2c_write(unsigned char devaddress, unsigned char address, unsigned char data)
     
314. {
     
315.         si2c_init();
     
316.        
     
317.     i2c_start_bit();
     
318.     i2c_send_byte((unsigned char)((devaddress<<1)|0));
     
319.     i2c_receive_ack();
     
320.     i2c_send_byte(address);
     
321.     i2c_receive_ack();
     
322.     i2c_send_byte(data);
     
323.            i2c_receive_ack();
     
324.     i2c_stop_bit();
     
325. 
     
326.            si2c_exit();
     
327. }
     
328. EXPORT_SYMBOL(gpio_i2c_write);
     
329. 
     
330. 
     
331. 
     
332. 
     
333. 
     
334. 
     
335. 
     
336. 
     
337. 
     
338. 
     
339. /*
     
340. * initializes I2C interface routine.
     
341. *
     
342. * @return value:0--success; 1--error.
     
343. *
     
344. */
     
345. static int __init gpio_i2c_init(void)
     
346. {
     
347. 
     
348. }
     
349. 
     
350. static void __exit gpio_i2c_exit(void)
     
351. {
     
352.        
     
353. }
     
354. 
     
355. module_init(gpio_i2c_init);
     
356. module_exit(gpio_i2c_exit);
     
357. 
     
358. #ifdef MODULE
     
359. #include <linux/compile.h>
     
360. #endif
     
361. MODULE_INFO(build, UTS_VERSION);
     
362. MODULE_LICENSE("GPL");
     
363. MODULE_VERSION("HI_VERSION=" OSDRV_MODULE_VERSION_STRING);
     

复制代码

gpio_i2c_set_bit与gpio_i2c_get_bit设置gpio高低的，DELAY宏为延时方法，理论只要实现这几个值就能够实现标准的gpio_i2c的功能了