自己写的GPIO模拟I2C驱动

pauloxu

这个可以算是我来到新公司写的第一个驱动吧，在之前公司写过spi的驱动，这个跟spi比较类似，只不过只有两跟线，scl(时钟)和sda(数据)，写的时候有代码参照，just easy job,调试的时候也只碰到几个小障碍：

1. iic_write的时候漏了一个i2c_start（），造成写入时序不正确，这时可以通过示波器抓波形查出来，波形中在sda改变输入输出方向时会出现一些毛刺，属正常现象，数据改变发生在scl为低的时候。

2.i2c_simu_read_byte的时候数据移位和取bit值的的顺序搞反了，应该是先移位，再取值！道理很简单，第一次移位是无效值，最后那次移位是有效值

3.GPIO pin角属性定义，当时是sfp设备不能scan到，但其他I2C设备正常，里面代码都是一样的，还是叶大师提醒才去看了连到sfp上的pin角属性定义，发现这些pin被定义成非GPIO的了，那当然是不行啦！

下面是正确属性值：

/* I2c BUS */
/*PA0 */ {PORTA,  0, IO_OUT,   0, GPIO,  1},/* SFP0_SCL */
/*PA1 */ {PORTA,  1, IO_OUT,   0, GPIO,  1},/*SFP0_SDA */
/*PA2 */ {PORTA,  2, IO_OUT,   0  , GPIO,  1},/*SFP1_SCL */
/*PA4 */ {PORTA,  4, IO_OUT,   0  , GPIO,  1},/*SFP1_SDA */
/*PA5 */ {PORTA,  5, IO_OUT,   0  , GPIO,  1},/*CPU_SCL */
/*PA6 */ {PORTA,  6, IO_OUT,   0  , GPIO,  1},/*CPU_SDA */

 

一。先上王道：

二.GPIO pin 定义

PA0		GPI	F0_SCL
PA1		GPI	F0_SDA
PA2		GPI	F1_SCL
PA4		GPI	F1_SDA
PA5		GPI	GPIO CPU_SCK
PA6		GPI	GPIO CPU_SDA

 

 

 

 

 

 

 

 

三源代码

1,i2cbussimu.c

1. /**********************************************************************************
   
2. Module:
   
3.     i2cbussimu.c
   
4. 
   
5. History:
   
6.     xu xinlin created in 2011.3.7
   
7. 
   
8. Description:
   
9.     This file define the interface to operate I2C, simulated by GPIO.
   
10. ***********************************************************************************/
    
11. 
    
12. #include <vxWorks.h>
    
13. #include <string.h>
    
14. #include "immap_83xx.h"
    
15. #include "rdb8323.h"
    
16. #include "gpio.h"
    
17. #include "i2cbussimu.h"
    
18. #include "i2cDevices.h"
    
19. 
    
20. extern void sysUsDelay(int delay);
    
21. #define i2c_debug 0
    
22. #define i2c_printf(fmt,arg...) {if(i2c_debug)printf(fmt,##arg);}
    
23. #define I2CBUS_FREN (85937) /* Hz */
    
24. #define I2CBUS_CYCLE ((1000000+I2CBUS_FREN)/I2CBUS_FREN) /* In Us */
    
25. #define BYTE_TRANSFER_TIME (I2CBUS_CYCLE*15) /* I2CBUS_CYCLE * 9 */
    
26. #define BYTE_TRANSFER_TIME2 (I2CBUS_CYCLE*50) /* I2CBUS_CYCLE * 9 */
    
27. 
    
28. #define I2CDELAY     sysUsDelay(I2CBUS_CYCLE/4)
    
29. 
    
30. const UINT8 aI2cDevAddr[] =
    
31. {
    
32.                          /* i2c line 0 */
    
33.     /*I2C_MB_EEPROM */ 0xAE, /* 0 device number for eeprom in main board */
    
34.     /*I2C_PM_SENSOR */ 0x30, /* 1 Thermal Sensor for Power module */
    
35.     /*I2C_CPU_SENSOR */ 0x98, /* 2 Thermal Sensor for CPU */
    
36.     /*I2C_AD */ 0x90, /* 3 A/D ADS7830IPWR */
    
37.     /*I2C_ZL30142 */ 0xCE, /* 4 ZL30142 */
    
38.     
    
39.                        /* i2c line 1 */
    
40.     /*I2C_SFP0_EL */ 0xA0, /* 5 SFP0 electric port*/
    
41.     /*I2C_SFP0_FB */ 0xA2, /* 6 SFP0 fiber port */
    
42.     
    
43.                         /* i2c line 2 */
    
44.     /*I2C_SFP1_EL */ 0xA0, /* 7 SFP1 electric port */
    
45.     /*I2C_SFP1_FB */ 0xA2, /* 8 SFP1 fiber port */
    
46. };
    
47. 
    
48. 
    
49. /* Proto definition */
    
50. LOCAL void      SDA_OUTPUT_ACTIVE(struct i2c_simu_dev i2c_dev);
    
