← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/board/Marvell/common/flash.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/board/Marvell/common/flash.c
 
1
/*
 
2
 * (C) Copyright 2001
 
3
 * Josh Huber <huber@mclx.com>, Mission Critical Linux, Inc.
 
4
 *
 
5
 * SPDX-License-Identifier:     GPL-2.0+
 
6
 */
 
7
 
 
8
/*
 
9
 * flash.c - flash support for the 512k, 8bit boot flash
 
10
        and the 8MB 32bit extra flash on the DB64360
 
11
 *           most of this file was based on the existing U-Boot
 
12
 *           flash drivers.
 
13
 *
 
14
 * written or collected and sometimes rewritten by
 
15
 * Ingo Assmus <ingo.assmus@keymile.com>
 
16
 *
 
17
 */
 
18
 
 
19
#include <common.h>
 
20
#include <mpc8xx.h>
 
21
#include "../include/mv_gen_reg.h"
 
22
#include "../include/memory.h"
 
23
#include "intel_flash.h"
 
24
 
 
25
#define FLASH_ROM       0xFFFD  /* unknown flash type                   */
 
26
#define FLASH_RAM       0xFFFE  /* unknown flash type                   */
 
27
#define FLASH_MAN_UNKNOWN 0xFFFF0000
 
28
 
 
29
/* #define DEBUG */
 
30
 
 
31
/* Intel flash commands */
 
32
int flash_erase_intel (flash_info_t * info, int s_first, int s_last);
 
33
int write_word_intel (bank_addr_t addr, bank_word_t value);
 
34
 
 
35
flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];    /* info for FLASH chips */
 
36
 
 
37
/*-----------------------------------------------------------------------
 
38
 * Functions
 
39
 */
 
40
static ulong flash_get_size (int portwidth, vu_long * addr,
 
41
                             flash_info_t * info);
 
42
static int write_word (flash_info_t * info, ulong dest, ulong data);
 
43
static void flash_get_offsets (ulong base, flash_info_t * info);
 
44
 
 
45
/*-----------------------------------------------------------------------
 
46
 */
 
47
 
 
48
unsigned long flash_init (void)
 
49
{
 
50
        unsigned int i;
 
51
        unsigned long size_b0 = 0, size_b1 = 0;
 
52
        unsigned long base, flash_size;
 
53
 
 
54
        /* Init: no FLASHes known */
 
55
        for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
 
56
                flash_info[i].flash_id = FLASH_UNKNOWN;
 
57
        }
 
58
 
 
59
        /* the boot flash */
 
60
        base = CONFIG_SYS_FLASH_BASE;
 
61
        size_b0 =
 
62
                flash_get_size (CONFIG_SYS_BOOT_FLASH_WIDTH, (vu_long *) base,
 
63
                                &flash_info[0]);
 
64
 
 
65
        printf ("[%ldkB@%lx] ", size_b0 / 1024, base);
 
66
 
 
67
        if (flash_info[0].flash_id == FLASH_UNKNOWN) {
 
68
                printf ("## Unknown FLASH at %08lx: Size = 0x%08lx = %ld MB\n", base, size_b0, size_b0 << 20);
 
69
        }
 
70
 
 
71
        base = memoryGetDeviceBaseAddress (CONFIG_SYS_EXTRA_FLASH_DEVICE);
 
72
/*      base = memoryGetDeviceBaseAddress(DEV_CS3_BASE_ADDR);*/
 
73
        for (i = 1; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
 
74
                unsigned long size =
 
75
                        flash_get_size (CONFIG_SYS_EXTRA_FLASH_WIDTH,
 
76
                                        (vu_long *) base, &flash_info[i]);
 
77
 
 
78
                printf ("[%ldMB@%lx] ", size >> 20, base);
 
79
 
 
80
                if (flash_info[i].flash_id == FLASH_UNKNOWN) {
 
81
                        if (i == 1) {
 
82
                                printf ("## Unknown FLASH at %08lx: Size = 0x%08lx = %ld MB\n", base, size_b1, size_b1 << 20);
 
83
                        }
 
84
                        break;
 
85
                }
 
86
                size_b1 += size;
 
87
                base += size;
 
88
        }
 
89
 
 
90
        flash_size = size_b0 + size_b1;
 
91
        return flash_size;
 
92
}
 
93
 
 
94
/*-----------------------------------------------------------------------
 
95
 */
 
96
static void flash_get_offsets (ulong base, flash_info_t * info)
 
97
{
 
98
        int i;
 
99
        int sector_size;
 
100
 
 
101
        if (!info->sector_count)
 
102
                return;
 
103
 
 
104
        /* set up sector start address table */
 
105
        switch (info->flash_id & FLASH_TYPEMASK) {
 
106
        case FLASH_AM040:
 
107
        case FLASH_28F128J3A:
 
108
        case FLASH_28F640J3A:
 
109
        case FLASH_RAM:
 
110
                /* this chip has uniformly spaced sectors */
 
111
                sector_size = info->size / info->sector_count;
 
112
                for (i = 0; i < info->sector_count; i++)
 
113
                        info->start[i] = base + (i * sector_size);
 
114
                break;
 
115
        default:
 
116
                if (info->flash_id & FLASH_BTYPE) {
 
117
                        /* set sector offsets for bottom boot block type    */
 
118
                        info->start[0] = base + 0x00000000;
 
119
                        info->start[1] = base + 0x00008000;
 
120
                        info->start[2] = base + 0x0000C000;
 
121
                        info->start[3] = base + 0x00010000;
 
122
                        for (i = 4; i < info->sector_count; i++) {
 
123
                                info->start[i] =
 
124
                                        base + (i * 0x00020000) - 0x00060000;
 
125
                        }
 
126
                } else {
 
127
                        /* set sector offsets for top boot block type               */
 
128
                        i = info->sector_count - 1;
 
129
                        info->start[i--] = base + info->size - 0x00008000;
 
130
                        info->start[i--] = base + info->size - 0x0000C000;
 
131
                        info->start[i--] = base + info->size - 0x00010000;
 
132
                        for (; i >= 0; i--) {
 
133
                                info->start[i] = base + i * 0x00020000;
 
134
                        }
 
135
                }
 
136
        }
 
137
}
 
