Add documentation for Open Firmware Flat Tree and usage.
[oweals/u-boot.git] / examples / smc91111_eeprom.c
1 /*
2  * (C) Copyright 2004
3  * Robin Getz rgetz@blacfin.uclinux.org
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  * Heavily borrowed from the following peoples GPL'ed software:
24  *  - Wolfgang Denk, DENX Software Engineering, wd@denx.de
25  *       Das U-boot
26  *  - Ladislav Michl ladis@linux-mips.org
27  *       A rejected patch on the U-Boot mailing list
28  */
29
30 #include <common.h>
31 #include <exports.h>
32 #include "../drivers/smc91111.h"
33
34 #define SMC_BASE_ADDRESS CONFIG_SMC91111_BASE
35 #define EEPROM          0x1;
36 #define MAC             0x2;
37 #define UNKNOWN         0x4;
38
39 void dump_reg (void);
40 void dump_eeprom (void);
41 int write_eeprom_reg (int, int);
42 void copy_from_eeprom (void);
43 void print_MAC (void);
44 int read_eeprom_reg (int);
45 void print_macaddr (void);
46
47 int smc91111_eeprom (int argc, char *argv[])
48 {
49         int c, i, j, done, line, reg, value, start, what;
50         char input[50];
51
52         /* Print the ABI version */
53         app_startup (argv);
54         if (XF_VERSION != (int) get_version ()) {
55                 printf ("Expects ABI version %d\n", XF_VERSION);
56                 printf ("Actual U-Boot ABI version %d\n",
57                         (int) get_version ());
58                 printf ("Can't run\n\n");
59                 return (0);
60         }
61
62         asm ("p2.h = 0xFFC0;");
63         asm ("p2.l = 0x0730;");
64         asm ("r0 = 0x01;");
65         asm ("w[p2] = r0;");
66         asm ("ssync;");
67
68         asm ("p2.h = 0xffc0;");
69         asm ("p2.l = 0x0708;");
70         asm ("r0 = 0x01;");
71         asm ("w[p2] = r0;");
72         asm ("ssync;");
73
74         if ((SMC_inw (BANK_SELECT) & 0xFF00) != 0x3300) {
75                 printf ("Can't find SMSC91111\n");
76                 return (0);
77         }
78
79         done = 0;
80         what = UNKNOWN;
81         printf ("\n");
82         while (!done) {
83                 /* print the prompt */
84                 printf ("SMC91111> ");
85                 line = 0;
86                 i = 0;
87                 start = 1;
88                 while (!line) {
89                         /* Wait for a keystroke */
90                         while (!tstc ());
91
92                         c = getc ();
93                         /* Make Uppercase */
94                         if (c >= 'Z')
95                                 c -= ('a' - 'A');
96                         /* printf(" |%02x| ",c); */
97
98                         switch (c) {
99                         case '\r':      /* Enter                */
100                         case '\n':
101                                 input[i] = 0;
102                                 puts ("\r\n");
103                                 line = 1;
104                                 break;
105                         case '\0':      /* nul                  */
106                                 continue;
107
108                         case 0x03:      /* ^C - break           */
109                                 input[0] = 0;
110                                 i = 0;
111                                 line = 1;
112                                 done = 1;
113                                 break;
114
115                         case 0x5F:
116                         case 0x08:      /* ^H  - backspace      */
117                         case 0x7F:      /* DEL - backspace      */
118                                 if (i > 0) {
119                                         puts ("\b \b");
120                                         i--;
121                                 }
122                                 break;
123                         default:
124                                 if (start) {
125                                         if ((c == 'W') || (c == 'D')
126                                             || (c == 'M') || (c == 'C')
127                                             || (c == 'P')) {
128                                                 putc (c);
129                                                 input[i] = c;
130                                                 if (i <= 45)
131                                                         i++;
132                                                 start = 0;
133                                         }
134                                 } else {
135                                         if ((c >= '0' && c <= '9')
136                                             || (c >= 'A' && c <= 'F')
137                                             || (c == 'E') || (c == 'M')
138                                             || (c == ' ')) {
139                                                 putc (c);
140                                                 input[i] = c;
141                                                 if (i <= 45)
142                                                         i++;
143                                                 break;
144                                         }
145                                 }
146                                 break;
147                         }
148                 }
149
150                 for (; i < 49; i++)
151                         input[i] = 0;
152
153                 switch (input[0]) {
154                 case ('W'):
155                         /* Line should be w reg value */
156                         i = 0;
157                         reg = 0;
158                         value = 0;
159                         /* Skip to the next space or end) */
160                         while ((input[i] != ' ') && (input[i] != 0))
161                                 i++;
162
163                         if (input[i] != 0)
164                                 i++;
165
166                         /* Are we writing to EEPROM or MAC */
167                         switch (input[i]) {
168                         case ('E'):
169                                 what = EEPROM;
170                                 break;
171                         case ('M'):
172                                 what = MAC;
173                                 break;
174                         default:
175                                 what = UNKNOWN;
176                                 break;
177                         }
178
179                         /* skip to the next space or end */
180                         while ((input[i] != ' ') && (input[i] != 0))
181                                 i++;
182                         if (input[i] != 0)
183                                 i++;
184
185                         /* Find register to write into */
186                         j = 0;
187                         while ((input[i] != ' ') && (input[i] != 0)) {
188                                 j = input[i] - 0x30;
189                                 if (j >= 0xA) {
190                                         j -= 0x07;
191                                 }
192                                 reg = (reg * 0x10) + j;
193                                 i++;
194                         }
195
196                         while ((input[i] != ' ') && (input[i] != 0))
197                                 i++;
198
199                         if (input[i] != 0)
200                                 i++;
201                         else
202                                 what = UNKNOWN;
203
204                         /* Get the value to write */
205                         j = 0;
206                         while ((input[i] != ' ') && (input[i] != 0)) {
207                                 j = input[i] - 0x30;
208                                 if (j >= 0xA) {
209                                         j -= 0x07;
210                                 }
211                                 value = (value * 0x10) + j;
212                                 i++;
213                         }
214
215                         switch (what) {
216                         case 1:
217                                 printf ("Writing EEPROM register %02x with %04x\n",
218                                         reg, value);
219                                 write_eeprom_reg (value, reg);
220                                 break;
221                         case 2:
222                                 printf ("Writing MAC register bank %i,
223                                         reg %02x with %04x\n", reg >> 4, reg & 0xE, value);
224                                 SMC_SELECT_BANK (reg >> 4);
225                                 SMC_outw (value, reg & 0xE);
226                                 break;
227                         default:
228                                 printf ("Wrong\n");
229                                 break;
230                         }
231                         break;
232                 case ('D'):
233                         dump_eeprom ();
234                         break;
235                 case ('M'):
236                         dump_reg ();
237                         break;
238                 case ('C'):
239                         copy_from_eeprom ();
240                         break;
241                 case ('P'):
242                         print_macaddr ();
243                         break;
244                 default:
245                         break;
246                 }
247
248         }
249
250         return (0);
251 }
252
253 void copy_from_eeprom (void)
254 {
255         int i;
256
257         SMC_SELECT_BANK (1);
258         SMC_outw ((SMC_inw (CTL_REG) & !CTL_EEPROM_SELECT) | CTL_RELOAD,
259                   CTL_REG);
260         i = 100;
261         while ((SMC_inw (CTL_REG) & CTL_RELOAD) && --i)
262                 udelay (100);
263         if (i == 0) {
264                 printf ("Timeout Refreshing EEPROM registers\n");
265         } else {
266                 printf ("EEPROM contents copied to MAC\n");
267         }
268
269 }
270
271 void print_macaddr (void)
272 {
273         int i, j, k, mac[6];
274
275         printf ("Current MAC Address in SMSC91111 ");
276         SMC_SELECT_BANK (1);
277         for (i = 0; i < 5; i++) {
278                 printf ("%02x:", SMC_inb (ADDR0_REG + i));
279         }
280
281         printf ("%02x\n", SMC_inb (ADDR0_REG + 5));
282
283         i = 0;
284         for (j = 0x20; j < 0x23; j++) {
285                 k = read_eeprom_reg (j);
286                 mac[i] = k & 0xFF;
287                 i++;
288                 mac[i] = k >> 8;
289                 i++;
290         }
291
292         printf ("Current MAC Address in EEPROM    ");
293         for (i = 0; i < 5; i++)
294                 printf ("%02x:", mac[i]);
295         printf ("%02x\n", mac[5]);
296
297 }
298 void dump_eeprom (void)
299 {
300         int j, k;
301
302         printf ("IOS2-0    ");
303         for (j = 0; j < 8; j++) {
304                 printf ("%03x     ", j);
305         }
306         printf ("\n");
307
308         for (k = 0; k < 4; k++) {
309                 if (k == 0)
310                         printf ("CONFIG ");
311                 if (k == 1)
312                         printf ("BASE   ");
313                 if ((k == 2) || (k == 3))
314                         printf ("       ");
315                 for (j = 0; j < 0x20; j += 4) {
316                         printf ("%02x:%04x ", j + k, read_eeprom_reg (j + k));
317                 }
318                 printf ("\n");
319         }
320
321         for (j = 0x20; j < 0x40; j++) {
322                 if ((j & 0x07) == 0)
323                         printf ("\n");
324                 printf ("%02x:%04x ", j, read_eeprom_reg (j));
325         }
326         printf ("\n");
327
328 }
329
330 int read_eeprom_reg (int reg)
331 {
332         int timeout;
333
334         SMC_SELECT_BANK (2);
335         SMC_outw (reg, PTR_REG);
336
337         SMC_SELECT_BANK (1);
338         SMC_outw (SMC_inw (CTL_REG) | CTL_EEPROM_SELECT | CTL_RELOAD,
339                   CTL_REG);
340         timeout = 100;
341         while ((SMC_inw (CTL_REG) & CTL_RELOAD) && --timeout)
342                 udelay (100);
343         if (timeout == 0) {
344                 printf ("Timeout Reading EEPROM register %02x\n", reg);
345                 return 0;
346         }
347
348         return SMC_inw (GP_REG);
349
350 }
351
352 int write_eeprom_reg (int value, int reg)
353 {
354         int timeout;
355
356         SMC_SELECT_BANK (2);
357         SMC_outw (reg, PTR_REG);
358
359         SMC_SELECT_BANK (1);
360         SMC_outw (value, GP_REG);
361         SMC_outw (SMC_inw (CTL_REG) | CTL_EEPROM_SELECT | CTL_STORE, CTL_REG);
362         timeout = 100;
363         while ((SMC_inw (CTL_REG) & CTL_STORE) && --timeout)
364                 udelay (100);
365         if (timeout == 0) {
366                 printf ("Timeout Writing EEPROM register %02x\n", reg);
367                 return 0;
368         }
369
370         return 1;
371
372 }
373
374 void dump_reg (void)
375 {
376         int i, j;
377
378         printf ("    ");
379         for (j = 0; j < 4; j++) {
380                 printf ("Bank%i ", j);
381         }
382         printf ("\n");
383         for (i = 0; i < 0xF; i += 2) {
384                 printf ("%02x  ", i);
385                 for (j = 0; j < 4; j++) {
386                         SMC_SELECT_BANK (j);
387                         printf ("%04x  ", SMC_inw (i));
388                 }
389                 printf ("\n");
390         }
391 }