51. LOCAL void SDA_OUTPUT_ACTIVE(struct i2c_simu_dev i2c_dev);
    
52. LOCAL void SDA_INPUT_ACTIVE(struct i2c_simu_dev i2c_dev);
    
53. LOCAL void SCL_OUTPUT_ACTIVE(struct i2c_simu_dev i2c_dev);
    
54. LOCAL void SCL_INPUT_ACTIVE(struct i2c_simu_dev i2c_dev);
    
55. LOCAL void SCL_WRITE(struct i2c_simu_dev i2c_dev, UINT8 bitval);
    
56. LOCAL STATUS SCL_READ(struct i2c_simu_dev i2c_dev);
    
57. LOCAL void SDA_WRITE(struct i2c_simu_dev i2c_dev, UINT8 bitval);
    
58. LOCAL STATUS SDA_READ(struct i2c_simu_dev i2c_dev);
    
59. LOCAL STATUS i2c_start(struct i2c_simu_dev i2c_dev);
    
60. LOCAL void i2c_stop(struct i2c_simu_dev i2c_dev);
    
61. LOCAL STATUS receive_i2c_ack(struct i2c_simu_dev i2c_dev);
    
62. LOCAL STATUS send_i2c_ack(struct i2c_simu_dev i2c_dev);
    
63. LOCAL STATUS send_i2c_nack(struct i2c_simu_dev i2c_dev);
    
64. LOCAL STATUS i2c_simu_read_byte (struct i2c_simu_dev i2c_dev, UINT8 *data,UINT32 length);
    
65. LOCAL STATUS i2c_simu_write_byte (struct i2c_simu_dev i2c_dev, UINT8 writeData);
    
66. LOCAL STATUS i2c_stat_check(struct i2c_simu_dev i2c_dev);
    
67. 
    
68. LOCAL void SDA_OUTPUT_ACTIVE(struct i2c_simu_dev i2c_dev)
    
69. {
    
70.     volatile immap_t * immr =(immap_t *)CCSBAR;
    
71.     immr->qepio.ioport[i2c_dev.port].dir1 &= ~(0x80000000 >> (i2c_dev.sda<<1));
    
72.     immr->qepio.ioport[i2c_dev.port].dir1 |= (0x80000000 >> ((i2c_dev.sda<<1) + 1));
    
73.     
    
74. }
    
75. 
    
76. LOCAL void SDA_INPUT_ACTIVE(struct i2c_simu_dev i2c_dev)
    
77. {
    
78.     volatile immap_t * immr =(immap_t *)CCSBAR;
    
79.     immr->qepio.ioport[i2c_dev.port].dir1 &= ~(0x80000000 >> ((i2c_dev.sda<<1) + 1));
    
80.     immr->qepio.ioport[i2c_dev.port].dir1 |= (0x80000000 >> (i2c_dev.sda<<1));
    
81. }
    
82. 
    
83. LOCAL void SCL_OUTPUT_ACTIVE(struct i2c_simu_dev i2c_dev)
    
84. {
    
85.     volatile immap_t * immr =(immap_t *)CCSBAR;
    
86.     immr->qepio.ioport[i2c_dev.port].dir1 &= ~(0x80000000 >> (i2c_dev.scl<<1));
    
87.     immr->qepio.ioport[i2c_dev.port].dir1 |= (0x80000000 >> ((i2c_dev.scl<<1) + 1));
    
88. }
    
89. 
    
90. LOCAL void SCL_INPUT_ACTIVE(struct i2c_simu_dev i2c_dev)
    
91. {
    
92.     volatile immap_t * immr =(immap_t *)CCSBAR;
    
93.     immr->qepio.ioport[i2c_dev.port].dir1 &= ~(0x80000000 >> ((i2c_dev.scl<<1) + 1));
    
94.     immr->qepio.ioport[i2c_dev.port].dir1 |= (0x80000000 >> (i2c_dev.scl<<1));
    
95. }
    
96. 
    
97. 
    
98. LOCAL void SCL_WRITE(struct i2c_simu_dev i2c_dev, UINT8 bitval)
    
99. {    
    
100.     volatile immap_t * immr =(immap_t *)CCSBAR;
     
101.     if(bitval)
     
102.         immr->qepio.ioport[i2c_dev.port].pdat |= 0x80000000 >> i2c_dev.scl;
     
103.     else
     
104.         immr->qepio.ioport[i2c_dev.port].pdat &= ~(0x80000000>> i2c_dev.scl);
     
105. }
     
106. 
     
107. LOCAL STATUS SCL_READ(struct i2c_simu_dev i2c_dev)
     
108. {    
     
109.     volatile immap_t * immr =(immap_t *)CCSBAR;
     
110.     return (((immr->qepio.ioport[i2c_dev.port].pdat) & (0x80000000 >> i2c_dev.scl)) != 0);
     
111. }
     
112. 
     