138
 
 
139
/*-----------------------------------------------------------------------
 
140
 */
 
141
void flash_print_info (flash_info_t * info)
 
142
{
 
143
        int i;
 
144
 
 
145
        if (info->flash_id == FLASH_UNKNOWN) {
 
146
                printf ("missing or unknown FLASH type\n");
 
147
                return;
 
148
        }
 
149
 
 
150
        switch (info->flash_id & FLASH_VENDMASK) {
 
151
        case FLASH_MAN_STM:
 
152
                printf ("STM ");
 
153
                break;
 
154
        case FLASH_MAN_AMD:
 
155
                printf ("AMD ");
 
156
                break;
 
157
        case FLASH_MAN_FUJ:
 
158
                printf ("FUJITSU ");
 
159
                break;
 
160
        case FLASH_MAN_INTEL:
 
161
                printf ("INTEL ");
 
162
                break;
 
163
        default:
 
164
                printf ("Unknown Vendor ");
 
165
                break;
 
166
        }
 
167
 
 
168
        switch (info->flash_id & FLASH_TYPEMASK) {
 
169
        case FLASH_AM040:
 
170
                printf ("AM29LV040B (4 Mbit, bottom boot sect)\n");
 
171
                break;
 
172
        case FLASH_AM400B:
 
173
                printf ("AM29LV400B (4 Mbit, bottom boot sect)\n");
 
174
                break;
 
175
        case FLASH_AM400T:
 
176
                printf ("AM29LV400T (4 Mbit, top boot sector)\n");
 
177
                break;
 
178
        case FLASH_AM800B:
 
179
                printf ("AM29LV800B (8 Mbit, bottom boot sect)\n");
 
180
                break;
 
181
        case FLASH_AM800T:
 
182
                printf ("AM29LV800T (8 Mbit, top boot sector)\n");
 
183
                break;
 
184
        case FLASH_AM160B:
 
185
                printf ("AM29LV160B (16 Mbit, bottom boot sect)\n");
 
186
                break;
 
187
        case FLASH_AM160T:
 
188
                printf ("AM29LV160T (16 Mbit, top boot sector)\n");
 
189
                break;
 
190
        case FLASH_AM320B:
 
191
                printf ("AM29LV320B (32 Mbit, bottom boot sect)\n");
 
192
                break;
 
193
        case FLASH_AM320T:
 
194
                printf ("AM29LV320T (32 Mbit, top boot sector)\n");
 
195
                break;
 
196
        case FLASH_28F640J3A:
 
197
                printf ("28F640J3A (64 Mbit)\n");
 
198
                break;
 
199
        case FLASH_28F128J3A:
 
200
                printf ("28F128J3A (128 Mbit)\n");
 
201
                break;
 
202
        case FLASH_ROM:
 
203
                printf ("ROM\n");
 
204
                break;
 
205
        case FLASH_RAM:
 
206
                printf ("RAM\n");
 
207
                break;
 
208
        default:
 
209
                printf ("Unknown Chip Type\n");
 
210
                break;
 
211
        }
 
212
 
 
213
        if ((info->size >> 20) > 0) {
 
214
                printf ("  Size: %ld MB in %d Sectors\n",
 
215
                        info->size >> 20, info->sector_count);
 
216
        } else {
 
217
                printf ("  Size: %ld kB in %d Sectors\n",
 
218
                        info->size >> 10, info->sector_count);
 
219
        }
 
220
 
 
221
        printf ("  Sector Start Addresses:");
 
222
        for (i = 0; i < info->sector_count; ++i) {
 
223
                if ((i % 5) == 0)
 
224
                        printf ("\n   ");
 
225
                printf (" %08lX%s",
 
226
                        info->start[i], info->protect[i] ? " (RO)" : "     ");
 
227
        }
 
228
        printf ("\n");
 
229
        return;
 
230
}
 
231
 
 
232
/*-----------------------------------------------------------------------
 
233
 */
 
234
 
 
235
 
 
236
/*-----------------------------------------------------------------------
 
237
 */
 
238
 
 
239
/*
 
240
 * The following code cannot be run from FLASH!
 
241
 */
 
242
 
 
243
static inline void flash_cmd (int width, volatile unsigned char *addr,
 
244
                              int offset, unsigned char cmd)
 
245
{
 
246
        /* supports 1x8, 1x16, and 2x16 */
 
247
        /* 2x8 and 4x8 are not supported */
 
248
        if (width == 4) {
 
249
                /* assuming chips are in 16 bit mode */
 
250
                /* 2x16 */
 
251
                unsigned long cmd32 = (cmd << 16) | cmd;
 
252
 
 
253
                *(volatile unsigned long *) (addr + offset * 2) = cmd32;
 
254
        } else {
 
255
                /* 1x16 or 1x8 */
 
256
                *(volatile unsigned char *) (addr + offset) = cmd;
 
257
        }
 
258
}
 
259
 
 
260
static ulong
 
261
flash_get_size (int portwidth, vu_long * addr, flash_info_t * info)
 
