]> git.sur5r.net Git - u-boot/blob - board/bf533-ezkit/flash.c
ppc4xx: Update 44x_spd_ddr2 code (440SP/440SPe)
[u-boot] / board / bf533-ezkit / flash.c
1 /*
2  * U-boot - flash.c Flash driver for PSD4256GV
3  *
4  * Copyright (c) 2005-2007 Analog Devices Inc.
5  * This file is based on BF533EzFlash.c originally written by Analog Devices, Inc.
6  *
7  * (C) Copyright 2000-2004
8  * Wolfgang Denk, DENX Software Engineering, wd@denx.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., 51 Franklin St, Fifth Floor, Boston,
26  * MA 02110-1301 USA
27  */
28
29 #include <asm/io.h>
30 #include "flash-defines.h"
31
32 void flash_reset(void)
33 {
34         reset_flash();
35 }
36
37 unsigned long flash_get_size(ulong baseaddr, flash_info_t * info, int bank_flag)
38 {
39         int id = 0, i = 0;
40         static int FlagDev = 1;
41
42         id = get_codes();
43         if (FlagDev) {
44 #ifdef DEBUG
45                 printf("Device ID of the Flash is %x\n", id);
46 #endif
47                 FlagDev = 0;
48         }
49         info->flash_id = id;
50
51         switch (bank_flag) {
52         case 0:
53                 for (i = PriFlashABegin; i < SecFlashABegin; i++)
54                         info->start[i] = (baseaddr + (i * AFP_SectorSize1));
55                 info->size = 0x200000;
56                 info->sector_count = 32;
57                 break;
58         case 1:
59                 info->start[0] = baseaddr + SecFlashASec1Off;
60                 info->start[1] = baseaddr + SecFlashASec2Off;
61                 info->start[2] = baseaddr + SecFlashASec3Off;
62                 info->start[3] = baseaddr + SecFlashASec4Off;
63                 info->size = 0x10000;
64                 info->sector_count = 4;
65                 break;
66         case 2:
67                 info->start[0] = baseaddr + SecFlashBSec1Off;
68                 info->start[1] = baseaddr + SecFlashBSec2Off;
69                 info->start[2] = baseaddr + SecFlashBSec3Off;
70                 info->start[3] = baseaddr + SecFlashBSec4Off;
71                 info->size = 0x10000;
72                 info->sector_count = 4;
73                 break;
74         }
75         return (info->size);
76 }
77
78 unsigned long flash_init(void)
79 {
80         unsigned long size_b0, size_b1, size_b2;
81         int i;
82
83         size_b0 = size_b1 = size_b2 = 0;
84 #ifdef DEBUG
85         printf("Flash Memory Start 0x%x\n", CFG_FLASH_BASE);
86         printf("Memory Map for the Flash\n");
87         printf("0x20000000 - 0x200FFFFF Flash A Primary (1MB)\n");
88         printf("0x20100000 - 0x201FFFFF Flash B Primary (1MB)\n");
89         printf("0x20200000 - 0x2020FFFF Flash A Secondary (64KB)\n");
90         printf("0x20280000 - 0x2028FFFF Flash B Secondary (64KB)\n");
91         printf("Please type command flinfo for information on Sectors \n");
92 #endif
93         for (i = 0; i < CFG_MAX_FLASH_BANKS; ++i) {
94                 flash_info[i].flash_id = FLASH_UNKNOWN;
95         }
96
97         size_b0 = flash_get_size(CFG_FLASH0_BASE, &flash_info[0], 0);
98         size_b1 = flash_get_size(CFG_FLASH0_BASE, &flash_info[1], 1);
99         size_b2 = flash_get_size(CFG_FLASH0_BASE, &flash_info[2], 2);
100
101         if (flash_info[0].flash_id == FLASH_UNKNOWN || size_b0 == 0) {
102                 printf("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
103                        size_b0, size_b0 >> 20);
104         }
105
106         (void)flash_protect(FLAG_PROTECT_SET, CFG_FLASH0_BASE,
107                             (flash_info[0].start[2] - 1), &flash_info[0]);
108
109         return (size_b0 + size_b1 + size_b2);
110 }
111
112 void flash_print_info(flash_info_t * info)
113 {
114         int i;
115
116         if (info->flash_id == FLASH_UNKNOWN) {
117                 printf("missing or unknown FLASH type\n");
118                 return;
119         }
120
121         switch (info->flash_id) {
122         case FLASH_PSD4256GV:
123                 printf("ST Microelectronics ");
124                 break;
125         default:
126                 printf("Unknown Vendor: (0x%08X) ", info->flash_id);
127                 break;
128         }
129         for (i = 0; i < info->sector_count; ++i) {
130                 if ((i % 5) == 0)
131                         printf("\n   ");
132                 printf(" %08lX%s",
133                        info->start[i], info->protect[i] ? " (RO)" : "     ");
134         }
135         printf("\n");
136         return;
137 }
138
139 int flash_erase(flash_info_t * info, int s_first, int s_last)
140 {
141         int cnt = 0, i;
142         int prot, sect;
143
144         prot = 0;
145         for (sect = s_first; sect <= s_last; ++sect) {
146                 if (info->protect[sect])
147                         prot++;
148         }
149
150         if (prot)
151                 printf("- Warning: %d protected sectors will not be erased!\n",
152                        prot);
153         else
154                 printf("\n");
155
156         cnt = s_last - s_first + 1;
157
158         if (cnt == FLASH_TOT_SECT) {
159                 printf("Erasing flash, Please Wait \n");
160                 if (erase_flash() < 0) {
161                         printf("Erasing flash failed \n");
162                         return FLASH_FAIL;
163                 }
164         } else {
165                 printf("Erasing Flash locations, Please Wait\n");
166                 for (i = s_first; i <= s_last; i++) {
167                         if (info->protect[i] == 0) {    /* not protected */
168                                 if (erase_block_flash(i, info->start[i]) < 0) {
169                                         printf("Error Sector erasing \n");
170                                         return FLASH_FAIL;
171                                 }
172                         }
173                 }
174         }
175         return FLASH_SUCCESS;
176 }
177
178 int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
179 {
180         int ret;
181         int d;
182         if (addr % 2) {
183                 read_flash(addr - 1 - CFG_FLASH_BASE, &d);
184                 d = (int)((d & 0x00FF) | (*src++ << 8));
185                 ret = write_data(addr - 1, 2, (uchar *) & d);
186                 if (ret == FLASH_FAIL)
187                         return ERR_NOT_ERASED;
188                 ret = write_data(addr + 1, cnt - 1, src);
189         } else
190                 ret = write_data(addr, cnt, src);
191         if (ret == FLASH_FAIL)
192                 return ERR_NOT_ERASED;
193         return FLASH_SUCCESS;
194 }
195
196 int write_data(long lStart, long lCount, uchar * pnData)
197 {
198         long i = 0;
199         unsigned long ulOffset = lStart - CFG_FLASH_BASE;
200         int d;
201         int nSector = 0;
202         int flag = 0;
203
204         if (lCount % 2) {
205                 flag = 1;
206                 lCount = lCount - 1;
207         }
208
209         for (i = 0; i < lCount - 1; i += 2, ulOffset += 2) {
210                 get_sector_number(ulOffset, &nSector);
211                 read_flash(ulOffset, &d);
212                 if (d != 0xffff) {
213                         printf
214                             ("Flash not erased at offset 0x%x Please erase to reprogram \n",
215                              ulOffset);
216                         return FLASH_FAIL;
217                 }
218                 unlock_flash(ulOffset);
219                 d = (int)(pnData[i] | pnData[i + 1] << 8);
220                 write_flash(ulOffset, d);
221                 if (poll_toggle_bit(ulOffset) < 0) {
222                         printf("Error programming the flash \n");
223                         return FLASH_FAIL;
224                 }
225                 if ((i > 0) && (!(i % AFP_SectorSize2)))
226                         printf(".");
227         }
228         if (flag) {
229                 get_sector_number(ulOffset, &nSector);
230                 read_flash(ulOffset, &d);
231                 if (d != 0xffff) {
232                         printf
233                             ("Flash not erased at offset 0x%x Please erase to reprogram \n",
234                              ulOffset);
235                         return FLASH_FAIL;
236                 }
237                 unlock_flash(ulOffset);
238                 d = (int)(pnData[i] | (d & 0xFF00));
239                 write_flash(ulOffset, d);
240                 if (poll_toggle_bit(ulOffset) < 0) {
241                         printf("Error programming the flash \n");
242                         return FLASH_FAIL;
243                 }
244         }
245         return FLASH_SUCCESS;
246 }
247
248 int read_data(long ulStart, long lCount, long lStride, int *pnData)
249 {
250         long i = 0;
251         int j = 0;
252         long ulOffset = ulStart;
253         int iShift = 0;
254         int iNumWords = 2;
255         int nLeftover = lCount % 4;
256         int nHi, nLow;
257         int nSector = 0;
258
259         for (i = 0; (i < lCount / 4) && (i < BUFFER_SIZE); i++) {
260                 for (iShift = 0, j = 0; j < iNumWords; j += 2) {
261                         if ((ulOffset >= INVALIDLOCNSTART)
262                             && (ulOffset < INVALIDLOCNEND))
263                                 return FLASH_FAIL;
264
265                         get_sector_number(ulOffset, &nSector);
266                         read_flash(ulOffset, &nLow);
267                         ulOffset += (lStride * 2);
268                         read_flash(ulOffset, &nHi);
269                         ulOffset += (lStride * 2);
270                         pnData[i] = (nHi << 16) | nLow;
271                 }
272         }
273         if (nLeftover > 0) {
274                 if ((ulOffset >= INVALIDLOCNSTART)
275                     && (ulOffset < INVALIDLOCNEND))
276                         return FLASH_FAIL;
277
278                 get_sector_number(ulOffset, &nSector);
279                 read_flash(ulOffset, &pnData[i]);
280         }
281         return FLASH_SUCCESS;
282 }
283
284 int write_flash(long nOffset, int nValue)
285 {
286         long addr;
287
288         addr = (CFG_FLASH_BASE + nOffset);
289         sync();
290         *(unsigned volatile short *)addr = nValue;
291         sync();
292         if (poll_toggle_bit(nOffset) < 0)
293                 return FLASH_FAIL;
294         return FLASH_SUCCESS;
295 }
296
297 int read_flash(long nOffset, int *pnValue)
298 {
299         int nValue = 0x0;
300         long addr = (CFG_FLASH_BASE + nOffset);
301
302         if (nOffset != 0x2)
303                 reset_flash();
304         sync();
305         nValue = *(volatile unsigned short *)addr;
306         sync();
307         *pnValue = nValue;
308         return TRUE;
309 }
310
311 int poll_toggle_bit(long lOffset)
312 {
313         unsigned int u1, u2;
314         unsigned long timeout = 0xFFFFFFFF;
315         volatile unsigned long *FB =
316             (volatile unsigned long *)(0x20000000 + lOffset);
317         while (1) {
318                 if (timeout < 0)
319                         break;
320                 u1 = *(volatile unsigned short *)FB;
321                 u2 = *(volatile unsigned short *)FB;
322                 if ((u1 & 0x0040) == (u2 & 0x0040))
323                         return FLASH_SUCCESS;
324                 if ((u2 & 0x0020) == 0x0000)
325                         continue;
326                 u1 = *(volatile unsigned short *)FB;
327                 if ((u2 & 0x0040) == (u1 & 0x0040))
328                         return FLASH_SUCCESS;
329                 else {
330                         reset_flash();
331                         return FLASH_FAIL;
332                 }
333                 timeout--;
334         }
335         printf("Time out occured \n");
336         if (timeout < 0)
337                 return FLASH_FAIL;
338 }
339
340 void reset_flash(void)
341 {
342         write_flash(WRITESEQ1, RESET_VAL);
343         /* Wait for 10 micro seconds */
344         udelay(10);
345 }
346
347 int erase_flash(void)
348 {
349         write_flash(WRITESEQ1, WRITEDATA1);
350         write_flash(WRITESEQ2, WRITEDATA2);
351         write_flash(WRITESEQ3, WRITEDATA3);
352         write_flash(WRITESEQ4, WRITEDATA4);
353         write_flash(WRITESEQ5, WRITEDATA5);
354         write_flash(WRITESEQ6, WRITEDATA6);
355
356         if (poll_toggle_bit(0x0000) < 0)
357                 return FLASH_FAIL;
358
359         write_flash(SecFlashAOff + WRITESEQ1, WRITEDATA1);
360         write_flash(SecFlashAOff + WRITESEQ2, WRITEDATA2);
361         write_flash(SecFlashAOff + WRITESEQ3, WRITEDATA3);
362         write_flash(SecFlashAOff + WRITESEQ4, WRITEDATA4);
363         write_flash(SecFlashAOff + WRITESEQ5, WRITEDATA5);
364         write_flash(SecFlashAOff + WRITESEQ6, WRITEDATA6);
365
366         if (poll_toggle_bit(SecFlashASec1Off) < 0)
367                 return FLASH_FAIL;
368
369         write_flash(PriFlashBOff + WRITESEQ1, WRITEDATA1);
370         write_flash(PriFlashBOff + WRITESEQ2, WRITEDATA2);
371         write_flash(PriFlashBOff + WRITESEQ3, WRITEDATA3);
372         write_flash(PriFlashBOff + WRITESEQ4, WRITEDATA4);
373         write_flash(PriFlashBOff + WRITESEQ5, WRITEDATA5);
374         write_flash(PriFlashBOff + WRITESEQ6, WRITEDATA6);
375
376         if (poll_toggle_bit(PriFlashBOff) < 0)
377                 return FLASH_FAIL;
378
379         write_flash(SecFlashBOff + WRITESEQ1, WRITEDATA1);
380         write_flash(SecFlashBOff + WRITESEQ2, WRITEDATA2);
381         write_flash(SecFlashBOff + WRITESEQ3, WRITEDATA3);
382         write_flash(SecFlashBOff + WRITESEQ4, WRITEDATA4);
383         write_flash(SecFlashBOff + WRITESEQ5, WRITEDATA5);
384         write_flash(SecFlashBOff + WRITESEQ6, WRITEDATA6);
385
386         if (poll_toggle_bit(SecFlashBOff) < 0)
387                 return FLASH_FAIL;
388
389         return FLASH_SUCCESS;
390 }
391
392 int erase_block_flash(int nBlock, unsigned long address)
393 {
394         long ulSectorOff = 0x0;
395
396         if ((nBlock < 0) || (nBlock > AFP_NumSectors))
397                 return FALSE;
398
399         ulSectorOff = (address - CFG_FLASH_BASE);
400
401         write_flash((WRITESEQ1 | ulSectorOff), WRITEDATA1);
402         write_flash((WRITESEQ2 | ulSectorOff), WRITEDATA2);
403         write_flash((WRITESEQ3 | ulSectorOff), WRITEDATA3);
404         write_flash((WRITESEQ4 | ulSectorOff), WRITEDATA4);
405         write_flash((WRITESEQ5 | ulSectorOff), WRITEDATA5);
406
407         write_flash(ulSectorOff, BlockEraseVal);
408
409         if (poll_toggle_bit(ulSectorOff) < 0)
410                 return FLASH_FAIL;
411
412         return FLASH_SUCCESS;
413 }
414
415 void unlock_flash(long ulOffset)
416 {
417         unsigned long ulOffsetAddr = ulOffset;
418         ulOffsetAddr &= 0xFFFF0000;
419
420         write_flash((WRITESEQ1 | ulOffsetAddr), UNLOCKDATA1);
421         write_flash((WRITESEQ2 | ulOffsetAddr), UNLOCKDATA2);
422         write_flash((WRITESEQ3 | ulOffsetAddr), UNLOCKDATA3);
423 }
424
425 int get_codes()
426 {
427         int dev_id = 0;
428
429         write_flash(WRITESEQ1, GETCODEDATA1);
430         write_flash(WRITESEQ2, GETCODEDATA2);
431         write_flash(WRITESEQ3, GETCODEDATA3);
432
433         read_flash(0x0002, &dev_id);
434         dev_id &= 0x00FF;
435
436         reset_flash();
437
438         return dev_id;
439 }
440
441 void get_sector_number(long ulOffset, int *pnSector)
442 {
443         int nSector = 0;
444
445         if (ulOffset >= SecFlashAOff) {
446                 if ((ulOffset < SecFlashASec1Off)
447                     && (ulOffset < SecFlashASec2Off)) {
448                         nSector = SECT32;
449                 } else if ((ulOffset >= SecFlashASec2Off)
450                            && (ulOffset < SecFlashASec3Off)) {
451                         nSector = SECT33;
452                 } else if ((ulOffset >= SecFlashASec3Off)
453                            && (ulOffset < SecFlashASec4Off)) {
454                         nSector = SECT34;
455                 } else if ((ulOffset >= SecFlashASec4Off)
456                            && (ulOffset < SecFlashAEndOff)) {
457                         nSector = SECT35;
458                 }
459         } else if (ulOffset >= SecFlashBOff) {
460                 if ((ulOffset < SecFlashBSec1Off)
461                     && (ulOffset < SecFlashBSec2Off)) {
462                         nSector = SECT36;
463                 }
464                 if ((ulOffset < SecFlashBSec2Off)
465                     && (ulOffset < SecFlashBSec3Off)) {
466                         nSector = SECT37;
467                 }
468                 if ((ulOffset < SecFlashBSec3Off)
469                     && (ulOffset < SecFlashBSec4Off)) {
470                         nSector = SECT38;
471                 }
472                 if ((ulOffset < SecFlashBSec4Off)
473                     && (ulOffset < SecFlashBEndOff)) {
474                         nSector = SECT39;
475                 }
476         } else if ((ulOffset >= PriFlashAOff) && (ulOffset < SecFlashAOff)) {
477                 nSector = ulOffset & 0xffff0000;
478                 nSector = ulOffset >> 16;
479                 nSector = nSector & 0x000ff;
480         }
481
482         if ((nSector >= 0) && (nSector < AFP_NumSectors)) {
483                 *pnSector = nSector;
484         }
485 }