113. LOCAL void SDA_WRITE(struct i2c_simu_dev i2c_dev, UINT8 bitval)
     
114. {    
     
115.     volatile immap_t * immr =(immap_t *)CCSBAR;
     
116.     if(bitval)
     
117.         immr->qepio.ioport[i2c_dev.port].pdat |= 0x80000000 >> i2c_dev.sda;
     
118.     else
     
119.         immr->qepio.ioport[i2c_dev.port].pdat &= ~(0x80000000>> i2c_dev.sda);
     
120. }
     
121. 
     
122. 
     
123. LOCAL STATUS SDA_READ(struct i2c_simu_dev i2c_dev)
     
124. {    
     
125.     volatile immap_t * immr =(immap_t *)CCSBAR;
     
126.     return (((immr->qepio.ioport[i2c_dev.port].pdat) & (0x80000000 >> i2c_dev.sda)) != 0);
     
127.         
     
128. }
     
129. 
     
130. 
     
131. /* -------------------------------------------------------------------------*
     
132.  * Function : i2cDrvInit *
     
133.  * Description: i2c device initial, configure i2c port/pin *
     
134.  * Parameters : i2c device structure & device number *
     
135.  * Return : OK if i2c start successfully,or I2C_ERROR_UNKNOW_DEVICE *
     
136.  * -------------------------------------------------------------------------*/
     
137. STATUS i2cDrvInit(UINT8 devNum,struct i2c_simu_dev *i2c_dev)
     
138. {
     
139.     /*****************************************************
     
140.     PA0--->F0_SCL
     
141.     PA1--->F0_SDA :SFP0
     
142.     
     
143.     PA2--->F1_SCL
     
144.     PA4--->F1_SDA :SFP1    
     
145. 
     
146.     PA5--->CPU_SCL
     
147.     PA6--->CPU_SDA :I2C_MB_EEPROM,I2C_PM_SENSOR,I2C_CPU_SENSOR,I2C_AD,I2C_ZL30142
     
148.     ******************************************************/
     
149.     if ((devNum <= I2C_ZL30142) && (devNum >= I2C_MB_EEPROM))
     
150.     {
     
151.         i2c_dev->port = 0;
     
152.         i2c_dev->scl = 5;
     
153.         i2c_dev->sda = 6;
     
154.     }
     
155.     else if ((devNum <= I2C_SFP0_FB) && (devNum >= I2C_SFP0_EL))
     
156.     {
     
157.         i2c_dev->port = 0;
     
158.         i2c_dev->scl = 0;
     
159.         i2c_dev->sda = 1;
     
160.     }
     
161.     else if ((devNum <= I2C_SFP1_FB) && (devNum >= I2C_SFP1_EL))
     
162.     {
     
163.         i2c_dev->port = 0;
     
164.         i2c_dev->scl = 2;
     
165.         i2c_dev->sda = 4;        
     
166.     }
     
167.     else
     
168.     {
     
169.         return I2C_ERROR_UNKNOW_DEVICE;
     
170.     }
     
171.     /* Get the device address */
     
172.     i2c_dev->i2cDevAddr = aI2cDevAddr[devNum];
     
173.     /* set sda&scl output mode */
     
174.     SCL_OUTPUT_ACTIVE(*i2c_dev);
     
175.     SDA_OUTPUT_ACTIVE(*i2c_dev);
     
176.     /* pull sda&scl high */
     
177.     SDA_WRITE(*i2c_dev, 1);
     
178.     SCL_WRITE(*i2c_dev, 1);        
     
179.     return OK;    
     
180. }
     
181. 
     
182. 
     
183. /* -------------------------------------------------------------------------*
     
184.  * Function : i2c_stat_check *
     
185.  * Description: restore I2C bus from dead lock by sending 9 clocks pusle *
     
186.  * Parameters : i2c device structure *
     
187.  * Return : OK if i2c start successfully,or I2C_ERROR_TIME_OUT *
     
188.  * -------------------------------------------------------------------------*/
     
189. LOCAL STATUS i2c_stat_check(struct i2c_simu_dev i2c_dev)
     
190. {
     
191.     UINT32 j = 0;             /* counter */
     
192.     
     
193.     /* check scl&sda status,if it's low ,send 9 clocks pusle to restore it */
     
194.     if((!SDA_READ(i2c_dev)) || (!SCL_READ(i2c_dev)))
     
195.     {
     
196.         SDA_INPUT_ACTIVE (i2c_dev);
     
197.         for (j=0; j<9; j++)
     
198.         {
     
199.             SCL_WRITE(i2c_dev, 0); /* pull SCL low */
     
200.             I2CDELAY;
     
201.             I2CDELAY;
     
202.             SCL_WRITE(i2c_dev, 1); /* pull SCL high */
     
203.             I2CDELAY;
     
204.             I2CDELAY;
     
205.         }    
     
206.         i2c_stop(i2c_dev);
     
207.         SDA_INPUT_ACTIVE (i2c_dev);        
     
208.     }
     
209.     return OK;
     
210. }
     