262
{
 
263
        short i;
 
264
        volatile unsigned char *caddr = (unsigned char *) addr;
 
265
        volatile unsigned short *saddr = (unsigned short *) addr;
 
266
        volatile unsigned long *laddr = (unsigned long *) addr;
 
267
        char old[2], save;
 
268
        ulong id = 0, manu = 0, base = (ulong) addr;
 
269
 
 
270
#ifdef DEBUG
 
271
        printf ("%s: enter\n", __FUNCTION__);
 
272
#endif
 
273
        info->portwidth = portwidth;
 
274
 
 
275
        save = *caddr;
 
276
 
 
277
        flash_cmd (portwidth, caddr, 0, 0xf0);
 
278
        flash_cmd (portwidth, caddr, 0, 0xf0);
 
279
 
 
280
        udelay (10);
 
281
 
 
282
        old[0] = caddr[0];
 
283
        old[1] = caddr[1];
 
284
 
 
285
 
 
286
        if (old[0] != 0xf0) {
 
287
                flash_cmd (portwidth, caddr, 0, 0xf0);
 
288
                flash_cmd (portwidth, caddr, 0, 0xf0);
 
289
 
 
290
                udelay (10);
 
291
 
 
292
                if (*caddr == 0xf0) {
 
293
                        /* this area is ROM */
 
294
                        *caddr = save;
 
295
                        info->flash_id = FLASH_ROM + FLASH_MAN_UNKNOWN;
 
296
                        info->sector_count = 8;
 
297
                        info->size = 0x80000;
 
298
                        flash_get_offsets (base, info);
 
299
                        return info->size;
 
300
                }
 
301
        } else {
 
302
                *caddr = 0;
 
303
 
 
304
                udelay (10);
 
305
 
 
306
                if (*caddr == 0) {
 
307
                        /* this area is RAM */
 
308
                        *caddr = save;
 
309
                        info->flash_id = FLASH_RAM + FLASH_MAN_UNKNOWN;
 
310
                        info->sector_count = 8;
 
311
                        info->size = 0x80000;
 
312
                        flash_get_offsets (base, info);
 
313
                        return info->size;
 
314
                }
 
315
                flash_cmd (portwidth, caddr, 0, 0xf0);
 
316
 
 
317
                udelay (10);
 
318
        }
 
319
 
 
320
        /* Write auto select command: read Manufacturer ID */
 
321
        flash_cmd (portwidth, caddr, 0x555, 0xAA);
 
322
        flash_cmd (portwidth, caddr, 0x2AA, 0x55);
 
323
        flash_cmd (portwidth, caddr, 0x555, 0x90);
 
324
 
 
325
        udelay (10);
 
326
 
 
327
        if ((caddr[0] == old[0]) && (caddr[1] == old[1])) {
 
328
 
 
329
                /* this area is ROM */
 
330
                info->flash_id = FLASH_ROM + FLASH_MAN_UNKNOWN;
 
331
                info->sector_count = 8;
 
332
                info->size = 0x80000;
 
333
                flash_get_offsets (base, info);
 
334
                return info->size;
 
335
#ifdef DEBUG
 
336
        } else {
 
337
                printf ("%px%d: %02x:%02x -> %02x:%02x\n",
 
338
                        caddr, portwidth, old[0], old[1], caddr[0], caddr[1]);
 
339
#endif
 
340
        }
 
341
 
 
342
        switch (portwidth) {
 
343
        case 1:
 
344
                manu = caddr[0];
 
345
                manu |= manu << 16;
 
346
                id = caddr[1];
 
347
                break;
 
348
        case 2:
 
349
                manu = saddr[0];
 
350
                manu |= manu << 16;
 
351
                id = saddr[1];
 
352
                id |= id << 16;
 
353
                break;
 
354
        case 4:
 
355
                manu = laddr[0];
 
356
                id = laddr[1];
 
357
                break;
 
358
        }
 
359
 
 
360
#ifdef DEBUG
 
361
        flash_cmd (portwidth, caddr, 0, 0xf0);
 
362
 
 
363
        printf ("\n%08lx:%08lx:%08lx\n", base, manu, id);
 
364
        printf ("%08lx %08lx %08lx %08lx\n",
 
365
                laddr[0], laddr[1], laddr[2], laddr[3]);
 
366
#endif
 
367
 
 
368
        switch (manu) {
 
369
        case STM_MANUFACT:
 
370
                info->flash_id = FLASH_MAN_STM;
 
371
                break;
 
372
        case AMD_MANUFACT:
 
373
                info->flash_id = FLASH_MAN_AMD;
 
374
                break;
 
375
        case FUJ_MANUFACT:
 
376
                info->flash_id = FLASH_MAN_FUJ;
 
377
                break;
 
378
        case INTEL_MANUFACT:
 
379
                info->flash_id = FLASH_MAN_INTEL;
 
380
                break;
 
381
        default:
 
382
                flash_cmd (portwidth, caddr, 0, 0xf0);
 
383
 
 
384
                printf ("Unknown Mfr [%08lx]:%08lx\n", manu, id);
 
385
                info->flash_id = FLASH_UNKNOWN;
 
386
                info->sector_count = 0;
 
387
                info->size = 0;
 
388
                return (0);     /* no or unknown flash  */
 
389
        }
 
390
 
 
391
        switch (id) {
 
392
        case AMD_ID_LV400T:
 
393
                info->flash_id += FLASH_AM400T;
 
394
                info->sector_count = 11;
 
395
                info->size = 0x00100000;
 
396
                info->chipwidth = 1;
 
397
                break;          /* => 1 MB      */
 
398
 
 
399
        case AMD_ID_LV400B:
 
400
                info->flash_id += FLASH_AM400B;
 
401
                info->sector_count = 11;
 
402
                info->size = 0x00100000;
 
403
                info->chipwidth = 1;
 
404
                break;          /* => 1 MB      */
 
405
 
 
406
        case AMD_ID_LV800T:
 
407
                info->flash_id += FLASH_AM800T;
 
408
                info->sector_count = 19;
 
409
                info->size = 0x00200000;
 
410
                info->chipwidth = 1;
 
411
                break;          /* => 2 MB      */
 
412
 
 
413
        case AMD_ID_LV800B:
 
414
                info->flash_id += FLASH_AM800B;
 
415
                info->sector_count = 19;
 
416
                info->size = 0x00200000;
 
417
                info->chipwidth = 1;
 
418
                break;          /* => 2 MB      */
 
419
 
 
420
        case AMD_ID_LV160T:
 
421
                info->flash_id += FLASH_AM160T;
 
422
                info->sector_count = 35;
 
423
                info->size = 0x00400000;
 
424
                info->chipwidth = 1;
 
425
                break;          /* => 4 MB      */
 
426
 
 
427
        case AMD_ID_LV160B:
 
428
                info->flash_id += FLASH_AM160B;
 
429
                info->sector_count = 35;
 
430
                info->size = 0x00400000;
 
431
                info->chipwidth = 1;
 
432
                break;          /* => 4 MB      */
 
433
#if 0                           /* enable when device IDs are available */
 
434
        case AMD_ID_LV320T:
 
435
                info->flash_id += FLASH_AM320T;
 
436
                info->sector_count = 67;
 
437
                info->size = 0x00800000;
 
438
                break;          /* => 8 MB      */
 
439
 
 
440
        case AMD_ID_LV320B:
 
441
                info->flash_id += FLASH_AM320B;
 
442
                info->sector_count = 67;
 
443
                info->size = 0x00800000;
 
444
                break;          /* => 8 MB      */
 
445
#endif
 
446
        case AMD_ID_LV040B:
 
447
                info->flash_id += FLASH_AM040;
 
448
                info->sector_count = 8;
 
449
                info->size = 0x80000;
 
450
                info->chipwidth = 1;
 
451
                break;          /* => 512 kB    */
 
452
 
 
453
        case INTEL_ID_28F640J3A:
 
454
                info->flash_id += FLASH_28F640J3A;
 
455
                info->sector_count = 64;
 
456
                info->size = 128 * 1024 * 64;   /* 128kbytes x 64 blocks */
 
457
                info->chipwidth = 2;
 
458
                if (portwidth == 4)
 
459
                        info->size *= 2;        /* 2x16 */
 
460
                break;
 
461
 
 
462
        case INTEL_ID_28F128J3A:
 
463
                info->flash_id += FLASH_28F128J3A;
 
464
                info->sector_count = 128;
 
465
                info->size = 128 * 1024 * 128;  /* 128kbytes x 128 blocks */
 
466
                info->chipwidth = 2;
 
467
                if (portwidth == 4)
 
468
                        info->size *= 2;        /* 2x16 */
 
469
                break;
 
470
 
 
471
        default:
 
472
                flash_cmd (portwidth, caddr, 0, 0xf0);
 
473
 
 
474
                printf ("Unknown id %lx:[%lx]\n", manu, id);
 
475
                info->flash_id = FLASH_UNKNOWN;
 
476
                info->chipwidth = 1;
 
477
                return (0);     /* => no or unknown flash */
 
478
 
 
479
        }
 
480
 
 
481
        flash_get_offsets (base, info);
 
482
 
 
483
 
 
484
        /* check for protected sectors */
 
485
        for (i = 0; i < info->sector_count; i++) {
 
486
                /* read sector protection at sector address, (A7 .. A0)=0x02 */
 
487
                /* D0 = 1 if protected */
 
488
                caddr = (volatile unsigned char *) (info->start[i]);
 
489
                saddr = (volatile unsigned short *) (info->start[i]);
 
490
                laddr = (volatile unsigned long *) (info->start[i]);
 
491
                if (portwidth == 1)
 
492
                        info->protect[i] = caddr[2] & 1;
 
493
                else if (portwidth == 2)
 
494
                        info->protect[i] = saddr[2] & 1;
 
495
                else
 
496
                        info->protect[i] = laddr[2] & 1;
 
497
        }
 
498
 
 
499
        /*
 
500
         * Prevent writes to uninitialized FLASH.
 
501
         */
 
502
        if (info->flash_id != FLASH_UNKNOWN) {
 
503
                caddr = (volatile unsigned char *) info->start[0];
 
504
 
 
505
                flash_cmd (portwidth, caddr, 0, 0xF0);  /* reset bank */
 
506
        }
 
507
 
 
508
        return (info->size);
 
509
}
 
