← Back to branch summary

~ubuntu-branches/ubuntu/maverick/u-boot-omap3/maverick

« back to all changes in this revision

Viewing changes to board/Marvell/common/flash.c

  • Committer: Bazaar Package Importer
  • Author(s): Oliver Grawert
  • Date: 2010-03-22 15:06:23 UTC
  • Revision ID: james.westby@ubuntu.com-20100322150623-i21g8rgiyl5dohag
Tags: upstream-2010.3git20100315
Import upstream version 2010.3git20100315

Show diffs side-by-side

added added

removed removed

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