211. 
     
212. 
     
213. 
     
214. /* -------------------------------------------------------------------------*
     
215.  * Function : i2c_start *
     
216.  * Description: SDA change from high to low when SCL keep in high. *
     
217.  * Parameters : i2c device structure *
     
218.  * Return : OK if i2c start successfully,or I2C_ERROR_TIME_OUT *
     
219.  * -------------------------------------------------------------------------*/
     
220. LOCAL STATUS i2c_start(struct i2c_simu_dev i2c_dev)
     
221. {
     
222.     I2CDELAY;
     
223.     SDA_WRITE (i2c_dev, 1); /* pull SDA high */
     
224.     SDA_OUTPUT_ACTIVE(i2c_dev); /* driver GPIO direction:output */
     
225.     I2CDELAY;
     
226.     SCL_WRITE(i2c_dev, 1); /* pull SCL high */
     
227.     I2CDELAY;        
     
228.     SDA_WRITE (i2c_dev, 0); /* pull SDA low */
     
229.     I2CDELAY;        
     
230.     return OK;
     
231. }
     
232. 
     
233. 
     
234. /* -------------------------------------------------------------------------*
     
235.  * Function : i2c_stop *
     
236.  * Description: SDA change from low to high when SCL keep in high. *
     
237.  * Parameters : i2c device structure *
     
238.  * Return : NULL                                                 *
     
239.  * -------------------------------------------------------------------------*/
     
240. void i2c_stop(struct i2c_simu_dev i2c_dev)
     
241. {
     
242.     SCL_WRITE(i2c_dev, 0); /* pull SCL low */
     
243.     I2CDELAY;
     
244.     SDA_WRITE (i2c_dev, 0); /* pull SDA low */
     
245.     SDA_OUTPUT_ACTIVE(i2c_dev); /* driver GPIO direction:output */
     
246.     I2CDELAY;
     
247.     SCL_WRITE (i2c_dev, 1); /* pull SCL high */
     
248.     I2CDELAY;
     
249.     SDA_WRITE (i2c_dev, 1); /* pull SDA high */
     
250.     I2CDELAY;
     
251.     SDA_INPUT_ACTIVE(i2c_dev); /* driver GPIO direction:input */    
     
252. }
     
253. 
     
254. 
     
255. /* -------------------------------------------------------------------------*
     
256.  * Function : receive_i2c_ack *
     
257.  * Description: During SCL high, when SDA holds low is ACK otherwise NACK. *
     
258.  * Parameters : i2c device structure *
     
259.  * Return : OK is ACK, or is NACK. *
     
260.  * Notes : This function gets the ACK signal from the slave. *
     
261.  * -------------------------------------------------------------------------*/
     
262. LOCAL STATUS receive_i2c_ack(struct i2c_simu_dev i2c_dev)
     
263. {
     
264.     INT32 isAck = 0;    
     
265.     SCL_WRITE (i2c_dev, 0); /* pull SCL low */
     
266.     I2CDELAY;
     
267.     SDA_WRITE (i2c_dev, 1);                  /* pull SDA high */
     
268.     SDA_INPUT_ACTIVE(i2c_dev); /* driver GPIO direction:input */
     
269.     I2CDELAY;
     
270.     SCL_WRITE (i2c_dev, 1);                          /* pull SCL high */
     
271.     I2CDELAY;
     
272.     I2CDELAY;
     
273.     if(SDA_READ(i2c_dev))
     
274.     {
     
275.         isAck = I2C_ERROR_CYCLE_ACKIN;
     
276.     }
     
277.     else
     
278.     {
     
279.         isAck = OK;
     
280.     }
     
281.     SCL_WRITE (i2c_dev, 0);
     
282.     I2CDELAY;
     
283.     SDA_OUTPUT_ACTIVE(i2c_dev); /* driver GPIO direction:output */
     
284.     return isAck;
     
285. }
     
286. 
     
287. /* -------------------------------------------------------------------------*
     
288.  * Function : send_i2c_ack *
     
289.  * Description: During SCL high, when SDA holds low is ACK otherwise NACK. *
     
290.  * Parameters : i2c device structure         *
     
291.  * Return : OK if success,or I2C_ERROR_ACK *
     
292.  * Notes : This function send ACK to slave device         *
     
293.  * -------------------------------------------------------------------------*/
     
294. LOCAL STATUS send_i2c_ack(struct i2c_simu_dev i2c_dev)
     
295. {
     
296.     SCL_WRITE (i2c_dev, 0); /* pull SCL low */
     
297.     I2CDELAY;
     
298.     SDA_OUTPUT_ACTIVE(i2c_dev); /* driver GPIO direction:output */    
     
299.     SDA_WRITE (i2c_dev, 0); /* pull SDA low */
     
300.     I2CDELAY;    
     
301.     SCL_WRITE (i2c_dev, 1); /* pull SCL high */
     
302.     I2CDELAY;
     
303.     I2CDELAY;
     
304.     SCL_WRITE (i2c_dev, 0); /* pull SCL low */
     
305.     I2CDELAY;    
     
306.     return OK;
     
307. }
     