510
 
 
511
int flash_erase (flash_info_t * info, int s_first, int s_last)
 
512
{
 
513
        volatile unsigned char *addr = (uchar *) (info->start[0]);
 
514
        int flag, prot, sect, l_sect;
 
515
        ulong start, now, last;
 
516
 
 
517
/* modified to support 2x16 Intel flash */
 
518
/* Note that the code will not exit on a flash erasure error or timeout */
 
519
/* but will print and error message and continue processing sectors */
 
520
/* until they are all erased. */
 
521
/* 10-16-2002 P. Marchese */
 
522
        ulong mask;
 
523
        int timeout;
 
524
 
 
525
        if (info->portwidth == 4)
 
526
/*              {
 
527
                printf ("- Warning: erasing of 32Bit (2*16Bit i.e. 2*28F640J3A) not supported yet !!!! \n");
 
528
                return 1;
 
529
                }*/
 
530
        {
 
531
                /* make sure it's Intel flash */
 
532
                if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL) {
 
533
                        /* yup! it's an Intel flash */
 
534
                        /* is it 16-bits wide? */
 
535
                        if (info->chipwidth == 2) {
 
536
                                /* yup! it's 16-bits wide */
 
537
                                /* are there any sectors to process? */
 
538
                                if ((s_first < 0) || (s_first > s_last)) {
 
539
                                        printf ("Error:  There are no sectors to erase\n");
 
540
                                        printf ("Either sector %d is less than zero\n", s_first);
 
541
                                        printf ("or sector %d is greater than sector %d\n", s_first, s_last);
 
542
                                        return 1;
 
543
                                }
 
544
                                /* check for protected sectors */
 
545
                                prot = 0;
 
546
                                for (sect = s_first; sect <= s_last; ++sect)
 
547
                                        if (info->protect[sect])
 
548
                                                prot++;
 
549
                                /* if variable "prot" is nonzero, there are protected sectors */
 
550
                                if (prot)
 
551
                                        printf ("- Warning: %d protected sectors will not be erased!\n", prot);
 
552
                                /* reset the flash */
 
553
                                flash_cmd (info->portwidth, addr, 0,
 
554
                                           CHIP_CMD_RST);
 
555
                                /* Disable interrupts which might cause a timeout here */
 
556
                                flag = disable_interrupts ();
 
557
                                /* Clear the status register */
 
558
                                flash_cmd (info->portwidth, addr, 0,
 
559
                                           CHIP_CMD_CLR_STAT);
 
560
                                flash_cmd (info->portwidth, addr, 0,
 
561
                                           CHIP_CMD_RST);
 
562
                                /* Start erase on unprotected sectors */
 
563
                                for (sect = s_first; sect <= s_last; sect++) {
 
564
                                        /* is the sector unprotected? */
 
565
                                        if (info->protect[sect] == 0) { /* not protected */
 
566
                                                /* issue the single block erase command, 0x20 */
 
567
                                                flash_cmd (info->portwidth,
 
568
                                                           (volatile unsigned
 
569
                                                            char *) info->
 
570
                                                           start[sect], 0,
 
571
                                                           CHIP_CMD_ERASE1);
 
572
                                                /* issue the erase confirm command, 0xD0 */
 
573
                                                flash_cmd (info->portwidth,
 
574
                                                           (volatile unsigned
 
575
                                                            char *) info->
 
576
                                                           start[sect], 0,
 
577
                                                           CHIP_CMD_ERASE2);
 
578
                                                l_sect = sect;
 
579
                                                /* re-enable interrupts if necessary */
 
580
                                                if (flag)
 
581
                                                        enable_interrupts ();
 
582
                                                /* poll for erasure completion */
 
583
                                                /* put flash into read status mode by writing 0x70 to it */
 
584
                                                flash_cmd (info->portwidth,
 
585
                                                           addr, 0,
 
586
                                                           CHIP_CMD_RD_STAT);
 
587
                                                /* setup the status register mask */
 
588
                                                mask = CHIP_STAT_RDY |
 
589
                                                        (CHIP_STAT_RDY << 16);
 
590
                                                /* init. the timeout counter */
 
591
                                                start = get_timer (0);
 
592
                                                /* keep looping while the flash is not ready */
 
593
                                                /* exit the loop by timing out or the flash */
 
594
                                                /* becomes ready again */
 
595
                                                timeout = 0;
 
596
                                                while ((*
 
597
                                                        (volatile unsigned
 
598
                                                         long *) info->
 
599
                                                        start[sect] & mask) !=
 
600
                                                       mask) {
 
601
                                                        /* has the timeout limit been reached? */
 
602
                                                        if (get_timer (start)
 
603
                                                            >
 
604
                                                            CONFIG_SYS_FLASH_ERASE_TOUT)
 
605
                                                        {
 
606
                                                                /* timeout limit reached */
 
607
                                                                printf ("Time out limit reached erasing sector at address %08lx\n", info->start[sect]);
 
608
                                                                printf ("Continuing with next sector\n");
 
609
                                                                timeout = 1;
 
610
                                                                goto timed_out_error;
 
611
                                                        }
 
612
                                                        /* put flash into read status mode by writing 0x70 to it */
 
613
                                                        flash_cmd (info->
 
614
                                                                   portwidth,
 
615
                                                                   addr, 0,
 
616
                                                                   CHIP_CMD_RD_STAT);
 
617
                                                }
 
618
                                                /* did we timeout? */
 
619
                                              timed_out_error:if (timeout == 0)
 
620
                                                {
 
621
                                                        /* didn't timeout, so check the status register */
 
622
                                                        /* create the status mask to check for errors */
 
623
                                                        mask = CHIP_STAT_ECLBS;
 
624
                                                        mask = mask | (mask <<
 
625
                                                                       16);
 
626
                                                        /* put flash into read status mode by writing 0x70 to it */
 
627
                                                        flash_cmd (info->
 
628
                                                                   portwidth,
 
629
                                                                   addr, 0,
 
630
                                                                   CHIP_CMD_RD_STAT);
 
631
                                                        /* are there any errors? */
 
632
                                                        if ((*
 
633
                                                             (volatile
 
634
                                                              unsigned long *)
 
635
                                                             info->
 
636
                                                             start[sect] &
 
637
                                                             mask) != 0) {
 
638
                                                                /* We got an erasure error */
 
639
                                                                printf ("Flash erasure error at address 0x%08lx\n", info->start[sect]);
 
640
                                                                printf ("Continuing with next sector\n");
 
641
                                                                /* reset the flash */
 
642
                                                                flash_cmd
 
643
                                                                        (info->
 
644
                                                                         portwidth,
 
645
                                                                         addr,
 
646
                                                                         0,
 
647
                                                                         CHIP_CMD_RST);
 
648
                                                        }
 
649
                                                }
 
650
                                                /* erasure completed without errors */
 
651
                                                /* reset the flash */
 
652
                                                flash_cmd (info->portwidth,
 
653
                                                           addr, 0,
 
654
                                                           CHIP_CMD_RST);
 
655
                                        }       /* end if not protected */
 
656
                                }       /* end for loop */
 
657
                                printf ("Flash erasure done\n");
 
658
                                return 0;
 
659
                        } else {
 
660
                                /* The Intel flash is not 16-bit wide */
 
661
                                /* print and error message and return */
 
662
                                /* NOTE: you can add routines here to handle other size flash */
 
663
                                printf ("Error: Intel flash device is only %d-bits wide\n", info->chipwidth * 8);
 
664
                                printf ("The erasure code only handles Intel 16-bit wide flash memory\n");
 
665
                                return 1;
 
666
                        }
 
667
                } else {
 
668
                        /* Not Intel flash so return an error as a write timeout */
 
669
                        /* NOTE: if it's another type flash, stick its routine here */
 
670
                        printf ("Error: The flash device is not Intel type\n");
 
671
                        printf ("The erasure code only supports Intel flash in a 32-bit port width\n");
 
672
                        return 1;
 
673
                }
 
674
        }
 
