omap24xx_i2c: Proper SCLH calculation
[x-loader-sniper.git] / drivers / omap24xx_i2c.c
1 /*
2  * Basic I2C functions
3  *
4  * Copyright (c) 2004 Texas Instruments
5  *
6  * This package is free software;  you can redistribute it and/or
7  * modify it under the terms of the license found in the file
8  * named COPYING that should have accompanied this file.
9  *
10  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
11  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
12  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
13  *
14  * Author: Jian Zhang jzhang@ti.com, Texas Instruments
15  *
16  * Copyright (c) 2003 Wolfgang Denk, wd@denx.de
17  * Rewritten to fit into the current U-Boot framework
18  *
19  * Adapted for OMAP2420 I2C, r-woodruff2@ti.com
20  *
21  */
22
23 #include <common.h>
24
25 #if defined(CONFIG_DRIVER_OMAP24XX_I2C) || defined(CONFIG_DRIVER_OMAP34XX_I2C)
26
27 #include <asm/arch/i2c.h>
28 #include <asm/io.h>
29
30 #define inb(a) __raw_readb(a)
31 #define outb(a,v) __raw_writeb(a,v)
32 #define inw(a) __raw_readw(a)
33 #define outw(a,v) __raw_writew(a,v)
34
35 static void wait_for_bb (void);
36 static u16 wait_for_pin (void);
37 static void flush_fifo(void);
38
39 void i2c_init (int speed, int slaveadd)
40 {
41         u16 scl;
42
43         outw(0x2, I2C_SYSC); /* for ES2 after soft reset */
44         udelay(1000);
45         outw(0x0, I2C_SYSC); /* will probably self clear but */
46
47         if (inw (I2C_CON) & I2C_CON_EN) {
48                 outw (0, I2C_CON);
49                 udelay (50000);
50         }
51
52         /* 12Mhz I2C module clock */
53         outw (0, I2C_PSC);
54         speed = speed/1000;                 /* 100 or 400 */
55         scl = ((12000/(speed*2)) - 7);
56         outw (scl, I2C_SCLL);
57         scl = ((12000/(speed*2)) - 5);
58         outw (scl, I2C_SCLH);
59         /* own address */
60         outw (slaveadd, I2C_OA);
61         outw (I2C_CON_EN, I2C_CON);
62
63         /* have to enable intrrupts or OMAP i2c module doesn't work */
64         outw (I2C_IE_XRDY_IE | I2C_IE_RRDY_IE | I2C_IE_ARDY_IE |
65               I2C_IE_NACK_IE | I2C_IE_AL_IE, I2C_IE);
66         udelay (1000);
67         flush_fifo();
68         outw (0xFFFF, I2C_STAT);
69         outw (0, I2C_CNT);
70 }
71
72 static int i2c_read_byte (u8 devaddr, u8 regoffset, u8 * value)
73 {
74         int i2c_error = 0;
75         u16 status;
76
77         /* wait until bus not busy */
78         wait_for_bb ();
79
80         /* one byte only */
81         outw (1, I2C_CNT);
82         /* set slave address */
83         outw (devaddr, I2C_SA);
84         /* no stop bit needed here */
85         outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX, I2C_CON);
86
87         status = wait_for_pin ();
88
89         if (status & I2C_STAT_XRDY) {
90                 /* Important: have to use byte access */
91                 *(volatile u8 *) (I2C_DATA) = regoffset;
92                 udelay (20000);
93                 if (inw (I2C_STAT) & I2C_STAT_NACK) {
94                         i2c_error = 1;
95                 }
96         } else {
97                 i2c_error = 1;
98         }
99
100         if (!i2c_error) {
101                 /* free bus, otherwise we can't use a combined transction */
102                 outw (0, I2C_CON);
103                 while (inw (I2C_STAT) || (inw (I2C_CON) & I2C_CON_MST)) {
104                         udelay (10000);
105                         /* Have to clear pending interrupt to clear I2C_STAT */
106                         outw (0xFFFF, I2C_STAT);
107                 }
108
109                 wait_for_bb ();
110                 /* set slave address */
111                 outw (devaddr, I2C_SA);
112                 /* read one byte from slave */
113                 outw (1, I2C_CNT);
114                 /* need stop bit here */
115                 outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP,
116                       I2C_CON);
117
118                 status = wait_for_pin ();
119                 if (status & I2C_STAT_RRDY) {
120 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
121                         *value = inb(I2C_DATA);
122 #else
123                         *value = inw(I2C_DATA);
124 #endif
125                         udelay (20000);
126                 } else {
127                         i2c_error = 1;
128                 }
129
130                 if (!i2c_error) {
131                         outw (I2C_CON_EN, I2C_CON);
132                         while (inw (I2C_STAT)
133                                || (inw (I2C_CON) & I2C_CON_MST)) {
134                                 udelay (10000);
135                                 outw (0xFFFF, I2C_STAT);
136                         }
137                 }
138         }
139         flush_fifo();
140         outw (0xFFFF, I2C_STAT);
141         outw (0, I2C_CNT);
142         return i2c_error;
143 }
144
145 static int i2c_write_byte (u8 devaddr, u8 regoffset, u8 value)
146 {
147         int i2c_error = 0;
148         u16 status, stat;
149
150         /* wait until bus not busy */
151         wait_for_bb ();
152
153         /* two bytes */
154         outw (2, I2C_CNT);
155         /* set slave address */
156         outw (devaddr, I2C_SA);
157         /* stop bit needed here */
158         outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX |
159               I2C_CON_STP, I2C_CON);
160
161         /* wait until state change */
162         status = wait_for_pin ();
163
164         if (status & I2C_STAT_XRDY) {
165 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
166                 /* send out 1 byte */
167                 outb(regoffset, I2C_DATA);
168                 outw(I2C_STAT_XRDY, I2C_STAT);
169                 status = wait_for_pin();
170                 if ((status & I2C_STAT_XRDY)) {
171                         /* send out next 1 byte */
172                         outb(value, I2C_DATA);
173                         outw(I2C_STAT_XRDY, I2C_STAT);
174                 } else {
175                         i2c_error = 1;
176                 }
177 #else
178                 /* send out two bytes */
179                 outw ((value << 8) + regoffset, I2C_DATA);
180 #endif
181
182                 /* must have enough delay to allow BB bit to go low */
183                 udelay (50000);
184                 if (inw (I2C_STAT) & I2C_STAT_NACK) {
185                         i2c_error = 1;
186                 }
187         } else {
188                 i2c_error = 1;
189         }
190
191         if (!i2c_error) {
192                 int eout = 200;
193
194                 outw (I2C_CON_EN, I2C_CON);
195                 while ((stat = inw (I2C_STAT)) || (inw (I2C_CON) & I2C_CON_MST)) {
196                         udelay (1000);
197                         /* have to read to clear intrrupt */
198                         outw (0xFFFF, I2C_STAT);
199                         if(--eout == 0) /* better leave with error than hang */
200                                 break;
201                 }
202         }
203         flush_fifo();
204         outw (0xFFFF, I2C_STAT);
205         outw (0, I2C_CNT);
206         return i2c_error;
207 }
208
209 static void flush_fifo(void)
210 {       u16 stat;
211
212         /* note: if you try and read data when its not there or ready
213          * you get a bus error
214          */
215         while(1){
216                 stat = inw(I2C_STAT);
217                 if(stat == I2C_STAT_RRDY){
218 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
219                         inb(I2C_DATA);
220 #else
221                         inw(I2C_DATA);
222 #endif
223                         outw(I2C_STAT_RRDY,I2C_STAT);
224                         udelay(1000);
225                 }else
226                         break;
227         }
228 }
229
230 int i2c_probe (uchar chip)
231 {
232         int res = 1; /* default = fail */
233
234         if (chip == inw (I2C_OA)) {
235                 return res;
236         }
237
238         /* wait until bus not busy */
239         wait_for_bb ();
240
241         /* try to read one byte */
242         outw (1, I2C_CNT);
243         /* set slave address */
244         outw (chip, I2C_SA);
245         /* stop bit needed here */
246         outw (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP, I2C_CON);
247         /* enough delay for the NACK bit set */
248         udelay (50000);
249
250         if (!(inw (I2C_STAT) & I2C_STAT_NACK)) {
251                 res = 0;      /* success case */
252                 flush_fifo();
253                 outw(0xFFFF, I2C_STAT);
254         } else {
255                 outw(0xFFFF, I2C_STAT);  /* failue, clear sources*/
256                 outw (inw (I2C_CON) | I2C_CON_STP, I2C_CON); /* finish up xfer */
257                 udelay(20000);
258                 wait_for_bb ();
259         }
260         flush_fifo();
261         outw (0, I2C_CNT); /* don't allow any more data in...we don't want it.*/
262         outw(0xFFFF, I2C_STAT);
263         return res;
264 }
265
266 int i2c_read (uchar chip, uint addr, int alen, uchar * buffer, int len)
267 {
268         int i;
269
270         if (alen > 1) {
271                 printf ("I2C read: addr len %d not supported\n", alen);
272                 return 1;
273         }
274
275         if (addr + len > 256) {
276                 printf ("I2C read: address out of range\n");
277                 return 1;
278         }
279
280         for (i = 0; i < len; i++) {
281                 if (i2c_read_byte (chip, addr + i, &buffer[i])) {
282                         printf ("I2C read: I/O error\n");
283                         i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE);
284                         return 1;
285                 }
286         }
287
288         return 0;
289 }
290
291 int i2c_write (uchar chip, uint addr, int alen, uchar * buffer, int len)
292 {
293         int i;
294
295         if (alen > 1) {
296                 printf ("I2C read: addr len %d not supported\n", alen);
297                 return 1;
298         }
299
300         if (addr + len > 256) {
301                 printf ("I2C read: address out of range\n");
302                 return 1;
303         }
304
305         for (i = 0; i < len; i++) {
306                 if (i2c_write_byte (chip, addr + i, buffer[i])) {
307                         printf ("I2C read: I/O error\n");
308                         i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE);
309                         return 1;
310                 }
311         }
312
313         return 0;
314 }
315
316 static void wait_for_bb (void)
317 {
318         int timeout = 10;
319         u16 stat;
320
321         outw(0xFFFF, I2C_STAT);  /* clear current interruts...*/
322         while ((stat = inw (I2C_STAT) & I2C_STAT_BB) && timeout--) {
323                 outw (stat, I2C_STAT);
324                 udelay (50000);
325         }
326
327         if (timeout <= 0) {
328                 printf ("timed out in wait_for_bb: I2C_STAT=%x\n",
329                         inw (I2C_STAT));
330         }
331         outw(0xFFFF, I2C_STAT);  /* clear delayed stuff*/
332 }
333
334 static u16 wait_for_pin (void)
335 {
336         u16 status;
337         int timeout = 10;
338
339         do {
340                 udelay (1000);
341                 status = inw (I2C_STAT);
342         } while (  !(status &
343                    (I2C_STAT_ROVR | I2C_STAT_XUDF | I2C_STAT_XRDY |
344                     I2C_STAT_RRDY | I2C_STAT_ARDY | I2C_STAT_NACK |
345                     I2C_STAT_AL)) && timeout--);
346
347         if (timeout <= 0) {
348                 printf ("timed out in wait_for_pin: I2C_STAT=%x\n",
349                         inw (I2C_STAT));
350                         outw(0xFFFF, I2C_STAT);
351 }
352         return status;
353 }
354
355 #endif /* CONFIG_DRIVER_OMAP24XX_I2C */