308. 
     
309. /* -------------------------------------------------------------------------*
     
310.  * Function : send_i2c_nack *
     
311.  * Description: During SCL high, when SDA holds low is ACK otherwise NACK. *
     
312.  * Parameters : i2c device structure         *
     
313.  * Return : OK if success,or I2C_ERROR_NACK *
     
314.  * Notes : This function send NACK to slave device         *
     
315.  * -------------------------------------------------------------------------*/
     
316. LOCAL STATUS send_i2c_nack(struct i2c_simu_dev i2c_dev)
     
317. {
     
318.     SCL_WRITE (i2c_dev, 0); /* pull SCL low */
     
319.     I2CDELAY;
     
320.     SDA_OUTPUT_ACTIVE(i2c_dev);/* driver GPIO direction:output */    
     
321.     SDA_WRITE (i2c_dev, 1); /* pull SDA high */
     
322.     I2CDELAY;    
     
323.     SCL_WRITE (i2c_dev, 1); /* pull SCL high */
     
324.     I2CDELAY;
     
325.     I2CDELAY;
     
326.     SCL_WRITE (i2c_dev, 0); /* pull SCL low */
     
327.     I2CDELAY;    
     
328.     return OK;
     
329. }
     
330. 
     
331. /*-------------------------------------------------------------------*
     
332. * Probe to see if a chip is present. Also good for checking for the *
     
333. * completion of EEPROM writes since the chip stops responding until *
     
334. * the write completes (typically 10mSec).                              *
     
335. * -------------------------------------------------------------------*/
     
336. STATUS i2c_probe (struct i2c_simu_dev i2c_dev)
     
337. {
     
338.     INT32 iRc = 0;    
     
339.     
     
340.     if (i2c_stat_check(i2c_dev) != OK)
     
341.     {
     
342.         return I2C_ERROR_KNOWN_STATE;
     
343.     }
     
344.     if (i2c_start(i2c_dev) != OK)
     
345.     {
     
346.         (void)i2c_stop(i2c_dev);
     
347.         return I2C_ERROR_CYCLE_START;
     
348.     }    
     
349.     iRc = (i2c_simu_write_byte(i2c_dev, (i2c_dev.i2cDevAddr)) != OK) ? I2C_ERROR_CYCLE_WRITE:OK;        
     
350.     (void)i2c_stop(i2c_dev);
     
351.     return (iRc);
     
352. }
     
353. 
     
354. 
     
355. /* -------------------------------------------------------------------------*
     
356.  * Function : i2c_simu_read_byte *
     
357.  * Description: Get the Data from slave device *
     
358.  * Parameters : i2c device structure,data buffer for loading data *
     
359.  * Return : OK if read byte successfully,or failure *
     
360.  * -------------------------------------------------------------------------*/
     
361. LOCAL STATUS i2c_simu_read_byte (struct i2c_simu_dev i2c_dev, UINT8 *data,UINT32 length)
     
362. {
     
363.     UINT8 i = 0,j = 0,input_byte = 0;            /* counter */
     
364.         
     
365.     /* set GPIO pin direction:input */
     
366.     I2CDELAY;
     
367.     
     
368.     /* receive bytes of data */
     
369.     for (i = 0; i < length; i++)
     
370.     {
     
371.         SDA_INPUT_ACTIVE(i2c_dev);
     
372.         input_byte = 0x00;
     
373.         /*SCL(i2c_dev, 1);*/
     
374.         for (j = 0; j < 8; j++)
     
375.         {
     
376.             SCL_WRITE(i2c_dev, 0);
     
377.             I2CDELAY;
     
378.             I2CDELAY;
     
379.             SCL_WRITE (i2c_dev, 1);
     
380.             I2CDELAY;
     
381.             input_byte <<= 1;
     
382.             if (SDA_READ(i2c_dev))
     
383.             {
     
384.                 input_byte++;
     
385.             }             
     
386.             I2CDELAY;                        
     
387.             
     
388.         }
     
389.         data[i] = input_byte;
     
390.         if (i == length - 1)
     
391.         {
     
392.             break;
     
393.         }
     
394.         if (send_i2c_ack(i2c_dev)) /* always return OK */
     
395.         {
     
396.             i2c_stop(i2c_dev);
     
397.             return I2C_ERROR_CYCLE_ACKOUT;
     
398.         }        
     
399.     }    
     
400.     return OK;
     
401. }
     
402. 
     
403. 
     
404. /* -------------------------------------------------------------------------*
     
405.  * Function : i2c_simu_write_byte *
     
406.  * Description: Send the byte output of gpio, MSB first. *
     
407.  * Parameters : i2c device structure,data to be shifted. *
     
408.  * Return : OK if write byte successfully,or failure *
     
409.  * -------------------------------------------------------------------------*/
     