675
 
 
676
        /* end 32-bit wide flash code */
 
677
        if ((info->flash_id & FLASH_TYPEMASK) == FLASH_ROM)
 
678
                return 1;       /* Rom can not be erased */
 
679
        if ((info->flash_id & FLASH_TYPEMASK) == FLASH_RAM) {   /* RAM just copy 0s to RAM */
 
680
                for (sect = s_first; sect <= s_last; sect++) {
 
681
                        int sector_size = info->size / info->sector_count;
 
682
 
 
683
                        addr = (uchar *) (info->start[sect]);
 
684
                        memset ((void *) addr, 0, sector_size);
 
685
                }
 
686
                return 0;
 
687
        }
 
688
 
 
689
        if ((s_first < 0) || (s_first > s_last)) {
 
690
                if (info->flash_id == FLASH_UNKNOWN) {
 
691
                        printf ("- missing\n");
 
692
                } else {
 
693
                        printf ("- no sectors to erase\n");
 
694
                }
 
695
                return 1;
 
696
        }
 
697
 
 
698
        if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL) {     /* Intel works spezial */
 
699
                return flash_erase_intel (info,
 
700
                                          (unsigned short) s_first,
 
701
                                          (unsigned short) s_last);
 
702
        }
 
703
#if 0
 
704
        if ((info->flash_id == FLASH_UNKNOWN) ||        /* Flash is unknown to PPCBoot */
 
705
            (info->flash_id > FLASH_AMD_COMP)) {
 
706
                printf ("Can't erase unknown flash type %08lx - aborted\n",
 
707
                        info->flash_id);
 
708
                return 1;
 
709
        }
 
