]> git.kernelconcepts.de Git - karo-tx-uboot.git/blob - board/eltec/mhpc/flash.c
rename CFG_ macros to CONFIG_SYS
[karo-tx-uboot.git] / board / eltec / mhpc / flash.c
1 /*
2  * (C) Copyright 2001
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 #include <mpc8xx.h>
26 #include <linux/byteorder/swab.h>
27
28 flash_info_t    flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips */
29
30 /*-----------------------------------------------------------------------
31  * Protection Flags:
32  */
33 #define FLAG_PROTECT_SET        0x01
34 #define FLAG_PROTECT_CLEAR      0x02
35
36 /* Board support for 1 or 2 flash devices */
37 #undef FLASH_PORT_WIDTH32
38 #define FLASH_PORT_WIDTH16
39
40 #ifdef FLASH_PORT_WIDTH16
41 #define FLASH_PORT_WIDTH                ushort
42 #define FLASH_PORT_WIDTHV               vu_short
43 #define SWAP(x)                         __swab16(x)
44 #else
45 #define FLASH_PORT_WIDTH                ulong
46 #define FLASH_PORT_WIDTHV               vu_long
47 #define SWAP(x)                         __swab32(x)
48 #endif
49
50 #define FPW     FLASH_PORT_WIDTH
51 #define FPWV    FLASH_PORT_WIDTHV
52
53 /*-----------------------------------------------------------------------
54  * Functions
55  */
56 static ulong flash_get_size (FPW *addr, flash_info_t *info);
57 static int   write_data (flash_info_t *info, ulong dest, FPW data);
58 static void  flash_get_offsets (ulong base, flash_info_t *info);
59
60 /*-----------------------------------------------------------------------
61  */
62
63 unsigned long flash_init (void)
64 {
65         volatile immap_t     *immap  = (immap_t *)CONFIG_SYS_IMMR;
66         volatile memctl8xx_t *memctl = &immap->im_memctl;
67         unsigned long size_b0;
68         int i;
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         /* Static FLASH Bank configuration here - FIXME XXX */
76         size_b0 = flash_get_size((FPW *)FLASH_BASE0_PRELIM, &flash_info[0]);
77
78         if (flash_info[0].flash_id == FLASH_UNKNOWN) {
79                 printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
80                         size_b0, size_b0<<20);
81         }
82
83         /* Remap FLASH according to real size */
84         memctl->memc_or0 = CONFIG_SYS_OR_TIMING_FLASH | (-size_b0 & 0xFFFF8000);
85         memctl->memc_br0 = (CONFIG_SYS_FLASH_BASE & BR_BA_MSK) | BR_PS_16 | BR_MS_GPCM | BR_V;
86
87         /* Re-do sizing to get full correct info */
88         size_b0 = flash_get_size((FPW *)CONFIG_SYS_FLASH_BASE, &flash_info[0]);
89
90         flash_get_offsets (CONFIG_SYS_FLASH_BASE, &flash_info[0]);
91
92         /* monitor protection ON by default */
93         (void)flash_protect(FLAG_PROTECT_SET,
94                             CONFIG_SYS_FLASH_BASE,
95                             CONFIG_SYS_FLASH_BASE+monitor_flash_len-1,
96                             &flash_info[0]);
97
98         flash_info[0].size = size_b0;
99
100         return (size_b0);
101 }
102
103 /*-----------------------------------------------------------------------
104  */
105 static void flash_get_offsets (ulong base, flash_info_t *info)
106 {
107         int i;
108
109         if (info->flash_id == FLASH_UNKNOWN) {
110                 return;
111         }
112
113         if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL) {
114                 for (i = 0; i < info->sector_count; i++) {
115                         info->start[i] = base + (i * 0x00020000);
116                 }
117         }
118 }
119
120 /*-----------------------------------------------------------------------
121  */
122 void flash_print_info  (flash_info_t *info)
123 {
124         int i;
125
126         if (info->flash_id == FLASH_UNKNOWN) {
127                 printf ("missing or unknown FLASH type\n");
128                 return;
129         }
130
131         switch (info->flash_id & FLASH_VENDMASK) {
132                 case FLASH_MAN_INTEL:   printf ("INTEL ");              break;
133                 default:                printf ("Unknown Vendor ");     break;
134         }
135
136         switch (info->flash_id & FLASH_TYPEMASK) {
137    case FLASH_28F640J5 :
138                                 printf ("28F640J5 \n"); break;
139         default:                printf ("Unknown Chip Type=0x%lXh\n",
140                                         info->flash_id & FLASH_TYPEMASK); break;
141         }
142
143         printf ("  Size: %ld MB in %d Sectors\n",
144                 info->size >> 20, info->sector_count);
145
146         printf ("  Sector Start Addresses:");
147         for (i=0; i<info->sector_count; ++i) {
148                 if ((i % 5) == 0)
149                         printf ("\n   ");
150                 printf (" %08lX%s",
151                         info->start[i],
152                         info->protect[i] ? " (RO)" : "     "
153                 );
154         }
155         printf ("\n");
156 }
157
158 /*-----------------------------------------------------------------------
159  */
160
161
162 /*-----------------------------------------------------------------------
163  */
164
165 /*
166  * The following code cannot be run from FLASH!
167  */
168
169 static ulong flash_get_size (FPW *addr, flash_info_t *info)
170 {
171         FPW value;
172
173         /* Write auto select command: read Manufacturer ID */
174         addr[0x5555] = (FPW)0xAA00AA00;
175         addr[0x2AAA] = (FPW)0x55005500;
176         addr[0x5555] = (FPW)0x90009000;
177
178         value = SWAP(addr[0]);
179
180    switch (value) {
181    case (FPW)INTEL_MANUFACT:
182       info->flash_id = FLASH_MAN_INTEL;
183       break;
184         default:
185                 info->flash_id = FLASH_UNKNOWN;
186                 info->sector_count = 0;
187                 info->size = 0;
188                 addr[0] = (FPW)0xFF00FF00;      /* restore read mode */
189                 return (0);                           /* no or unknown flash    */
190         }
191
192    value = SWAP(addr[1]);                               /* device ID no swap !*/
193
194    switch (value) {
195    case (FPW)INTEL_ID_28F640J5 :
196         info->flash_id += FLASH_28F640J5 ;
197         info->sector_count = 64;
198         info->size = 0x00800000;
199         break;            /* => 8 MB     */
200
201         default:
202                 info->flash_id = FLASH_UNKNOWN;
203                 break;
204         }
205
206         if (info->sector_count > CONFIG_SYS_MAX_FLASH_SECT) {
207                 printf ("** ERROR: sector count %d > max (%d) **\n",
208                         info->sector_count, CONFIG_SYS_MAX_FLASH_SECT);
209                 info->sector_count = CONFIG_SYS_MAX_FLASH_SECT;
210         }
211
212         addr[0] = (FPW)0xFF00FF00;      /* restore read mode */
213
214         return (info->size);
215 }
216
217
218 /*-----------------------------------------------------------------------
219  */
220
221 int     flash_erase (flash_info_t *info, int s_first, int s_last)
222 {
223         int flag, prot, sect;
224         ulong type, start, now, last;
225         int rc = 0;
226
227         if ((s_first < 0) || (s_first > s_last)) {
228                 if (info->flash_id == FLASH_UNKNOWN) {
229                         printf ("- missing\n");
230                 } else {
231                         printf ("- no sectors to erase\n");
232                 }
233                 return 1;
234         }
235
236         type = (info->flash_id & FLASH_VENDMASK);
237         if ((type != FLASH_MAN_INTEL)) {
238                 printf ("Can't erase unknown flash type %08lx - aborted\n",
239                         info->flash_id);
240                 return 1;
241         }
242
243         prot = 0;
244         for (sect=s_first; sect<=s_last; ++sect) {
245                 if (info->protect[sect]) {
246                         prot++;
247                 }
248         }
249
250         if (prot) {
251                 printf ("- Warning: %d protected sectors will not be erased!\n",
252                         prot);
253         } else {
254                 printf ("\n");
255         }
256
257         start = get_timer (0);
258         last  = start;
259         /* Start erase on unprotected sectors */
260         for (sect = s_first; sect<=s_last; sect++) {
261                 if (info->protect[sect] == 0) { /* not protected */
262                         FPWV *addr = (FPWV *)(info->start[sect]);
263                         FPW status;
264
265                         /* Disable interrupts which might cause a timeout here */
266                         flag = disable_interrupts();
267
268                         *addr = (FPW)0x50005000;        /* clear status register */
269                         *addr = (FPW)0x20002000;        /* erase setup */
270                         *addr = (FPW)0xD000D000;        /* erase confirm */
271
272                         /* re-enable interrupts if necessary */
273                         if (flag)
274                                 enable_interrupts();
275
276                         /* wait at least 80us - let's wait 1 ms */
277                         udelay (1000);
278
279                         while (((status = SWAP(*addr)) & (FPW)0x00800080) != (FPW)0x00800080) {
280                                 if ((now=get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
281                                         printf ("Timeout\n");
282                                         *addr = (FPW)0xB000B000; /* suspend erase */
283                                         *addr = (FPW)0xFF00FF00; /* reset to read mode */
284                                         rc = 1;
285                                         break;
286                                 }
287
288                                 /* show that we're waiting */
289                         if ((now - last) > 1000) {      /* every second */
290                                         putc ('.');
291                                         last = now;
292                                 }
293                         }
294
295                         *addr = (FPW)0xFF00FF00;        /* reset to read mode */
296                         printf (" done\n");
297                 }
298         }
299         return rc;
300 }
301
302 /*-----------------------------------------------------------------------
303  * Copy memory to flash, returns:
304  * 0 - OK
305  * 1 - write timeout
306  * 2 - Flash not erased
307  * 4 - Flash not identified
308  */
309
310 int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
311 {
312         ulong cp, wp;
313         FPW data;
314         int count, i, l, rc, port_width;
315
316         if (info->flash_id == FLASH_UNKNOWN) {
317                 return 4;
318         }
319 /* get lower word aligned address */
320 #ifdef FLASH_PORT_WIDTH16
321         wp = (addr & ~1);
322         port_width = 2;
323 #else
324         wp = (addr & ~3);
325         port_width = 4;
326 #endif
327
328         /*
329          * handle unaligned start bytes
330          */
331         if ((l = addr - wp) != 0) {
332                 data = 0;
333                 for (i=0, cp=wp; i<l; ++i, ++cp) {
334                         data = (data << 8) | (*(uchar *)cp);
335                 }
336                 for (; i<port_width && cnt>0; ++i) {
337                         data = (data << 8) | *src++;
338                         --cnt;
339                         ++cp;
340                 }
341                 for (; cnt==0 && i<port_width; ++i, ++cp) {
342                         data = (data << 8) | (*(uchar *)cp);
343                 }
344
345                 if ((rc = write_data(info, wp, data)) != 0) {
346                         return (rc);
347                 }
348                 wp += port_width;
349         }
350
351         /*
352          * handle word aligned part
353          */
354         count = 0;
355         while (cnt >= port_width) {
356                 data = 0;
357                 for (i=0; i<port_width; ++i) {
358                         data = (data << 8) | *src++;
359                 }
360                 if ((rc = write_data(info, wp, data)) != 0) {
361                         return (rc);
362                 }
363                 wp  += port_width;
364                 cnt -= port_width;
365                 if ((wp & 0xfff) == 0)
366                 {
367                         printf("%08lX",wp);
368                         printf("\x1b[8D");
369                 }
370         }
371
372         if (cnt == 0) {
373                 return (0);
374         }
375
376         /*
377          * handle unaligned tail bytes
378          */
379         data = 0;
380         for (i=0, cp=wp; i<port_width && cnt>0; ++i, ++cp) {
381                 data = (data << 8) | *src++;
382                 --cnt;
383         }
384         for (; i<port_width; ++i, ++cp) {
385                 data = (data << 8) | (*(uchar *)cp);
386         }
387
388         return (write_data(info, wp, data));
389 }
390
391 /*-----------------------------------------------------------------------
392  * Write a word or halfword to Flash, returns:
393  * 0 - OK
394  * 1 - write timeout
395  * 2 - Flash not erased
396  */
397 static int write_data (flash_info_t *info, ulong dest, FPW data)
398 {
399         FPWV *addr = (FPWV *)dest;
400         ulong status;
401         ulong start;
402         int flag;
403
404         /* Check if Flash is (sufficiently) erased */
405         if ((*addr & data) != data) {
406                 printf("not erased at %08lx (%x)\n",(ulong)addr,*addr);
407                 return (2);
408         }
409         /* Disable interrupts which might cause a timeout here */
410         flag = disable_interrupts();
411
412         *addr = (FPW)0x40004000;                /* write setup */
413         *addr = data;
414
415         /* re-enable interrupts if necessary */
416         if (flag)
417                 enable_interrupts();
418
419         start = get_timer (0);
420
421         while (((status = SWAP(*addr)) & (FPW)0x00800080) != (FPW)0x00800080) {
422                 if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
423                         *addr = (FPW)0xFF00FF00;        /* restore read mode */
424                         return (1);
425                 }
426         }
427
428         *addr = (FPW)0xFF00FF00;        /* restore read mode */
429
430         return (0);
431 }