410. LOCAL STATUS i2c_simu_write_byte (struct i2c_simu_dev i2c_dev, UINT8 writeData)
     
411. {
     
412.     UINT8 j = 0; /* counter */
     
413.     
     
414.     /* set GPIO pin direction:output */
     
415.     SDA_OUTPUT_ACTIVE(i2c_dev);
     
416. 
     
417.     for (j = 0; j < 8; j++)
     
418.     {
     
419.         SCL_WRITE (i2c_dev, 0);
     
420.         I2CDELAY;    
     
421.         if ((writeData & 0x80) == 0)
     
422.         {
     
423.             SDA_WRITE (i2c_dev, 0);
     
424.         }
     
425.         else
     
426.         {
     
427.             SDA_WRITE (i2c_dev, 1);
     
428.         }
     
429.         I2CDELAY;
     
430.         
     
431.         SCL_WRITE (i2c_dev, 1);            
     
432.         I2CDELAY;
     
433.         I2CDELAY;        
     
434.         writeData <<= 1;
     
435.     }
     
436.     if (receive_i2c_ack(i2c_dev))
     
437.     {
     
438.         i2c_stop(i2c_dev);
     
439.         return I2C_ERROR_CYCLE_ACKIN;
     
440.     }
     
441.     return OK;
     
442. }
     
443. 
     
444. void i2cSearch()
     
445. {
     
446.     UINT32 i = 0, j = 0, iRc = 0;
     
447.     struct i2c_simu_dev i2c_dev;
     
448.         
     
449.     for(i=4; i<11;i++)
     
450.     {
     
451.         /* i2c device initial */
     
452.         if (i2cDrvInit(i,&i2c_dev) != OK)
     
453.         {
     
454.      printf("\n[i2c]init failed");
     
455.             continue;
     
456.         }
     
457.         /*
     
458.         printf("\ndebug_device=%x",aI2cDevAddr[i]);
     
459.         if(!i2c_probe(i2c_dev))
     
460.         {
     
461.             printf("\ndevice=%x",aI2cDevAddr[i]);
     
462.         }
     
463.         */
     
464.         for(j = 0; j < 128; j++)
     
465.         {
     
466.             if (i2c_stat_check(i2c_dev) != OK)
     
467.             {
     
468.                 return I2C_ERROR_KNOWN_STATE;
     
469.             }
     
470.             if (i2c_start(i2c_dev) != OK)
     
471.             {
     
472.                 (void)i2c_stop(i2c_dev);
     
473.                 return I2C_ERROR_CYCLE_START;
     
474.             }            
     
475.             iRc = (i2c_simu_write_byte(i2c_dev, j<<1) != OK) ? I2C_ERROR_CYCLE_WRITE:OK;
     
476.             (void)i2c_stop(i2c_dev);
     
477.             if (OK == iRc)
     
478.             {
     
479.                 printf("\ndevice=%x", j<<1);
     
480.             }
     
481.         }
     
482.     }
     
483. }
     
484. 
     
485. /* -------------------------------------------------------------------------*
     
486.  * Function : iic_read             *
     
487.  * Description: Read slave datas from gpio, MSB first     *
     
488.  * Parameters : i2c device structure,slave address,data buffer to be loaded.*
     
489.  * Return : the amount of reading bytes ,or failure *
     
490.  * -------------------------------------------------------------------------*/
     
491. STATUS iic_read(struct i2c_simu_dev i2c_dev, UINT32 addr, UINT32 alen, UINT8 *buffer, UINT32 len)
     