710
#endif
 
711
 
 
712
        prot = 0;
 
713
        for (sect = s_first; sect <= s_last; ++sect) {
 
714
                if (info->protect[sect]) {
 
715
                        prot++;
 
716
                }
 
717
        }
 
718
 
 
719
        if (prot) {
 
720
                printf ("- Warning: %d protected sectors will not be erased!\n", prot);
 
721
        } else {
 
722
                printf ("\n");
 
723
        }
 
724
 
 
725
        l_sect = -1;
 
726
 
 
727
        /* Disable interrupts which might cause a timeout here */
 
728
        flag = disable_interrupts ();
 
729
 
 
730
        flash_cmd (info->portwidth, addr, 0x555, 0xAA); /* start erase routine */
 
731
        flash_cmd (info->portwidth, addr, 0x2AA, 0x55);
 
732
        flash_cmd (info->portwidth, addr, 0x555, 0x80);
 
733
        flash_cmd (info->portwidth, addr, 0x555, 0xAA);
 
734
        flash_cmd (info->portwidth, addr, 0x2AA, 0x55);
 
735
 
 
736
        /* Start erase on unprotected sectors */
 
737
        for (sect = s_first; sect <= s_last; sect++) {
 
738
                if (info->protect[sect] == 0) { /* not protected */
 
739
                        addr = (uchar *) (info->start[sect]);
 
740
                        flash_cmd (info->portwidth, addr, 0, 0x30);
 
741
                        l_sect = sect;
 
742
                }
 
743
        }
 
744
 
 
745
        /* re-enable interrupts if necessary */
 
746
        if (flag)
 
747
                enable_interrupts ();
 
748
 
 
749
        /* wait at least 80us - let's wait 1 ms */
 
750
        udelay (1000);
 
751
 
 
752
        /*
 
753
         * We wait for the last triggered sector
 
754
         */
 
755
        if (l_sect < 0)
 
756
                goto DONE;
 
757
 
 
758
        start = get_timer (0);
 
759
        last = start;
 
760
        addr = (volatile unsigned char *) (info->start[l_sect]);
 
761
        /* broken for 2x16: TODO */
 
