blob: d3122edf21c828463b92350977ca55ed88bff4f1 [file] [log] [blame]
wdenk5b1d7132002-11-03 00:07:02 +00001/*
2 * (C) Copyright 2001
3 * Josh Huber <huber@mclx.com>, Mission Critical Linux, Inc.
4 *
5 * (C) Copyright 2002
6 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
7 *
8 * Adapted for Interphase 4539 by Wolfgang Grandegger <wg@denx.de>.
9 *
Wolfgang Denk1a459662013-07-08 09:37:19 +020010 * SPDX-License-Identifier: GPL-2.0+
wdenk5b1d7132002-11-03 00:07:02 +000011 */
12
13#include <config.h>
14#include <common.h>
15#include <flash.h>
16#include <asm/io.h>
17
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020018flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
wdenk5b1d7132002-11-03 00:07:02 +000019
20extern int hwc_flash_size(void);
21static ulong flash_get_size (u32 addr, flash_info_t *info);
22static int flash_get_offsets (u32 base, flash_info_t *info);
23static int write_word (flash_info_t *info, ulong dest, ulong data);
24static void flash_reset (u32 addr);
25
26#define out8(a,v) *(volatile unsigned char*)(a) = v
27#define in8(a) *(volatile unsigned char*)(a)
28#define in32(a) *(volatile unsigned long*)(a)
29#define iobarrier_rw() eieio()
30
31unsigned long flash_init (void)
32{
33 unsigned int i;
34 unsigned long flash_size = 0;
35 unsigned long bank_size;
36 unsigned int bank = 0;
37
38 /* Init: no FLASHes known */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020039 for (i=0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
wdenk5b1d7132002-11-03 00:07:02 +000040 flash_info[i].flash_id = FLASH_UNKNOWN;
41 flash_info[i].sector_count = 0;
42 flash_info[i].size = 0;
43 }
44
45 /* Initialise the BOOT Flash */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020046 if (bank == CONFIG_SYS_MAX_FLASH_BANKS) {
wdenk5b1d7132002-11-03 00:07:02 +000047 puts ("Warning: not all Flashes are initialised !");
48 return flash_size;
49 }
50
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020051 bank_size = flash_get_size (CONFIG_SYS_FLASH_BASE, flash_info + bank);
wdenk5b1d7132002-11-03 00:07:02 +000052 if (bank_size) {
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020053#if CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH_BASE && \
54 CONFIG_SYS_MONITOR_BASE < CONFIG_SYS_FLASH_BASE + CONFIG_SYS_MAX_FLASH_SIZE
wdenk5b1d7132002-11-03 00:07:02 +000055 /* monitor protection ON by default */
56 flash_protect(FLAG_PROTECT_SET,
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020057 CONFIG_SYS_MONITOR_BASE,
58 CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1,
wdenk5b1d7132002-11-03 00:07:02 +000059 flash_info + bank);
60#endif
61
Jean-Christophe PLAGNIOL-VILLARD5a1aceb2008-09-10 22:48:04 +020062#ifdef CONFIG_ENV_IS_IN_FLASH
wdenk5b1d7132002-11-03 00:07:02 +000063 /* ENV protection ON by default */
64 flash_protect(FLAG_PROTECT_SET,
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +020065 CONFIG_ENV_ADDR,
66 CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1,
wdenk5b1d7132002-11-03 00:07:02 +000067 flash_info + bank);
68#endif
69
70 /* HWC protection ON by default */
71 flash_protect(FLAG_PROTECT_SET,
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020072 CONFIG_SYS_FLASH_BASE,
73 CONFIG_SYS_FLASH_BASE + 0x10000 - 1,
wdenk5b1d7132002-11-03 00:07:02 +000074 flash_info + bank);
75
76 flash_size += bank_size;
77 bank++;
78 } else {
79 puts ("Warning: the BOOT Flash is not initialised !");
80 }
81
82 return flash_size;
83}
84
85/*
86 * The following code cannot be run from FLASH!
87 */
88static ulong flash_get_size (u32 addr, flash_info_t *info)
89{
90 volatile uchar value;
91#if 0
92 int i;
93#endif
94
95 /* Write auto select command: read Manufacturer ID */
96 out8(addr + 0x0555, 0xAA);
97 iobarrier_rw();
98 udelay(10);
99 out8(addr + 0x02AA, 0x55);
100 iobarrier_rw();
101 udelay(10);
102 out8(addr + 0x0555, 0x90);
103 iobarrier_rw();
104 udelay(10);
105
106 value = in8(addr);
107 iobarrier_rw();
108 udelay(10);
109 switch (value | (value << 16)) {
110 case AMD_MANUFACT:
111 info->flash_id = FLASH_MAN_AMD;
112 break;
113
114 case FUJ_MANUFACT:
115 info->flash_id = FLASH_MAN_FUJ;
116 break;
117
118 default:
119 info->flash_id = FLASH_UNKNOWN;
120 flash_reset (addr);
121 return 0;
122 }
123
124 value = in8(addr + 1); /* device ID */
125 iobarrier_rw();
126
127 switch (value) {
128 case AMD_ID_LV033C:
129 info->flash_id += FLASH_AM033C;
130 info->size = hwc_flash_size();
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200131 if (info->size > CONFIG_SYS_MAX_FLASH_SIZE) {
wdenk5b1d7132002-11-03 00:07:02 +0000132 printf("U-Boot supports only %d MB\n",
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200133 CONFIG_SYS_MAX_FLASH_SIZE);
134 info->size = CONFIG_SYS_MAX_FLASH_SIZE;
wdenk5b1d7132002-11-03 00:07:02 +0000135 }
136 info->sector_count = info->size / 0x10000;
137 break; /* => 4 MB */
138
139 default:
140 info->flash_id = FLASH_UNKNOWN;
141 flash_reset (addr);
142 return (0); /* => no or unknown flash */
143
144 }
145
146 if (!flash_get_offsets (addr, info)) {
147 flash_reset (addr);
148 return 0;
149 }
150
151#if 0
152 /* check for protected sectors */
153 for (i = 0; i < info->sector_count; i++) {
154 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
155 /* D0 = 1 if protected */
156 value = in8(info->start[i] + 2);
157 iobarrier_rw();
158 info->protect[i] = (value & 1) != 0;
159 }
160#endif
161
162 /*
163 * Reset bank to read mode
164 */
165 flash_reset (addr);
166
167 return (info->size);
168}
169
170static int flash_get_offsets (u32 base, flash_info_t *info)
171{
172 unsigned int i, size;
173
174 switch (info->flash_id & FLASH_TYPEMASK) {
175 case FLASH_AM033C:
176 /* set sector offsets for uniform sector type */
177 size = info->size / info->sector_count;
178 for (i = 0; i < info->sector_count; i++) {
179 info->start[i] = base + i * size;
180 }
181 break;
182 default:
183 return 0;
184 }
185
186 return 1;
187}
188
189int flash_erase (flash_info_t *info, int s_first, int s_last)
190{
191 volatile u32 addr = info->start[0];
192 int flag, prot, sect, l_sect;
193 ulong start, now, last;
194
195 if (s_first < 0 || s_first > s_last) {
196 if (info->flash_id == FLASH_UNKNOWN) {
197 printf ("- missing\n");
198 } else {
199 printf ("- no sectors to erase\n");
200 }
201 return 1;
202 }
203
204 if (info->flash_id == FLASH_UNKNOWN ||
205 info->flash_id > FLASH_AMD_COMP) {
206 printf ("Can't erase unknown flash type %08lx - aborted\n",
207 info->flash_id);
208 return 1;
209 }
210
211 prot = 0;
212 for (sect=s_first; sect<=s_last; ++sect) {
213 if (info->protect[sect]) {
214 prot++;
215 }
216 }
217
218 if (prot) {
219 printf ("- Warning: %d protected sectors will not be erased!\n",
220 prot);
221 } else {
222 printf ("\n");
223 }
224
225 l_sect = -1;
226
227 /* Disable interrupts which might cause a timeout here */
228 flag = disable_interrupts();
229
230 out8(addr + 0x555, 0xAA);
231 iobarrier_rw();
232 out8(addr + 0x2AA, 0x55);
233 iobarrier_rw();
234 out8(addr + 0x555, 0x80);
235 iobarrier_rw();
236 out8(addr + 0x555, 0xAA);
237 iobarrier_rw();
238 out8(addr + 0x2AA, 0x55);
239 iobarrier_rw();
240
241 /* Start erase on unprotected sectors */
242 for (sect = s_first; sect<=s_last; sect++) {
243 if (info->protect[sect] == 0) { /* not protected */
244 addr = info->start[sect];
245 out8(addr, 0x30);
246 iobarrier_rw();
247 l_sect = sect;
248 }
249 }
250
251 /* re-enable interrupts if necessary */
252 if (flag)
253 enable_interrupts();
254
255 /* wait at least 80us - let's wait 1 ms */
256 udelay (1000);
257
258 /*
259 * We wait for the last triggered sector
260 */
261 if (l_sect < 0)
262 goto DONE;
263
264 start = get_timer (0);
265 last = start;
266 addr = info->start[l_sect];
267 while ((in8(addr) & 0x80) != 0x80) {
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200268 if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
wdenk5b1d7132002-11-03 00:07:02 +0000269 printf ("Timeout\n");
270 return 1;
271 }
272 /* show that we're waiting */
273 if ((now - last) > 1000) { /* every second */
274 putc ('.');
275 last = now;
276 }
277 iobarrier_rw();
278 }
279
280DONE:
281 /* reset to read mode */
282 flash_reset (info->start[0]);
283
284 printf (" done\n");
285 return 0;
286}
287
288/*
289 * Copy memory to flash, returns:
290 * 0 - OK
291 * 1 - write timeout
292 * 2 - Flash not erased
293 */
294int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
295{
296 ulong cp, wp, data;
297 int i, l, rc;
298
299 wp = (addr & ~3); /* get lower word aligned address */
300
301 /*
302 * handle unaligned start bytes
303 */
304 if ((l = addr - wp) != 0) {
305 data = 0;
306 for (i=0, cp=wp; i<l; ++i, ++cp) {
307 data = (data << 8) | (*(uchar *)cp);
308 }
309 for (; i<4 && cnt>0; ++i) {
310 data = (data << 8) | *src++;
311 --cnt;
312 ++cp;
313 }
314 for (; cnt==0 && i<4; ++i, ++cp) {
315 data = (data << 8) | (*(uchar *)cp);
316 }
317
318 if ((rc = write_word(info, wp, data)) != 0) {
319 return (rc);
320 }
321 wp += 4;
322 }
323
324 /*
325 * handle word aligned part
326 */
327 while (cnt >= 4) {
328 data = 0;
329 for (i=0; i<4; ++i) {
330 data = (data << 8) | *src++;
331 }
332 if ((rc = write_word(info, wp, data)) != 0) {
333 return (rc);
334 }
335 wp += 4;
336 cnt -= 4;
337 }
338
339 if (cnt == 0) {
340 return (0);
341 }
342
343 /*
344 * handle unaligned tail bytes
345 */
346 data = 0;
347 for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
348 data = (data << 8) | *src++;
349 --cnt;
350 }
351 for (; i<4; ++i, ++cp) {
352 data = (data << 8) | (*(uchar *)cp);
353 }
354
355 return (write_word(info, wp, data));
356}
357
358/*
359 * Write a word to Flash, returns:
360 * 0 - OK
361 * 1 - write timeout
362 * 2 - Flash not erased
363 */
364static int write_word (flash_info_t *info, ulong dest, ulong data)
365{
366 volatile u32 addr = info->start[0];
367 ulong start;
368 int flag, i;
369
370 /* Check if Flash is (sufficiently) erased */
371 if ((in32(dest) & data) != data) {
372 return (2);
373 }
374 /* Disable interrupts which might cause a timeout here */
375 flag = disable_interrupts();
376
377 /* first, perform an unlock bypass command to speed up flash writes */
378 out8(addr + 0x555, 0xAA);
379 iobarrier_rw();
380 out8(addr + 0x2AA, 0x55);
381 iobarrier_rw();
382 out8(addr + 0x555, 0x20);
383 iobarrier_rw();
384
385 /* write each byte out */
386 for (i = 0; i < 4; i++) {
387 char *data_ch = (char *)&data;
388 out8(addr, 0xA0);
389 iobarrier_rw();
390 out8(dest+i, data_ch[i]);
391 iobarrier_rw();
392 udelay(10); /* XXX */
393 }
394
395 /* we're done, now do an unlock bypass reset */
396 out8(addr, 0x90);
397 iobarrier_rw();
398 out8(addr, 0x00);
399 iobarrier_rw();
400
401 /* re-enable interrupts if necessary */
402 if (flag)
403 enable_interrupts();
404
405 /* data polling for D7 */
406 start = get_timer (0);
407 while ((in32(dest) & 0x80808080) != (data & 0x80808080)) {
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200408 if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
wdenk5b1d7132002-11-03 00:07:02 +0000409 return (1);
410 }
411 iobarrier_rw();
412 }
413
414 flash_reset (addr);
415
416 return (0);
417}
418
419/*
420 * Reset bank to read mode
421 */
422static void flash_reset (u32 addr)
423{
424 out8(addr, 0xF0); /* reset bank */
425 iobarrier_rw();
426}
427
428void flash_print_info (flash_info_t *info)
429{
430 int i;
431
432 if (info->flash_id == FLASH_UNKNOWN) {
433 printf ("missing or unknown FLASH type\n");
434 return;
435 }
436
437 switch (info->flash_id & FLASH_VENDMASK) {
438 case FLASH_MAN_AMD: printf ("AMD "); break;
439 case FLASH_MAN_FUJ: printf ("FUJITSU "); break;
440 case FLASH_MAN_BM: printf ("BRIGHT MICRO "); break;
441 default: printf ("Unknown Vendor "); break;
442 }
443
444 switch (info->flash_id & FLASH_TYPEMASK) {
445 case FLASH_AM033C: printf ("AM29LV033C (32 Mbit, uniform sectors)\n");
446 break;
447 default: printf ("Unknown Chip Type\n");
448 break;
449 }
450
451 if (info->size % 0x100000 == 0) {
452 printf (" Size: %ld MB in %d Sectors\n",
453 info->size / 0x100000, info->sector_count);
454 }
455 else if (info->size % 0x400 == 0) {
456 printf (" Size: %ld KB in %d Sectors\n",
457 info->size / 0x400, info->sector_count);
458 }
459 else {
460 printf (" Size: %ld B in %d Sectors\n",
461 info->size, info->sector_count);
462 }
463
464 printf (" Sector Start Addresses:");
465 for (i=0; i<info->sector_count; ++i) {
466 if ((i % 5) == 0)
467 printf ("\n ");
468 printf (" %08lX%s",
469 info->start[i],
470 info->protect[i] ? " (RO)" : " "
471 );
472 }
473 printf ("\n");
474}