492. {
     
493.     INT32 shift,iRc;
     
494.     i2c_printf("iic_read: chip %02X addr %02X alen %d buffer %p len %d\n",
     
495.              i2c_dev.i2cDevAddr, addr, alen, buffer, len);    
     
496.     /*
     
497.      * Do the addressing portion of a write cycle to set the
     
498.      * chip's address pointer. If the address length is zero,
     
499.      * don't do the normal write cycle to set the address pointer,
     
500.      * there is no address pointer in this chip.
     
501.      */    
     
502.     if (i2c_stat_check(i2c_dev) != OK)
     
503.     {
     
504.         return I2C_ERROR_KNOWN_STATE;
     
505.     }
     
506. 
     
507.     /* Send the chip address for a read cycle. */
     
508.     if(alen > 0)
     
509.     {    
     
510.         if (i2c_start(i2c_dev) != OK)
     
511.         {
     
512.             (void)i2c_stop(i2c_dev);
     
513.             return I2C_ERROR_CYCLE_START;
     
514.         }
     
515.         /* write slave address */
     
516.         if(i2c_simu_write_byte(i2c_dev, i2c_dev.i2cDevAddr))
     
517.         {    /* write cycle */    
     
518.             (void)i2c_stop(i2c_dev);
     
519.             i2c_printf("iic_read, no chip responded %02X\n", i2c_dev.i2cDevAddr);
     
520.             return I2C_ERROR_CYCLE_WRITE;
     
521.         }
     
522.         
     
523.         shift = (alen-1) * 8;
     
524.         while(alen-- > 0)
     
525.         {
     
526.             if(i2c_simu_write_byte(i2c_dev, (addr >> shift)))
     
527.             {    
     
528.                 (void)i2c_stop(i2c_dev);
     
529.                 i2c_printf("iic_read, address not <ACK>ed\n");
     
530.                 return I2C_ERROR_CYCLE_WRITE;
     
531.             }
     
532.             shift -= 8;
     
533.         }
     
534.         i2c_stop(i2c_dev);    /* reportedly some chips need a full stop */        
     
535.     }
     
536. 
     
537.     /*
     
538.      * Send the chip address again, this time for a read cycle.
     
539.      * Then read the data. On the last byte, we do a NACK instead
     
540.      * of an ACK(len == 0) to terminate the read.
     
541.      */    
     
542.     if (i2c_start(i2c_dev) != OK)
     
543.     {
     
544.         (void)i2c_stop(i2c_dev);
     
545.         return I2C_ERROR_CYCLE_START;
     
546.     }
     
547.         
     
548.     if(i2c_simu_write_byte(i2c_dev, ((i2c_dev.i2cDevAddr) | 1)))
     
549.     {    
     
550.         (void)i2c_stop(i2c_dev);            
     
551.         return I2C_ERROR_CYCLE_WRITE;
     
552.     }        
     
553.     
     
554.     iRc = (i2c_simu_read_byte(i2c_dev, buffer,len) == len) ? OK : ERROR;
     
555. 
     
556.     (void)i2c_stop(i2c_dev);
     
557. 
     
558.     return iRc;
     
559.     
     
560. }
     
561. 
     
562. /*-----------------------------------------------------------------------
     
563.  * Write bytes
     
564.  */
     
565. /* -------------------------------------------------------------------------*
     
566.  * Function : iic_write             *
     
567.  * Description: Send the bytes out to gpio, MSB first. *
     
568.  * Parameters : i2c device structure,slave address,data to be shifted. *
     
569.  * Return : OK if write bytes successfully,or failure times *
     
570.  * -------------------------------------------------------------------------*/
     
571. STATUS iic_write(struct i2c_simu_dev i2c_dev, UINT32 addr, UINT32 alen, UINT8 *buffer, UINT32 len)
     
572. {
     
573.     INT32 shift,failures = 0;
     
574.     i2c_printf("iic_write: chip %02X addr %02X alen %d buffer %p len %d\n",
     
575.              i2c_dev.i2cDevAddr, addr, alen, buffer, len);
     
576.     if (i2c_stat_check(i2c_dev) != OK)
     
577.     {
     
578.         return I2C_ERROR_KNOWN_STATE;
     
579.     }
     
580. 
     
581.     if (i2c_start(i2c_dev) != OK)
     
582.     {
     
583.         (void)i2c_stop(i2c_dev);
     
584.         return I2C_ERROR_CYCLE_START;
     
585.     }
     
586. 
     
587.     
     
588.     if (i2c_simu_write_byte(i2c_dev, i2c_dev.i2cDevAddr) != OK)
     
589.     {
     
590.         (void)i2c_stop(i2c_dev);
     
591.         i2c_printf("iic_write, no chip responded %02X\n", i2c_dev.i2cDevAddr);    
     
592.         return I2C_ERROR_CYCLE_START;
     
593.     }
     
594.             
     
595.     shift = (alen-1) * 8;
     
596.     while(alen-- > 0)
     
597.     {
     
598.         if(i2c_simu_write_byte(i2c_dev, (addr >> shift)))
     
599.         {
     
600.             (void)i2c_stop(i2c_dev);
     
601.             i2c_printf("iic_write, address not <ACK>ed\n");
     
602.             return I2C_ERROR_CYCLE_WRITE;
     
603.         }
     
604.         shift -= 8;
     
605.     }
     
606. 
     
607.     while(len-- > 0)
     
608.     {
     
609.         if(i2c_simu_write_byte(i2c_dev, *buffer++))
     
610.         {
     
611.             failures--;/* negative value */
     
612.         }
     
613.     }
     
614.     i2c_stop(i2c_dev);
     
615.     return(failures);
     
616. }

2.i2cDevices.c

 

1. #include <vxWorks.h>
   
2. #include <stdio.h>
   
3. #include <semLib.h>
   
4. #include "i2cbussimu.h"
   
5. #include "i2cDevices.h"
   
6. #include "bsp.h"
   
7. 
   
8. #define AT24C02_BUF_LEN 0x8
   
9. #define MIN(a,b) ((a) < (b) ? (a) : (b))
   
10. 
    
11. #define i2c_debug 0
    
12. 
    
13. #define i2c_printf(fmt,arg...) {if(i2c_debug)printf(fmt,##arg);}
    
14. 
    
15. extern SEM_ID i2cMutex;
    
16. extern void sysUsDelay(int delay);
    