762
        while ((addr[0] & 0x80) != 0x80) {
 
763
                if ((now = get_timer (start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
 
764
                        printf ("Timeout\n");
 
765
                        return 1;
 
766
                }
 
767
                /* show that we're waiting */
 
768
                if ((now - last) > 1000) {      /* every second */
 
769
                        putc ('.');
 
770
                        last = now;
 
771
                }
 
772
        }
 
773
 
 
774
      DONE:
 
775
        /* reset to read mode */
 
776
        addr = (volatile unsigned char *) info->start[0];
 
777
        flash_cmd (info->portwidth, addr, 0, 0xf0);
 
778
        flash_cmd (info->portwidth, addr, 0, 0xf0);
 
779
 
 
780
        printf (" done\n");
 
781
        return 0;
 
782
}
 
783
 
 
784
/*-----------------------------------------------------------------------
 
785
 * Copy memory to flash, returns:
 
786
 * 0 - OK
 
787
 * 1 - write timeout
 
788
 * 2 - Flash not erased
 
789
 */
 
790
 
 
791
/* broken for 2x16: TODO */
 
792
int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
 
793
{
 
794
        ulong cp, wp, data;
 
795
        int i, l, rc;
 
796
 
 
797
/* Commented out since the below code should work for 32-bit(2x 16 flash) */
 
798
/* 10-16-2002 P. Marchese */
 
799
/*      if(info->portwidth==4) return 1; */
 
800
/*      if(info->portwidth==4) {
 
801
                printf ("- Warning: writting of 32Bit (2*16Bit i.e. 2*28F640J3A) not supported yet !!!! \n");
 
802
                return 1;
 
803
                }*/
 
804
 
 
805
        if ((info->flash_id & FLASH_TYPEMASK) == FLASH_ROM)
 
806
                return 0;
 
807
        if ((info->flash_id & FLASH_TYPEMASK) == FLASH_RAM) {
 
808
                memcpy ((void *) addr, src, cnt);
 
809
                return 0;
 
810
        }
 
811
 
 
812
        wp = (addr & ~3);       /* get lower word aligned address */
 
813
 
 
814
        /*
 
815
         * handle unaligned start bytes
 
816
         */
 
817
        if ((l = addr - wp) != 0) {
 
818
                data = 0;
 
819
                for (i = 0, cp = wp; i < l; ++i, ++cp) {
 
820
                        data = (data << 8) | (*(uchar *) cp);
 
821
                }
 
822
                for (; i < 4 && cnt > 0; ++i) {
 
823
                        data = (data << 8) | *src++;
 
824
                        --cnt;
 
825
                        ++cp;
 
826
                }
 
827
                for (; cnt == 0 && i < 4; ++i, ++cp) {
 
828
                        data = (data << 8) | (*(uchar *) cp);
 
829
                }
 
830
 
 
831
                if ((rc = write_word (info, wp, data)) != 0) {
 
832
                        return (rc);
 
833
                }
 
834
                wp += 4;
 
835
        }
 
836
 
 
837
        /*
 
838
         * handle word aligned part
 
839
         */
 
840
        while (cnt >= 4) {
 
841
                data = 0;
 
842
                for (i = 0; i < 4; ++i) {
 
843
                        data = (data << 8) | *src++;
 
844
                }
 
845
                if ((rc = write_word (info, wp, data)) != 0) {
 
846
                        return (rc);
 
847
                }
 
848
                wp += 4;
 
849
                cnt -= 4;
 
850
        }
 
851
 
 
852
        if (cnt == 0) {
 
853
                return (0);
 
854
        }
 
855
 
 
856
        /*
 
857
         * handle unaligned tail bytes
 
858
         */
 
859
        data = 0;
 
860
        for (i = 0, cp = wp; i < 4 && cnt > 0; ++i, ++cp) {
 
861
                data = (data << 8) | *src++;
 
862
                --cnt;
 
863
        }
 
864
        for (; i < 4; ++i, ++cp) {
 
865
                data = (data << 8) | (*(uchar *) cp);
 
866
        }
 
867
 
 
868
        return (write_word (info, wp, data));
 
869
}
 
870
 
 
871
/*-----------------------------------------------------------------------
 
872
 * Write a word to Flash, returns:
 
873
 * 0 - OK
 
874
 * 1 - write timeout
 
875
 * 2 - Flash not erased
 
876
 */
 
877
/* broken for 2x16: TODO */
 
878
static int write_word (flash_info_t * info, ulong dest, ulong data)
 
879
{
 
880
        volatile unsigned char *addr = (uchar *) (info->start[0]);
 
881
        ulong start;
 
882
        int flag, i;
 
883
        ulong mask;
 
884
 
 
885
/* modified so that it handles 32-bit(2x16 Intel flash programming */
 
886
/* 10-16-2002 P. Marchese */
 
887
 
 
888
        if (info->portwidth == 4)
 
889
/*              {
 
890
                printf ("- Warning: writting of 32Bit (2*16Bit i.e. 2*28F640J3A) not supported yet !!!! \n");
 
891
                return 1;
 
892
                }*/
 
893
        {
 
894
                /* make sure it's Intel flash */
 
895
                if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL) {
 
896
                        /* yup! it's an Intel flash */
 
897
                        /* is it 16-bits wide? */
 
898
                        if (info->chipwidth == 2) {
 
899
                                /* yup! it's 16-bits wide */
 
900
                                /* so we know how to program it */
 
901
                                /* reset the flash */
 
902
                                flash_cmd (info->portwidth, addr, 0,
 
903
                                           CHIP_CMD_RST);
 
904
                                /* Disable interrupts which might cause a timeout here */
 
905
                                flag = disable_interrupts ();
 
906
                                /* Clear the status register */
 
907
                                flash_cmd (info->portwidth, addr, 0,
 
908
                                           CHIP_CMD_CLR_STAT);
 
909
                                flash_cmd (info->portwidth, addr, 0,
 
910
                                           CHIP_CMD_RST);
 
911
                                /* 1st cycle of word/byte program */
 
912
                                /* write 0x40 to the location to program */
 
913
                                flash_cmd (info->portwidth, (uchar *) dest, 0,
 
914
                                           CHIP_CMD_PROG);
 
915
                                /* 2nd cycle of word/byte program */
 
916
                                /* write the data to the destination address */
 
917
                                *(ulong *) dest = data;
 
918
                                /* re-enable interrupts if necessary */
 
919
                                if (flag)
 
920
                                        enable_interrupts ();
 
921
                                /* setup the status register mask */
 
922
                                mask = CHIP_STAT_RDY | (CHIP_STAT_RDY << 16);
 
923
                                /* put flash into read status mode by writing 0x70 to it */
 
924
                                flash_cmd (info->portwidth, addr, 0,
 
925
                                           CHIP_CMD_RD_STAT);
 
926
                                /* init. the timeout counter */
 
927
                                start = get_timer (0);
 
928
                                /* keep looping while the flash is not ready */
 
929
                                /* exit the loop by timing out or the flash */
 
930
                                /* becomes ready again */
 
931
/* 11-13-2002 Paul Marchese */
 
932
/* modified while loop conditional statement */
 
933
/* because we were always timing out.  */
 
934
/* there is a type mismatch, "addr[0]" */
 
935
/* returns a byte but "mask" is a 32-bit value */
 
936
                                while ((*(volatile unsigned long *) info->
 
937
                                        start[0] & mask) != mask)
 
938
/* original code */
 
939
/* while (addr[0] & mask) != mask) */
 
940
                                {
 
941
                                        /* has the timeout limit been reached? */
 
942
                                        if (get_timer (start) >
 
943
                                            CONFIG_SYS_FLASH_WRITE_TOUT) {
 
944
                                                /* timeout limit reached */
 
945
                                                printf ("Time out limit reached programming address %08lx with data %08lx\n", dest, data);
 
946
                                                /* reset the flash */
 
947
                                                flash_cmd (info->portwidth,
 
948
                                                           addr, 0,
 
949
                                                           CHIP_CMD_RST);
 
950
                                                return (1);
 
951
                                        }
 
952
                                        /* put flash into read status mode by writing 0x70 to it */
 
953
                                        flash_cmd (info->portwidth, addr, 0,
 
954
                                                   CHIP_CMD_RD_STAT);
 
955
                                }
 
956
                                /* flash is ready, so check the status */
 
957
                                /* create the status mask to check for errors */
 
958
                                mask = CHIP_STAT_DPS | CHIP_STAT_VPPS |
 
959
                                        CHIP_STAT_PSLBS;
 
960
                                mask = mask | (mask << 16);
 
961
                                /* put flash into read status mode by writing 0x70 to it */
 
962
                                flash_cmd (info->portwidth, addr, 0,
 
963
                                           CHIP_CMD_RD_STAT);
 
964
                                /* are there any errors? */
 
965
                                if ((addr[0] & mask) != 0) {
 
966
                                        /* We got a one of the following errors: */
 
967
                                        /* Voltage range, Device protect, or programming */
 
968
                                        /* return the error as a device timeout */
 
969
                                        /* put flash into read status mode by writing 0x70 to it */
 
970
                                        flash_cmd (info->portwidth, addr, 0,
 
971
                                                   CHIP_CMD_RD_STAT);
 
972
                                        printf ("Flash programming error at address 0x%08lx\n", dest);
 
973
                                        printf ("Flash status register contains 0x%08lx\n", (unsigned long) addr[0]);
 
974
                                        /* reset the flash */
 
975
                                        flash_cmd (info->portwidth, addr, 0,
 
976
                                                   CHIP_CMD_RST);
 
977
                                        return 1;
 
978
                                }
 
979
                                /* write completed without errors */
 
980
                                /* reset the flash */
 
981
                                flash_cmd (info->portwidth, addr, 0,
 
982
                                           CHIP_CMD_RST);
 
983
                                return 0;
 
984
                        } else {
 
985
                                /* it's not 16-bits wide, so return an error as a write timeout */
 
986
                                /* NOTE: you can add routines here to handle other size flash */
 
987
                                printf ("Error: Intel flash device is only %d-bits wide\n", info->chipwidth * 8);
 
988
                                printf ("The write code only handles Intel 16-bit wide flash memory\n");
 
989
                                return 1;
 
990
                        }
 
991
                } else {
 
992
                        /* not Intel flash so return an error as a write timeout */
 
993
                        /* NOTE: if it's another type flash, stick its routine here */
 
994
                        printf ("Error: The flash device is not Intel type\n");
 
995
                        printf ("The code only supports Intel flash in a 32-bit port width\n");
 
996
                        return 1;
 
997
                }
 
998
        }
 
999
 
 
1000
        /* end of 32-bit flash code */
 
1001
        if ((info->flash_id & FLASH_TYPEMASK) == FLASH_ROM)
 
1002
                return 1;
 
1003
        if ((info->flash_id & FLASH_TYPEMASK) == FLASH_RAM) {
 
1004
                *(unsigned long *) dest = data;
 
1005
                return 0;
 
1006
        }
 
1007
        if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL) {
 
1008
                unsigned short low = data & 0xffff;
 
1009
                unsigned short hi = (data >> 16) & 0xffff;
 
1010
                int ret = write_word_intel ((bank_addr_t) dest, hi);
 
1011
 
 
1012
                if (!ret)
 
1013
                        ret = write_word_intel ((bank_addr_t) (dest + 2),
 
1014
                                                low);
 
1015
 
 
1016
                return ret;
 
1017
        }
 
