]> git.sur5r.net Git - u-boot/blob - board/esd/cpci750/i2c.c
board/[d-e]*: Remove obsolete references to CONFIG_COMMANDS
[u-boot] / board / esd / cpci750 / i2c.c
1 /*
2  * (C) Copyright 2000
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  *
23  * Hacked for the DB64360 board by Ingo.Assmus@keymile.com
24  * extra improvments by Brain Waite
25  * for cpci750 by reinhard.arlt@esd-electronics.com
26  */
27 #include <common.h>
28 #include <mpc8xx.h>
29 #include <malloc.h>
30 #include "../../Marvell/include/mv_gen_reg.h"
31 #include "../../Marvell/include/core.h"
32
33 #define I2C_DELAY           100
34 #undef  DEBUG_I2C
35
36 #ifdef DEBUG_I2C
37 #define DP(x) x
38 #else
39 #define DP(x)
40 #endif
41
42 /* Assuming that there is only one master on the bus (us) */
43
44 static void i2c_init (int speed, int slaveaddr)
45 {
46         unsigned int n, m, freq, margin, power;
47         unsigned int actualN = 0, actualM = 0;
48         unsigned int minMargin = 0xffffffff;
49         unsigned int tclk = CFG_TCLK;
50         unsigned int i2cFreq = speed;   /* 100000 max. Fast mode not supported */
51
52         DP (puts ("i2c_init\n"));
53 /* gtI2cMasterInit */
54         for (n = 0; n < 8; n++) {
55                 for (m = 0; m < 16; m++) {
56                         power = 2 << n; /* power = 2^(n+1) */
57                         freq = tclk / (10 * (m + 1) * power);
58                         if (i2cFreq > freq)
59                                 margin = i2cFreq - freq;
60                         else
61                                 margin = freq - i2cFreq;
62                         if (margin < minMargin) {
63                                 minMargin = margin;
64                                 actualN = n;
65                                 actualM = m;
66                         }
67                 }
68         }
69
70         DP (puts ("setup i2c bus\n"));
71
72         /* Setup bus */
73         /* gtI2cReset */
74         GT_REG_WRITE (I2C_SOFT_RESET, 0);
75         asm(" sync");
76         GT_REG_WRITE (I2C_CONTROL, 0);
77         asm(" sync");
78
79         DP (puts ("set baudrate\n"));
80
81         GT_REG_WRITE (I2C_STATUS_BAUDE_RATE, (actualM << 3) | actualN);
82         asm(" sync");
83
84         DP (puts ("udelay...\n"));
85
86         udelay (I2C_DELAY);
87
88         GT_REG_WRITE (I2C_CONTROL, (0x1 << 2) | (0x1 << 6));
89         asm(" sync");
90 }
91
92
93 static uchar i2c_select_device (uchar dev_addr, uchar read, int ten_bit)
94 {
95         unsigned int status, data, bits = 7;
96         unsigned int control;
97         int count = 0;
98
99         DP (puts ("i2c_select_device\n"));
100
101         /* Output slave address */
102
103         if (ten_bit) {
104                 bits = 10;
105         }
106
107         GT_REG_READ (I2C_CONTROL, &control);
108         control |=  (0x1 << 2);
109         GT_REG_WRITE (I2C_CONTROL, control);
110         asm(" sync");
111
112         GT_REG_READ (I2C_CONTROL, &control);
113         control |= (0x1 << 5);  /* generate the I2C_START_BIT */
114         GT_REG_WRITE (I2C_CONTROL, control);
115         asm(" sync");
116         RESET_REG_BITS (I2C_CONTROL, (0x01 << 3));
117         asm(" sync");
118
119         GT_REG_READ (I2C_CONTROL, &status);
120         while ((status & 0x08) != 0x08) {
121                 GT_REG_READ (I2C_CONTROL, &status);
122                 }
123
124
125         count = 0;
126
127         GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
128         while (((status & 0xff) != 0x08) && ((status & 0xff) != 0x10)){
129                 if (count > 200) {
130 #ifdef DEBUG_I2C
131                         printf ("Failed to set startbit: 0x%02x\n", status);
132 #endif
133                         GT_REG_WRITE (I2C_CONTROL, (0x1 << 4)); /*stop */
134                         asm(" sync");
135                         return (status);
136                 }
137                 GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
138                 count++;
139         }
140
141         DP (puts ("i2c_select_device:write addr byte\n"));
142
143         /* assert the address */
144
145         data = (dev_addr << 1);
146         /* set the read bit */
147         data |= read;
148         GT_REG_WRITE (I2C_DATA, data);
149         asm(" sync");
150         RESET_REG_BITS (I2C_CONTROL, BIT3);
151         asm(" sync");
152
153         GT_REG_READ (I2C_CONTROL, &status);
154         while ((status & 0x08) != 0x08) {
155                 GT_REG_READ (I2C_CONTROL, &status);
156                 }
157
158         GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
159         count = 0;
160         while (((status & 0xff) != 0x40) && ((status & 0xff) != 0x18)) {
161                 if (count > 200) {
162 #ifdef DEBUG_I2C
163                         printf ("Failed to write address: 0x%02x\n", status);
164 #endif
165                         GT_REG_WRITE (I2C_CONTROL, (0x1 << 4)); /*stop */
166                         return (status);
167                 }
168                 GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
169                 asm(" sync");
170                 count++;
171         }
172
173         if (bits == 10) {
174                 printf ("10 bit I2C addressing not yet implemented\n");
175                 return (0xff);
176         }
177
178         return (0);
179 }
180
181 static uchar i2c_get_data (uchar * return_data, int len)
182 {
183
184         unsigned int data, status;
185         int count = 0;
186
187         DP (puts ("i2c_get_data\n"));
188
189         while (len) {
190
191                 RESET_REG_BITS (I2C_CONTROL, BIT3);
192                 asm(" sync");
193
194                 /* Get and return the data */
195
196                 GT_REG_READ (I2C_CONTROL, &status);
197                 while ((status & 0x08) != 0x08) {
198                         GT_REG_READ (I2C_CONTROL, &status);
199                         }
200
201                 GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
202                 count++;
203                 while ((status & 0xff) != 0x50) {
204                         if (count > 20) {
205 #ifdef DEBUG_I2C
206                                 printf ("Failed to get data len status: 0x%02x\n", status);
207 #endif
208                                 GT_REG_WRITE (I2C_CONTROL, (0x1 << 4)); /*stop */
209                                 asm(" sync");
210                                 return 0;
211                         }
212                         GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
213                         count++;
214                 }
215                 GT_REG_READ (I2C_DATA, &data);
216                 len--;
217                 *return_data = (uchar) data;
218                 return_data++;
219
220         }
221         RESET_REG_BITS (I2C_CONTROL, BIT2 | BIT3);
222         asm(" sync");
223         count = 0;
224
225         GT_REG_READ (I2C_CONTROL, &status);
226         while ((status & 0x08) != 0x08) {
227                 GT_REG_READ (I2C_CONTROL, &status);
228                 }
229
230         while ((status & 0xff) != 0x58) {
231                 if (count > 2000) {
232                         GT_REG_WRITE (I2C_CONTROL, (0x1 << 4)); /*stop */
233                         return (status);
234                 }
235                 GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
236                 count++;
237         }
238         GT_REG_WRITE (I2C_CONTROL, (0x1 << 4)); /* stop */
239         asm(" sync");
240         RESET_REG_BITS (I2C_CONTROL, (0x1 << 3));
241         asm(" sync");
242
243         return (0);
244 }
245
246
247 static uchar i2c_write_data (unsigned int *data, int len)
248 {
249         unsigned int status;
250         int count;
251         unsigned int temp;
252         unsigned int *temp_ptr = data;
253
254         DP (puts ("i2c_write_data\n"));
255
256         while (len) {
257                 count = 0;
258                 temp = (unsigned int) (*temp_ptr);
259                 GT_REG_WRITE (I2C_DATA, temp);
260                 asm(" sync");
261                 RESET_REG_BITS (I2C_CONTROL, (0x1 << 3));
262                 asm(" sync");
263
264                 GT_REG_READ (I2C_CONTROL, &status);
265                 while ((status & 0x08) != 0x08) {
266                         GT_REG_READ (I2C_CONTROL, &status);
267                         }
268
269                 GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
270                 count++;
271                 while ((status & 0xff) != 0x28) {
272                         if (count > 200) {
273                                 GT_REG_WRITE (I2C_CONTROL, (0x1 << 4)); /*stop */
274                                 asm(" sync");
275                                 return (status);
276                         }
277                         GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
278                         count++;
279                 }
280                 len--;
281                 temp_ptr++;
282         }
283         return (0);
284 }
285
286
287 static uchar i2c_write_byte (unsigned char *data, int len)
288 {
289         unsigned int status;
290         int count;
291         unsigned int temp;
292         unsigned char *temp_ptr = data;
293
294         DP (puts ("i2c_write_byte\n"));
295
296         while (len) {
297                 count = 0;
298                 /* Set and assert the data */
299                 temp = *temp_ptr;
300                 GT_REG_WRITE (I2C_DATA, temp);
301                 asm(" sync");
302                 RESET_REG_BITS (I2C_CONTROL, (0x1 << 3));
303                 asm(" sync");
304
305
306                 GT_REG_READ (I2C_CONTROL, &status);
307                 while ((status & 0x08) != 0x08) {
308                         GT_REG_READ (I2C_CONTROL, &status);
309                         }
310
311                 GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
312                 count++;
313                 while ((status & 0xff) != 0x28) {
314                         if (count > 200) {
315                                 GT_REG_WRITE (I2C_CONTROL, (0x1 << 4)); /*stop */
316                                 asm(" sync");
317                                 return (status);
318                         }
319                         GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
320                         count++;
321                 }
322                 len--;
323                 temp_ptr++;
324         }
325         return (0);
326 }
327
328 static uchar
329 i2c_set_dev_offset (uchar dev_addr, unsigned int offset, int ten_bit,
330                     int alen)
331 {
332         uchar status;
333         unsigned int table[2];
334
335         table[1] = (offset     ) & 0x0ff;       /* low byte */
336         table[0] = (offset >> 8) & 0x0ff;       /* high byte */
337
338         DP (puts ("i2c_set_dev_offset\n"));
339
340         status = i2c_select_device (dev_addr, 0, ten_bit);
341         if (status) {
342 #ifdef DEBUG_I2C
343 22              printf ("Failed to select device setting offset: 0x%02x\n",
344                         status);
345 #endif
346                 return status;
347         }
348 /* check the address offset length */
349         if (alen == 0)
350                 /* no address offset */
351                 return (0);
352         else if (alen == 1) {
353                 /* 1 byte address offset */
354                 status = i2c_write_data (&offset, 1);
355                 if (status) {
356 #ifdef DEBUG_I2C
357                         printf ("Failed to write data: 0x%02x\n", status);
358 #endif
359                         return status;
360                 }
361         } else if (alen == 2) {
362                 /* 2 bytes address offset */
363                 status = i2c_write_data (table, 2);
364                 if (status) {
365 #ifdef DEBUG_I2C
366                         printf ("Failed to write data: 0x%02x\n", status);
367 #endif
368                         return status;
369                 }
370         } else {
371                 /* address offset unknown or not supported */
372                 printf ("Address length offset %d is not supported\n", alen);
373                 return 1;
374         }
375         return 0;               /* sucessful completion */
376 }
377
378 uchar
379 i2c_read (uchar dev_addr, unsigned int offset, int alen, uchar * data,
380           int len)
381 {
382         uchar status = 0;
383         unsigned int i2cFreq = CFG_I2C_SPEED;
384
385         DP (puts ("i2c_read\n"));
386
387         i2c_init (i2cFreq, 0);  /* set the i2c frequency */
388
389         status = i2c_set_dev_offset (dev_addr, offset, 0, alen);        /* send the slave address + offset */
390         if (status) {
391 #ifdef DEBUG_I2C
392                 printf ("Failed to set slave address & offset: 0x%02x\n",
393                         status);
394 #endif
395                 return status;
396         }
397
398         status = i2c_select_device (dev_addr, 1, 0);
399         if (status) {
400 #ifdef DEBUG_I2C
401                 printf ("Failed to select device for data read: 0x%02x\n",
402                         status);
403 #endif
404                 return status;
405         }
406
407         status = i2c_get_data (data, len);
408         if (status) {
409 #ifdef DEBUG_I2C
410                 printf ("Data not read: 0x%02x\n", status);
411 #endif
412                 return status;
413         }
414
415         return 0;
416 }
417
418
419 void i2c_stop (void)
420 {
421         GT_REG_WRITE (I2C_CONTROL, (0x1 << 4));
422         asm(" sync");
423 }
424
425
426 uchar
427 i2c_write (uchar dev_addr, unsigned int offset, int alen, uchar * data,
428            int len)
429 {
430         uchar status = 0;
431         unsigned int i2cFreq = CFG_I2C_SPEED;
432
433         DP (puts ("i2c_write\n"));
434
435         i2c_init (i2cFreq, 0);  /* set the i2c frequency */
436
437         status = i2c_set_dev_offset (dev_addr, offset, 0, alen);        /* send the slave address + offset */
438         if (status) {
439 #ifdef DEBUG_I2C
440                 printf ("Failed to set slave address & offset: 0x%02x\n",
441                         status);
442 #endif
443                 return status;
444                 }
445
446
447         status = i2c_write_byte (data, len);    /* write the data */
448         if (status) {
449 #ifdef DEBUG_I2C
450                 printf ("Data not written: 0x%02x\n", status);
451 #endif
452                 return status;
453                 }
454         /* issue a stop bit */
455         i2c_stop ();
456         return 0;
457 }
458
459
460 int i2c_probe (uchar chip)
461 {
462
463 #ifdef DEBUG_I2C
464         unsigned int i2c_status;
465 #endif
466         uchar status = 0;
467         unsigned int i2cFreq = CFG_I2C_SPEED;
468
469         DP (puts ("i2c_probe\n"));
470
471         i2c_init (i2cFreq, 0);  /* set the i2c frequency */
472
473         status = i2c_set_dev_offset (chip, 0, 0, 0);    /* send the slave address + no offset */
474         if (status) {
475 #ifdef DEBUG_I2C
476                 printf ("Failed to set slave address: 0x%02x\n", status);
477 #endif
478                 return (int) status;
479         }
480 #ifdef DEBUG_I2C
481         GT_REG_READ (I2C_STATUS_BAUDE_RATE, &i2c_status);
482         printf ("address %#x returned %#x\n", chip, i2c_status);
483 #endif
484         /* issue a stop bit */
485         i2c_stop ();
486         return 0;               /* successful completion */
487 }