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