1018
 
 
1019
        /* Check if Flash is (sufficiently) erased */
 
1020
        if ((*((vu_long *) dest) & data) != data) {
 
1021
                return (2);
 
1022
        }
 
1023
        /* Disable interrupts which might cause a timeout here */
 
1024
        flag = disable_interrupts ();
 
1025
 
 
1026
        /* first, perform an unlock bypass command to speed up flash writes */
 
1027
        addr[0x555] = 0xAA;
 
1028
        addr[0x2AA] = 0x55;
 
1029
        addr[0x555] = 0x20;
 
1030
 
 
1031
        /* write each byte out */
 
1032
        for (i = 0; i < 4; i++) {
 
1033
                char *data_ch = (char *) &data;
 
1034
 
 
1035
                addr[0] = 0xA0;
 
1036
                *(((char *) dest) + i) = data_ch[i];
 
1037
                udelay (10);    /* XXX */
 
1038
        }
 
1039
 
 
1040
        /* we're done, now do an unlock bypass reset */
 
1041
        addr[0] = 0x90;
 
1042
        addr[0] = 0x00;
 
1043
 
 
1044
        /* re-enable interrupts if necessary */
 
1045
        if (flag)
 
1046
                enable_interrupts ();
 
1047
 
 
1048
        /* data polling for D7 */
 
1049
        start = get_timer (0);
 
1050
        while ((*((vu_long *) dest) & 0x00800080) != (data & 0x00800080)) {
 
1051
                if (get_timer (start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
 
1052
                        return (1);
 
1053
                }
 
1054
        }
 
1055
        return (0);
 
1056
}