blob: 84ae5c1b5d633a45189ebe6622ddc4fe37a4851b [file] [log] [blame]
wdenk682011f2003-06-03 23:54:09 +00001/*
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
24#include <common.h>
25#include <mpc8xx.h>
26
27flash_info_t flash_info[CFG_MAX_FLASH_BANKS]; /* info for FLASH chips */
28
29/*-----------------------------------------------------------------------
30 * Functions
31 */
32static ulong flash_get_size (vu_long *addr, flash_info_t *info);
33static int write_word (flash_info_t *info, ulong dest, ulong data);
34static void flash_get_offsets (ulong base, flash_info_t *info);
35
36/*-----------------------------------------------------------------------
37 */
38
39unsigned long flash_init (void)
40{
41 unsigned long size_b0, size_b1;
42 int i;
43
44 /* Init: no FLASHes known */
45 for (i=0; i < CFG_MAX_FLASH_BANKS; ++i)
46 flash_info[i].flash_id = FLASH_UNKNOWN;
47
48 /* Detect size */
49 size_b0 = flash_get_size((vu_long *)CFG_FLASH_BASE, &flash_info[0]);
50
51 /* Setup offsets */
52 flash_get_offsets (CFG_FLASH_BASE, &flash_info[0]);
53
54#if CFG_MONITOR_BASE >= CFG_FLASH_BASE
55 /* Monitor protection ON by default */
56 flash_protect(FLAG_PROTECT_SET,
57 CFG_MONITOR_BASE,
58 CFG_MONITOR_BASE+monitor_flash_len-1,
59 &flash_info[0]);
60#endif
61
62 size_b1 = 0 ;
63
64 flash_info[1].flash_id = FLASH_UNKNOWN;
65 flash_info[1].sector_count = -1;
66
67 flash_info[0].size = size_b0;
68 flash_info[1].size = size_b1;
69
70 return (size_b0 + size_b1);
71}
72
73/*-----------------------------------------------------------------------
74 * Fix this to support variable sector sizes
75*/
76static void flash_get_offsets (ulong base, flash_info_t *info)
77{
78 int i;
79
80 /* set up sector start address table */
81 if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040) {
82 /* set sector offsets for bottom boot block type */
83 for (i = 0; i < info->sector_count; i++)
84 info->start[i] = base + (i * 0x00010000);
85 }
86}
87
88/*-----------------------------------------------------------------------
89 */
90void flash_print_info (flash_info_t *info)
91{
92 int i;
93
94 if (info->flash_id == FLASH_UNKNOWN)
95 {
96 puts ("missing or unknown FLASH type\n");
97 return;
98 }
99
100 switch (info->flash_id & FLASH_VENDMASK)
101 {
102 case FLASH_MAN_AMD: printf ("AMD "); break;
103 case FLASH_MAN_FUJ: printf ("FUJITSU "); break;
104 case FLASH_MAN_BM: printf ("BRIGHT MICRO "); break;
105 default: printf ("Unknown Vendor "); break;
106 }
107
108 switch (info->flash_id & FLASH_TYPEMASK)
109 {
110 case FLASH_AM040: printf ("29F040 or 29LV040 (4 Mbit, uniform sectors)\n");
111 break;
112 case FLASH_AM400B: printf ("AM29LV400B (4 Mbit, bottom boot sect)\n");
113 break;
114 case FLASH_AM400T: printf ("AM29LV400T (4 Mbit, top boot sector)\n");
115 break;
116 case FLASH_AM800B: printf ("AM29LV800B (8 Mbit, bottom boot sect)\n");
117 break;
118 case FLASH_AM800T: printf ("AM29LV800T (8 Mbit, top boot sector)\n");
119 break;
120 case FLASH_AM160B: printf ("AM29LV160B (16 Mbit, bottom boot sect)\n");
121 break;
122 case FLASH_AM160T: printf ("AM29LV160T (16 Mbit, top boot sector)\n");
123 break;
124 case FLASH_AM320B: printf ("AM29LV320B (32 Mbit, bottom boot sect)\n");
125 break;
126 case FLASH_AM320T: printf ("AM29LV320T (32 Mbit, top boot sector)\n");
127 break;
128 default: printf ("Unknown Chip Type\n");
129 break;
130 }
131
132 if (info->size >> 20) {
133 printf (" Size: %ld MB in %d Sectors\n",
134 info->size >> 20,
135 info->sector_count);
136 } else {
137 printf (" Size: %ld KB in %d Sectors\n",
138 info->size >> 10,
139 info->sector_count);
140 }
141
142 puts (" Sector Start Addresses:");
143
144 for (i=0; i<info->sector_count; ++i)
145 {
146 if ((i % 5) == 0)
147 {
148 puts ("\n ");
149 }
150
151 printf (" %08lX%s",
152 info->start[i],
153 info->protect[i] ? " (RO)" : " ");
154 }
155
156 putc ('\n');
157 return;
158}
159/*-----------------------------------------------------------------------
160 */
161
162/*
163 * The following code cannot be run from FLASH!
164 */
165
166static ulong flash_get_size (vu_long *addr, flash_info_t *info)
167{
168 short i;
169 volatile unsigned char *caddr;
170 char value;
171
172 caddr = (volatile unsigned char *)addr ;
173
174 /* Write auto select command: read Manufacturer ID */
175
176#if 0
177 printf("Base address is: %08x\n", caddr);
178#endif
179
180 caddr[0x0555] = 0xAA;
181 caddr[0x02AA] = 0x55;
182 caddr[0x0555] = 0x90;
183
184 value = caddr[0];
185
186#if 0
187 printf("Manufact ID: %02x\n", value);
188#endif
189 switch (value)
190 {
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200191 case 0x01: /*AMD_MANUFACT*/
wdenk682011f2003-06-03 23:54:09 +0000192 info->flash_id = FLASH_MAN_AMD;
193 break;
194
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200195 case 0x04: /*FUJ_MANUFACT*/
wdenk682011f2003-06-03 23:54:09 +0000196 info->flash_id = FLASH_MAN_FUJ;
197 break;
198
199 default:
200 info->flash_id = FLASH_UNKNOWN;
201 info->sector_count = 0;
202 info->size = 0;
203 break;
204 }
205
206 value = caddr[1]; /* device ID */
207#if 0
208 printf("Device ID: %02x\n", value);
209#endif
210 switch (value)
211 {
212 case AMD_ID_LV040B:
213 info->flash_id += FLASH_AM040;
214 info->sector_count = 8;
215 info->size = 0x00080000;
216 break; /* => 512Kb */
217
218 default:
219 info->flash_id = FLASH_UNKNOWN;
220 return (0); /* => no or unknown flash */
221
222 }
223
224 flash_get_offsets ((ulong)addr, &flash_info[0]);
225
226 /* check for protected sectors */
227 for (i = 0; i < info->sector_count; i++)
228 {
229 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
230 /* D0 = 1 if protected */
231 caddr = (volatile unsigned char *)(info->start[i]);
232 info->protect[i] = caddr[2] & 1;
233 }
234
235 /*
236 * Prevent writes to uninitialized FLASH.
237 */
238 if (info->flash_id != FLASH_UNKNOWN)
239 {
240 caddr = (volatile unsigned char *)info->start[0];
241 *caddr = 0xF0; /* reset bank */
242 }
243
244 return (info->size);
245}
246
247
248/*-----------------------------------------------------------------------
249 */
250
251int flash_erase (flash_info_t *info, int s_first, int s_last)
252{
253 volatile unsigned char *addr = (volatile unsigned char *)(info->start[0]);
254 int flag, prot, sect, l_sect;
255 ulong start, now, last;
256
257 if ((s_first < 0) || (s_first > s_last)) {
258 if (info->flash_id == FLASH_UNKNOWN) {
259 printf ("- missing\n");
260 } else {
261 printf ("- no sectors to erase\n");
262 }
263 return 1;
264 }
265
266 if ((info->flash_id == FLASH_UNKNOWN) ||
267 (info->flash_id > FLASH_AMD_COMP)) {
268 printf ("Can't erase unknown flash type - aborted\n");
269 return 1;
270 }
271
272 prot = 0;
273 for (sect=s_first; sect<=s_last; ++sect) {
274 if (info->protect[sect]) {
275 prot++;
276 }
277 }
278
279 if (prot) {
280 printf ("- Warning: %d protected sectors will not be erased!\n",
281 prot);
282 } else {
283 printf ("\n");
284 }
285
286 l_sect = -1;
287
288 /* Disable interrupts which might cause a timeout here */
289 flag = disable_interrupts();
290
291 addr[0x0555] = 0xAA;
292 addr[0x02AA] = 0x55;
293 addr[0x0555] = 0x80;
294 addr[0x0555] = 0xAA;
295 addr[0x02AA] = 0x55;
296
297 /* Start erase on unprotected sectors */
298 for (sect = s_first; sect<=s_last; sect++) {
299 if (info->protect[sect] == 0) { /* not protected */
300 addr = (volatile unsigned char *)(info->start[sect]);
301 addr[0] = 0x30;
302 l_sect = sect;
303 }
304 }
305
306 /* re-enable interrupts if necessary */
307 if (flag)
308 enable_interrupts();
309
310 /* wait at least 80us - let's wait 1 ms */
311 udelay (1000);
312
313 /*
314 * We wait for the last triggered sector
315 */
316 if (l_sect < 0)
317 goto DONE;
318
319 start = get_timer (0);
320 last = start;
321 addr = (volatile unsigned char *)(info->start[l_sect]);
322
323 while ((addr[0] & 0xFF) != 0xFF)
324 {
325 if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
326 printf ("Timeout\n");
327 return 1;
328 }
329 /* show that we're waiting */
330 if ((now - last) > 1000) { /* every second */
331 putc ('.');
332 last = now;
333 }
334 }
335
336DONE:
337 /* reset to read mode */
338 addr = (volatile unsigned char *)info->start[0];
339
340 addr[0] = 0xF0; /* reset bank */
341
342 printf (" done\n");
343 return 0;
344}
345
346/*-----------------------------------------------------------------------
347 * Copy memory to flash, returns:
348 * 0 - OK
349 * 1 - write timeout
350 * 2 - Flash not erased
351 */
352
353int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
354{
355 ulong cp, wp, data;
356 int i, l, rc;
357
358 wp = (addr & ~3); /* get lower word aligned address */
359
360 /*
361 * handle unaligned start bytes
362 */
363 if ((l = addr - wp) != 0) {
364 data = 0;
365 for (i=0, cp=wp; i<l; ++i, ++cp) {
366 data = (data << 8) | (*(uchar *)cp);
367 }
368 for (; i<4 && cnt>0; ++i) {
369 data = (data << 8) | *src++;
370 --cnt;
371 ++cp;
372 }
373 for (; cnt==0 && i<4; ++i, ++cp) {
374 data = (data << 8) | (*(uchar *)cp);
375 }
376
377 if ((rc = write_word(info, wp, data)) != 0) {
378 return (rc);
379 }
380 wp += 4;
381 }
382
383 /*
384 * handle word aligned part
385 */
386 while (cnt >= 4) {
387 data = 0;
388 for (i=0; i<4; ++i) {
389 data = (data << 8) | *src++;
390 }
391 if ((rc = write_word(info, wp, data)) != 0) {
392 return (rc);
393 }
394 wp += 4;
395 cnt -= 4;
396 }
397
398 if (cnt == 0) {
399 return (0);
400 }
401
402 /*
403 * handle unaligned tail bytes
404 */
405 data = 0;
406 for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
407 data = (data << 8) | *src++;
408 --cnt;
409 }
410 for (; i<4; ++i, ++cp) {
411 data = (data << 8) | (*(uchar *)cp);
412 }
413
414 return (write_word(info, wp, data));
415}
416
417/*-----------------------------------------------------------------------
418 * Write a word to Flash, returns:
419 * 0 - OK
420 * 1 - write timeout
421 * 2 - Flash not erased
422 */
423static int write_word (flash_info_t *info, ulong dest, ulong data)
424{
425 volatile unsigned char *addr = (volatile unsigned char*)(info->start[0]),
426 *cdest,*cdata;
427 ulong start;
428 int flag, count = 4 ;
429
430 cdest = (volatile unsigned char *)dest ;
431 cdata = (volatile unsigned char *)&data ;
432
433 /* Check if Flash is (sufficiently) erased */
434 if ((*((vu_long *)dest) & data) != data) {
435 return (2);
436 }
437
438 while(count--)
439 {
440 /* Disable interrupts which might cause a timeout here */
441 flag = disable_interrupts();
442
443 addr[0x0555] = 0xAA;
444 addr[0x02AA] = 0x55;
445 addr[0x0555] = 0xA0;
446
447 *cdest = *cdata;
448
449 /* re-enable interrupts if necessary */
450 if (flag)
451 enable_interrupts();
452
453 /* data polling for D7 */
454 start = get_timer (0);
455 while ((*cdest ^ *cdata) & 0x80)
456 {
457 if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
458 return (1);
459 }
460 }
461
462 cdata++ ;
463 cdest++ ;
464 }
465 return (0);
466}
467
468/*-----------------------------------------------------------------------
469 */