17. 
    
18. LOCAL int at24c02_read(struct i2c_simu_dev i2c_dev,void *dst, UINT32 src,int cnt)
    
19. {
    
20.     if(((int)src+cnt>0x100) || (cnt<0)||(dst == 0))
    
21.     {
    
22.         return ERROR;
    
23.     }
    
24. 
    
25.     if(iic_read(i2c_dev,src,1,(UINT8 *)dst,cnt)!=OK)
    
26.     {
    
27.         return ERROR;
    
28.     }
    
29. 
    
30.     return cnt;
    
31. }
    
32. 
    
33. LOCAL int progDone(INT32 i2c_dev_addr, INT32 dummy)
    
34. {
    
35.     return (!i2c_probe(*((struct i2c_simu_dev *)i2c_dev_addr)));
    
36. }
    
37. 
    
38. LOCAL int at24c02_write(struct i2c_simu_dev i2c_dev, UINT32 offset,void *buffer,int byteCnt)
    
39. {
    
40.     UINT32 dst,src,cnt;
    
41.     int iRc;
    
42.     dst = offset;
    
43.     src = (UINT32)buffer;
    
44.     iRc = byteCnt;
    
45. 
    
46.     do{
    
47.         cnt = MIN(AT24C02_BUF_LEN-((UINT32)dst & (AT24C02_BUF_LEN-1)),byteCnt);
    
48. 
    
49.         if((OK != iic_write(i2c_dev,dst,1,(UINT8 *)src,cnt)) ||
    
50.            (OK != sysUsDelayPoll(20000, progDone,(INT32)&i2c_dev,0))) /* Self-timed Write Cycle (12 ms Max) */
    
51.         {
    
52.             return ERROR;
    
53.         }
    
54. 
    
55.         dst += cnt;
    
56.         src += cnt;
    
57.         byteCnt -= cnt;
    
58.     }while(byteCnt>0);
    
59. 
    
60.     return iRc;
    
61. }
    
62. 
    
63. /*
    
64. @devNum: device number for FPH800H from 0 to 11
    
65. @cmd: IIC_READ or IIC_WEITW
    
66. @offset:I2C device register address
    
67. @buffer :buffer address provided by user
    
68. @bufLen: the length of buffer
    
69. */
    
70. UINT32 i2c_dev_access (UINT32 devNum,UINT32 cmd, UINT32 offset, void *buffer, UINT32 bufLen)
    
71. {
    
72. 
    
73.     UINT8 i2cDevAddr;
    
74. 
    
75.     int alen,iRc=0;
    
76. 
    
77.     if(devNum < I2C_MB_EEPROM || devNum > I2C_SFP1_FB || !(cmd == I2C_READ || cmd == I2C_WRITE) || !buffer )
    
78.     {
    
79.         return ERROR;
    
80.     }
    
81.     
    
82.     i2c_printf("\n[i2c]begin,DevNum=%d,cmd=%d,offset=%d,buffer=0x%x,bufLen=%d",
    
83.                                    devNum, cmd, offset,(int)buffer, bufLen);
    
84. 
    
85.     if(i2cMutex)
    
86.     {
    
87.         semTake (i2cMutex,WAIT_FOREVER);
    
88.     }
    
89. 
    
90.     struct i2c_simu_dev i2c_dev;
    
91.     
    
92.     /* i2c device initial */
    
93.     if (i2cDrvInit(devNum,&i2c_dev) != OK)
    
94.     {
    
95.         i2c_printf("\n[i2c]init failed");
    
96.         goto IIC_END;        
    
97.     }
    
98. 
    
99.     /* Get the register address length */
    
100.     alen = 1; /* currently, It seems that the length of address is 1 byte */
     
101. 
     
102.     if (cmd == I2C_READ)
     
103.     {
     
104.         if(devNum == I2C_MB_EEPROM)
     
105.         {
     
106.             iRc = at24c02_read(i2c_dev,(void *)buffer,offset,bufLen); /* error or count */
     
107.         }
     
108.         else
     
109.         {
     
110.             iRc = iic_read(i2c_dev,offset,alen,buffer,bufLen); /* OK or error */
     
111.         }
     
112.     }
     
113.     else /* cmd == IIC_WRITE */
     
114.     {
     
115.         if(devNum == I2C_MB_EEPROM)
     
116.         {
     
117.             iRc = at24c02_write(i2c_dev,offset,(void *)buffer,bufLen); /* error or count */
     
118.         }
     
119.         else
     
120.         {
     
121.             iRc = iic_write(i2c_dev,offset,alen,buffer,bufLen);/*OK or negative count */
     
122.         }
     
123.     }
     
124. 
     
125. IIC_END:
     
126.     if(i2cMutex)
     
127.     {
     
128.         semGive (i2cMutex);
     
129.     }
     
130. 
     
131.     i2c_printf("\n[i2c]end, iRc=0x%X",iRc);
     
132.   
     
133.     return iRc;
     
134. }