]> git.sur5r.net Git - u-boot/blob - board/at91rm9200dk/flash.c
ppc4xx: Update 44x_spd_ddr2 code (440SP/440SPe)
[u-boot] / board / at91rm9200dk / flash.c
1 /*
2  * (C) Copyright 2002
3  * Lineo, Inc. <www.lineo.com>
4  * Bernhard Kuhn <bkuhn@lineo.com>
5  *
6  * (C) Copyright 2002
7  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
8  * Alex Zuepke <azu@sysgo.de>
9  *
10  * See file CREDITS for list of people who contributed to this
11  * project.
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License as
15  * published by the Free Software Foundation; either version 2 of
16  * the License, or (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
26  * MA 02111-1307 USA
27  */
28
29 #include <common.h>
30
31 ulong myflush(void);
32
33
34 /* Flash Organization Structure */
35 typedef struct OrgDef
36 {
37         unsigned int sector_number;
38         unsigned int sector_size;
39 } OrgDef;
40
41
42 /* Flash Organizations */
43 OrgDef OrgAT49BV16x4[] =
44 {
45         {  8,  8*1024 },        /*   8 *  8 kBytes sectors */
46         {  2, 32*1024 },        /*   2 * 32 kBytes sectors */
47         { 30, 64*1024 },        /*  30 * 64 kBytes sectors */
48 };
49
50 OrgDef OrgAT49BV16x4A[] =
51 {
52         {  8,  8*1024 },        /*   8 *  8 kBytes sectors */
53         { 31, 64*1024 },        /*  31 * 64 kBytes sectors */
54 };
55
56 OrgDef OrgAT49BV6416[] =
57 {
58         {   8,  8*1024 },       /*   8 *  8 kBytes sectors */
59         { 127, 64*1024 },       /* 127 * 64 kBytes sectors */
60 };
61
62 flash_info_t    flash_info[CFG_MAX_FLASH_BANKS];
63
64 /* AT49BV1614A Codes */
65 #define FLASH_CODE1             0xAA
66 #define FLASH_CODE2             0x55
67 #define ID_IN_CODE              0x90
68 #define ID_OUT_CODE             0xF0
69
70
71 #define CMD_READ_ARRAY          0x00F0
72 #define CMD_UNLOCK1             0x00AA
73 #define CMD_UNLOCK2             0x0055
74 #define CMD_ERASE_SETUP         0x0080
75 #define CMD_ERASE_CONFIRM       0x0030
76 #define CMD_PROGRAM             0x00A0
77 #define CMD_UNLOCK_BYPASS       0x0020
78 #define CMD_SECTOR_UNLOCK       0x0070
79
80 #define MEM_FLASH_ADDR1         (*(volatile u16 *)(CFG_FLASH_BASE + (0x00005555<<1)))
81 #define MEM_FLASH_ADDR2         (*(volatile u16 *)(CFG_FLASH_BASE + (0x00002AAA<<1)))
82
83 #define BIT_ERASE_DONE          0x0080
84 #define BIT_RDY_MASK            0x0080
85 #define BIT_PROGRAM_ERROR       0x0020
86 #define BIT_TIMEOUT             0x80000000 /* our flag */
87
88 #define READY 1
89 #define ERR   2
90 #define TMO   4
91
92 /*-----------------------------------------------------------------------
93  */
94 void flash_identification (flash_info_t * info)
95 {
96         volatile u16 manuf_code, device_code, add_device_code;
97
98         MEM_FLASH_ADDR1 = FLASH_CODE1;
99         MEM_FLASH_ADDR2 = FLASH_CODE2;
100         MEM_FLASH_ADDR1 = ID_IN_CODE;
101
102         manuf_code = *(volatile u16 *) CFG_FLASH_BASE;
103         device_code = *(volatile u16 *) (CFG_FLASH_BASE + 2);
104         add_device_code = *(volatile u16 *) (CFG_FLASH_BASE + (3 << 1));
105
106         MEM_FLASH_ADDR1 = FLASH_CODE1;
107         MEM_FLASH_ADDR2 = FLASH_CODE2;
108         MEM_FLASH_ADDR1 = ID_OUT_CODE;
109
110         /* Vendor type */
111         info->flash_id = ATM_MANUFACT & FLASH_VENDMASK;
112         printf ("Atmel: ");
113
114         if ((device_code & FLASH_TYPEMASK) == (ATM_ID_BV1614 & FLASH_TYPEMASK)) {
115
116                 if ((add_device_code & FLASH_TYPEMASK) ==
117                         (ATM_ID_BV1614A & FLASH_TYPEMASK)) {
118                         info->flash_id |= ATM_ID_BV1614A & FLASH_TYPEMASK;
119                         printf ("AT49BV1614A (16Mbit)\n");
120                 } else {                                /* AT49BV1614 Flash */
121                         info->flash_id |= ATM_ID_BV1614 & FLASH_TYPEMASK;
122                         printf ("AT49BV1614 (16Mbit)\n");
123                 }
124
125         } else if ((device_code & FLASH_TYPEMASK) == (ATM_ID_BV6416 & FLASH_TYPEMASK)) {
126                 info->flash_id |= ATM_ID_BV6416 & FLASH_TYPEMASK;
127                 printf ("AT49BV6416 (64Mbit)\n");
128         }
129 }
130
131 ushort flash_number_sector(OrgDef *pOrgDef, unsigned int nb_blocks)
132 {
133         int i, nb_sectors = 0;
134
135         for (i=0; i<nb_blocks; i++){
136                 nb_sectors += pOrgDef[i].sector_number;
137         }
138
139         return nb_sectors;
140 }
141
142 void flash_unlock_sector(flash_info_t * info, unsigned int sector)
143 {
144         volatile u16 *addr = (volatile u16 *) (info->start[sector]);
145
146         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
147         *addr = CMD_SECTOR_UNLOCK;
148 }
149
150
151 ulong flash_init (void)
152 {
153         int i, j, k;
154         unsigned int flash_nb_blocks, sector;
155         unsigned int start_address;
156         OrgDef *pOrgDef;
157
158         ulong size = 0;
159
160         for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) {
161                 ulong flashbase = 0;
162
163                 flash_identification (&flash_info[i]);
164
165                 if ((flash_info[i].flash_id & FLASH_TYPEMASK) ==
166                         (ATM_ID_BV1614 & FLASH_TYPEMASK)) {
167
168                         pOrgDef = OrgAT49BV16x4;
169                         flash_nb_blocks = sizeof (OrgAT49BV16x4) / sizeof (OrgDef);
170                 } else if ((flash_info[i].flash_id & FLASH_TYPEMASK) ==
171                         (ATM_ID_BV1614A & FLASH_TYPEMASK)){     /* AT49BV1614A Flash */
172
173                         pOrgDef = OrgAT49BV16x4A;
174                         flash_nb_blocks = sizeof (OrgAT49BV16x4A) / sizeof (OrgDef);
175                 } else if ((flash_info[i].flash_id & FLASH_TYPEMASK) ==
176                         (ATM_ID_BV6416 & FLASH_TYPEMASK)){      /* AT49BV6416 Flash */
177
178                         pOrgDef = OrgAT49BV6416;
179                         flash_nb_blocks = sizeof (OrgAT49BV6416) / sizeof (OrgDef);
180                 } else {
181                         flash_nb_blocks = 0;
182                         pOrgDef = OrgAT49BV16x4;
183                 }
184
185                 flash_info[i].sector_count = flash_number_sector(pOrgDef, flash_nb_blocks);
186                 memset (flash_info[i].protect, 0, flash_info[i].sector_count);
187
188                 if (i == 0)
189                         flashbase = PHYS_FLASH_1;
190                 else
191                         panic ("configured too many flash banks!\n");
192
193                 sector = 0;
194                 start_address = flashbase;
195                 flash_info[i].size = 0;
196
197                 for (j = 0; j < flash_nb_blocks; j++) {
198                         for (k = 0; k < pOrgDef[j].sector_number; k++) {
199                                 flash_info[i].start[sector++] = start_address;
200                                 start_address += pOrgDef[j].sector_size;
201                                 flash_info[i].size += pOrgDef[j].sector_size;
202                         }
203                 }
204
205                 size += flash_info[i].size;
206
207                 if ((flash_info[i].flash_id & FLASH_TYPEMASK) ==
208                         (ATM_ID_BV6416 & FLASH_TYPEMASK)){      /* AT49BV6416 Flash */
209
210                         /* Unlock all sectors at reset */
211                         for (j=0; j<flash_info[i].sector_count; j++){
212                                 flash_unlock_sector(&flash_info[i], j);
213                         }
214                 }
215         }
216
217         /* Protect binary boot image */
218         flash_protect (FLAG_PROTECT_SET,
219                        CFG_FLASH_BASE,
220                        CFG_FLASH_BASE + CFG_BOOT_SIZE - 1, &flash_info[0]);
221
222         /* Protect environment variables */
223         flash_protect (FLAG_PROTECT_SET,
224                        CFG_ENV_ADDR,
225                        CFG_ENV_ADDR + CFG_ENV_SIZE - 1, &flash_info[0]);
226
227         /* Protect U-Boot gzipped image */
228         flash_protect (FLAG_PROTECT_SET,
229                        CFG_U_BOOT_BASE,
230                        CFG_U_BOOT_BASE + CFG_U_BOOT_SIZE - 1, &flash_info[0]);
231
232         return size;
233 }
234
235 /*-----------------------------------------------------------------------
236  */
237 void flash_print_info (flash_info_t * info)
238 {
239         int i;
240
241         switch (info->flash_id & FLASH_VENDMASK) {
242         case (ATM_MANUFACT & FLASH_VENDMASK):
243                 printf ("Atmel: ");
244                 break;
245         default:
246                 printf ("Unknown Vendor ");
247                 break;
248         }
249
250         switch (info->flash_id & FLASH_TYPEMASK) {
251         case (ATM_ID_BV1614 & FLASH_TYPEMASK):
252                 printf ("AT49BV1614 (16Mbit)\n");
253                 break;
254         case (ATM_ID_BV1614A & FLASH_TYPEMASK):
255                 printf ("AT49BV1614A (16Mbit)\n");
256                 break;
257         case (ATM_ID_BV6416 & FLASH_TYPEMASK):
258                 printf ("AT49BV6416 (64Mbit)\n");
259                 break;
260         default:
261                 printf ("Unknown Chip Type\n");
262                 return;
263         }
264
265         printf ("  Size: %ld MB in %d Sectors\n",
266                 info->size >> 20, info->sector_count);
267
268         printf ("  Sector Start Addresses:");
269         for (i = 0; i < info->sector_count; i++) {
270                 if ((i % 5) == 0) {
271                         printf ("\n   ");
272                 }
273                 printf (" %08lX%s", info->start[i],
274                         info->protect[i] ? " (RO)" : "     ");
275         }
276         printf ("\n");
277 }
278
279 /*-----------------------------------------------------------------------
280  */
281
282 int flash_erase (flash_info_t * info, int s_first, int s_last)
283 {
284         ulong result;
285         int iflag, cflag, prot, sect;
286         int rc = ERR_OK;
287         int chip1;
288
289         /* first look for protection bits */
290
291         if (info->flash_id == FLASH_UNKNOWN)
292                 return ERR_UNKNOWN_FLASH_TYPE;
293
294         if ((s_first < 0) || (s_first > s_last)) {
295                 return ERR_INVAL;
296         }
297
298         if ((info->flash_id & FLASH_VENDMASK) !=
299                 (ATM_MANUFACT & FLASH_VENDMASK)) {
300                 return ERR_UNKNOWN_FLASH_VENDOR;
301         }
302
303         prot = 0;
304         for (sect = s_first; sect <= s_last; ++sect) {
305                 if (info->protect[sect]) {
306                         prot++;
307                 }
308         }
309         if (prot)
310                 return ERR_PROTECTED;
311
312         /*
313          * Disable interrupts which might cause a timeout
314          * here. Remember that our exception vectors are
315          * at address 0 in the flash, and we don't want a
316          * (ticker) exception to happen while the flash
317          * chip is in programming mode.
318          */
319         cflag = icache_status ();
320         icache_disable ();
321         iflag = disable_interrupts ();
322
323         /* Start erase on unprotected sectors */
324         for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
325                 printf ("Erasing sector %2d ... ", sect);
326
327                 /* arm simple, non interrupt dependent timer */
328                 reset_timer_masked ();
329
330                 if (info->protect[sect] == 0) { /* not protected */
331                         volatile u16 *addr = (volatile u16 *) (info->start[sect]);
332
333                         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
334                         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
335                         MEM_FLASH_ADDR1 = CMD_ERASE_SETUP;
336
337                         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
338                         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
339                         *addr = CMD_ERASE_CONFIRM;
340
341                         /* wait until flash is ready */
342                         chip1 = 0;
343
344                         do {
345                                 result = *addr;
346
347                                 /* check timeout */
348                                 if (get_timer_masked () > CFG_FLASH_ERASE_TOUT) {
349                                         MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
350                                         chip1 = TMO;
351                                         break;
352                                 }
353
354                                 if (!chip1 && (result & 0xFFFF) & BIT_ERASE_DONE)
355                                         chip1 = READY;
356
357                         } while (!chip1);
358
359                         MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
360
361                         if (chip1 == ERR) {
362                                 rc = ERR_PROG_ERROR;
363                                 goto outahere;
364                         }
365                         if (chip1 == TMO) {
366                                 rc = ERR_TIMOUT;
367                                 goto outahere;
368                         }
369
370                         printf ("ok.\n");
371                 } else {                        /* it was protected */
372                         printf ("protected!\n");
373                 }
374         }
375
376         if (ctrlc ())
377                 printf ("User Interrupt!\n");
378
379 outahere:
380         /* allow flash to settle - wait 10 ms */
381         udelay_masked (10000);
382
383         if (iflag)
384                 enable_interrupts ();
385
386         if (cflag)
387                 icache_enable ();
388
389         return rc;
390 }
391
392 /*-----------------------------------------------------------------------
393  * Copy memory to flash
394  */
395
396 static int write_word (flash_info_t * info, ulong dest, ulong data)
397 {
398         volatile u16 *addr = (volatile u16 *) dest;
399         ulong result;
400         int rc = ERR_OK;
401         int cflag, iflag;
402         int chip1;
403
404         /*
405          * Check if Flash is (sufficiently) erased
406          */
407         result = *addr;
408         if ((result & data) != data)
409                 return ERR_NOT_ERASED;
410
411         /*
412          * Disable interrupts which might cause a timeout
413          * here. Remember that our exception vectors are
414          * at address 0 in the flash, and we don't want a
415          * (ticker) exception to happen while the flash
416          * chip is in programming mode.
417          */
418         cflag = icache_status ();
419         icache_disable ();
420         iflag = disable_interrupts ();
421
422         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
423         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
424         MEM_FLASH_ADDR1 = CMD_PROGRAM;
425         *addr = data;
426
427         /* arm simple, non interrupt dependent timer */
428         reset_timer_masked ();
429
430         /* wait until flash is ready */
431         chip1 = 0;
432         do {
433                 result = *addr;
434
435                 /* check timeout */
436                 if (get_timer_masked () > CFG_FLASH_ERASE_TOUT) {
437                         chip1 = ERR | TMO;
438                         break;
439                 }
440                 if (!chip1 && ((result & 0x80) == (data & 0x80)))
441                         chip1 = READY;
442
443         } while (!chip1);
444
445         *addr = CMD_READ_ARRAY;
446
447         if (chip1 == ERR || *addr != data)
448                 rc = ERR_PROG_ERROR;
449
450         if (iflag)
451                 enable_interrupts ();
452
453         if (cflag)
454                 icache_enable ();
455
456         return rc;
457 }
458
459 /*-----------------------------------------------------------------------
460  * Copy memory to flash.
461  */
462
463 int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
464 {
465         ulong wp, data;
466         int rc;
467
468         if (addr & 1) {
469                 printf ("unaligned destination not supported\n");
470                 return ERR_ALIGN;
471         };
472
473         if ((int) src & 1) {
474                 printf ("unaligned source not supported\n");
475                 return ERR_ALIGN;
476         };
477
478         wp = addr;
479
480         while (cnt >= 2) {
481                 data = *((volatile u16 *) src);
482                 if ((rc = write_word (info, wp, data)) != 0) {
483                         return (rc);
484                 }
485                 src += 2;
486                 wp += 2;
487                 cnt -= 2;
488         }
489
490         if (cnt == 1) {
491                 data = (*((volatile u8 *) src)) | (*((volatile u8 *) (wp + 1)) <<
492                                                                                    8);
493                 if ((rc = write_word (info, wp, data)) != 0) {
494                         return (rc);
495                 }
496                 src += 1;
497                 wp += 1;
498                 cnt -= 1;
499         };
500
501         return ERR_OK;
502 }