source: SVN/rincon/u-boot/board/idmr/flash.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 22 months ago

rincon: added latest u-boot source

restored form server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 7.3 KB
Line 
1/*
2 * (C) Copyright 2000-2006
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21 * MA 02111-1307 USA
22 */
23
24#include <common.h>
25
26#define PHYS_FLASH_1 CFG_FLASH_BASE
27#define FLASH_BANK_SIZE 0x800000
28#define EN29LV640 0x227e227e
29
30flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
31
32void flash_print_info (flash_info_t * info)
33{
34        int i;
35
36        switch (info->flash_id & FLASH_VENDMASK) {
37        case (AMD_MANUFACT & FLASH_VENDMASK):
38                printf ("AMD: ");
39                break;
40        default:
41                printf ("Unknown Vendor ");
42                break;
43        }
44
45        switch (info->flash_id & FLASH_TYPEMASK) {
46        case (EN29LV640 & FLASH_TYPEMASK):
47                printf ("EN29LV640 (16Mbit)\n");
48                break;
49        default:
50                printf ("Unknown Chip Type\n");
51                goto Done;
52                break;
53        }
54
55        printf ("  Size: %ld MB in %d Sectors\n",
56                info->size >> 20, info->sector_count);
57
58        printf ("  Sector Start Addresses:");
59        for (i = 0; i < info->sector_count; i++) {
60                if ((i % 5) == 0) {
61                        printf ("\n   ");
62                }
63                printf (" %08lX%s", info->start[i],
64                        info->protect[i] ? " (RO)" : "     ");
65        }
66        printf ("\n");
67
68      Done:
69        return;
70}
71
72
73unsigned long flash_init (void)
74{
75        int i, j;
76        ulong size = 0;
77
78        for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) {
79                ulong flashbase = 0;
80
81                flash_info[i].flash_id =
82                        (AMD_MANUFACT & FLASH_VENDMASK) |
83                        (EN29LV640 & FLASH_TYPEMASK);
84                flash_info[i].size = FLASH_BANK_SIZE;
85                flash_info[i].sector_count = CFG_MAX_FLASH_SECT;
86                memset (flash_info[i].protect, 0, CFG_MAX_FLASH_SECT);
87                if (i == 0)
88                        flashbase = PHYS_FLASH_1;
89                else
90                        panic ("configured to many flash banks!\n");
91
92                for (j = 0; j < flash_info[i].sector_count; j++) {
93                        flash_info[i].start[j] = flashbase + 0x10000 * j;
94                }
95                size += flash_info[i].size;
96        }
97
98        flash_protect (FLAG_PROTECT_SET,
99                       CFG_FLASH_BASE,
100                       CFG_FLASH_BASE + 0x2ffff, &flash_info[0]);
101
102        return size;
103}
104
105
106#define CMD_READ_ARRAY          0x00F0
107#define CMD_UNLOCK1             0x00AA
108#define CMD_UNLOCK2             0x0055
109#define CMD_ERASE_SETUP         0x0080
110#define CMD_ERASE_CONFIRM       0x0030
111#define CMD_PROGRAM             0x00A0
112#define CMD_UNLOCK_BYPASS       0x0020
113
114#define MEM_FLASH_ADDR1         (*(volatile u16 *)(CFG_FLASH_BASE + (0x00000555<<1)))
115#define MEM_FLASH_ADDR2         (*(volatile u16 *)(CFG_FLASH_BASE + (0x000002AA<<1)))
116
117#define BIT_ERASE_DONE          0x0080
118#define BIT_RDY_MASK            0x0080
119#define BIT_PROGRAM_ERROR       0x0020
120#define BIT_TIMEOUT             0x80000000      /* our flag */
121
122#define READY 1
123#define ERR   2
124#define TMO   4
125
126
127int flash_erase (flash_info_t * info, int s_first, int s_last)
128{
129        ulong result;
130        int iflag, prot, sect;
131        int rc = ERR_OK;
132        int chip1;
133
134        /* first look for protection bits */
135
136        if (info->flash_id == FLASH_UNKNOWN)
137                return ERR_UNKNOWN_FLASH_TYPE;
138
139        if ((s_first < 0) || (s_first > s_last)) {
140                return ERR_INVAL;
141        }
142
143        if ((info->flash_id & FLASH_VENDMASK) !=
144            (AMD_MANUFACT & FLASH_VENDMASK)) {
145                return ERR_UNKNOWN_FLASH_VENDOR;
146        }
147
148        prot = 0;
149        for (sect = s_first; sect <= s_last; ++sect) {
150                if (info->protect[sect]) {
151                        prot++;
152                }
153        }
154        if (prot)
155                return ERR_PROTECTED;
156
157        /*
158         * Disable interrupts which might cause a timeout
159         * here. Remember that our exception vectors are
160         * at address 0 in the flash, and we don't want a
161         * (ticker) exception to happen while the flash
162         * chip is in programming mode.
163         */
164        iflag = disable_interrupts ();
165
166        printf ("\n");
167
168        /* Start erase on unprotected sectors */
169        for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
170                printf ("Erasing sector %2d ... ", sect);
171
172                /* arm simple, non interrupt dependent timer */
173                set_timer (0);
174
175                if (info->protect[sect] == 0) { /* not protected */
176                        volatile u16 *addr =
177                                (volatile u16 *) (info->start[sect]);
178
179                        MEM_FLASH_ADDR1 = CMD_UNLOCK1;
180                        MEM_FLASH_ADDR2 = CMD_UNLOCK2;
181                        MEM_FLASH_ADDR1 = CMD_ERASE_SETUP;
182
183                        MEM_FLASH_ADDR1 = CMD_UNLOCK1;
184                        MEM_FLASH_ADDR2 = CMD_UNLOCK2;
185                        *addr = CMD_ERASE_CONFIRM;
186
187                        /* wait until flash is ready */
188                        chip1 = 0;
189
190                        do {
191                                result = *addr;
192
193                                /* check timeout */
194                                if (get_timer (0) > CFG_FLASH_ERASE_TOUT * CFG_HZ / 1000) {
195                                        MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
196                                        chip1 = TMO;
197                                        break;
198                                }
199
200                                if (!chip1
201                                    && (result & 0xFFFF) & BIT_ERASE_DONE)
202                                        chip1 = READY;
203
204                        } while (!chip1);
205
206                        MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
207
208                        if (chip1 == ERR) {
209                                rc = ERR_PROG_ERROR;
210                                goto outahere;
211                        }
212                        if (chip1 == TMO) {
213                                rc = ERR_TIMOUT;
214                                goto outahere;
215                        }
216
217                        printf ("ok.\n");
218                } else {        /* it was protected */
219
220                        printf ("protected!\n");
221                }
222        }
223
224        if (ctrlc ())
225                printf ("User Interrupt!\n");
226
227      outahere:
228        /* allow flash to settle - wait 10 ms */
229        printf("Waiting 10 ms...");
230         udelay (10000);
231
232/*      for (i = 0; i < 10 * 1000 * 1000; ++i)
233                asm(" nop");
234*/
235
236        printf("done\n");
237        if (iflag)
238                enable_interrupts ();
239
240
241        return rc;
242}
243
244static int write_word (flash_info_t * info, ulong dest, ulong data)
245{
246        volatile u16 *addr = (volatile u16 *) dest;
247        ulong result;
248        int rc = ERR_OK;
249        int iflag;
250        int chip1;
251
252        /*
253         * Check if Flash is (sufficiently) erased
254         */
255        result = *addr;
256        if ((result & data) != data)
257                return ERR_NOT_ERASED;
258
259
260        /*
261         * Disable interrupts which might cause a timeout
262         * here. Remember that our exception vectors are
263         * at address 0 in the flash, and we don't want a
264         * (ticker) exception to happen while the flash
265         * chip is in programming mode.
266         */
267        iflag = disable_interrupts ();
268
269        MEM_FLASH_ADDR1 = CMD_UNLOCK1;
270        MEM_FLASH_ADDR2 = CMD_UNLOCK2;
271        MEM_FLASH_ADDR1 = CMD_PROGRAM;
272        *addr = data;
273
274        /* arm simple, non interrupt dependent timer */
275        set_timer (0);
276
277        /* wait until flash is ready */
278        chip1 = 0;
279        do {
280                result = *addr;
281
282                /* check timeout */
283                if (get_timer (0) > CFG_FLASH_ERASE_TOUT * CFG_HZ / 1000) {
284                        chip1 = ERR | TMO;
285                        break;
286                }
287                if (!chip1 && ((result & 0x80) == (data & 0x80)))
288                        chip1 = READY;
289
290        } while (!chip1);
291
292        *addr = CMD_READ_ARRAY;
293
294        if (chip1 == ERR || *addr != data)
295                rc = ERR_PROG_ERROR;
296
297        if (iflag)
298                enable_interrupts ();
299
300        return rc;
301}
302
303
304int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
305{
306        ulong wp, data;
307        int rc;
308
309        if (addr & 1) {
310                printf ("unaligned destination not supported\n");
311                return ERR_ALIGN;
312        }
313
314#if 0
315        if (cnt & 1) {
316                printf ("odd transfer sizes not supported\n");
317                return ERR_ALIGN;
318        }
319#endif
320
321        wp = addr;
322
323        if (addr & 1) {
324                data = (*((volatile u8 *) addr) << 8) | *((volatile u8 *)
325                                                          src);
326                if ((rc = write_word (info, wp - 1, data)) != 0) {
327                        return (rc);
328                }
329                src += 1;
330                wp += 1;
331                cnt -= 1;
332        }
333
334        while (cnt >= 2) {
335                data = *((volatile u16 *) src);
336                if ((rc = write_word (info, wp, data)) != 0) {
337                        return (rc);
338                }
339                src += 2;
340                wp += 2;
341                cnt -= 2;
342        }
343
344        if (cnt == 1) {
345                data = (*((volatile u8 *) src) << 8) |
346                        *((volatile u8 *) (wp + 1));
347                if ((rc = write_word (info, wp, data)) != 0) {
348                        return (rc);
349                }
350                src += 1;
351                wp += 1;
352                cnt -= 1;
353        }
354
355        return ERR_OK;
356}
Note: See TracBrowser for help on using the repository browser.