Support Micron or Numonyx memory
[x-loader:x-loader.git] / drivers / k9f1g08r0a.c
1 /*
2  * (C) Copyright 2004 Texas Instruments
3  * Jian Zhang <jzhang@ti.com>
4  *
5  *  Samsung K9F1G08R0AQ0C NAND chip driver for an OMAP2420 board
6  * 
7  * This file is based on the following u-boot file:
8  *      common/cmd_nand.c
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 #include <asm/arch/sys_proto.h>
32 #include <asm/arch/sys_info.h>
33
34 #ifdef CFG_NAND_K9F1G08R0A
35
36 #define K9F1G08R0A_MFR          0xec  /* Samsung */
37 #define K9F1G08R0A_ID           0xa1  /* part # */
38
39 /* Since Micron and Samsung parts are similar in geometry and bus width
40  * we can use the same driver. Need to revisit to make this file independent
41  * of part/manufacturer
42  */
43 #define MT29F1G_MFR             0x2c  /* Micron */
44 #define MT29F1G_MFR2            0x20  /* numonyx */
45 #define MT29F1G_ID              0xa1  /* x8, 1GiB */
46 #define MT29F2G_ID              0xba  /* x16, 2GiB */
47 #define MT29F4G_ID              0xbc  /* x16, 4GiB */
48
49 #define ADDR_COLUMN             1          
50 #define ADDR_PAGE               2             
51 #define ADDR_COLUMN_PAGE        (ADDR_COLUMN | ADDR_PAGE)
52
53 #define ADDR_OOB                (0x4 | ADDR_COLUMN_PAGE) 
54
55 #define PAGE_SIZE               2048
56 #define OOB_SIZE                64
57 #define MAX_NUM_PAGES           64
58
59 #define ECC_CHECK_ENABLE
60 #define ECC_SIZE                24
61 #define ECC_STEPS               3
62
63 /*******************************************************
64  * Routine: delay
65  * Description: spinning delay to use before udelay works
66  ******************************************************/
67 static inline void delay (unsigned long loops)
68 {
69         __asm__ volatile ("1:\n"
70                                           "subs %0, %0, #1\n"
71                                           "bne 1b":"=r" (loops):"0" (loops));
72 }
73
74 static int nand_read_page(u_char *buf, ulong page_addr);
75 static int nand_read_oob(u_char * buf, ulong page_addr);
76
77 /* JFFS2 large page layout for 3-byte ECC per 256 bytes ECC layout */
78 /* This is the only SW ECC supported by u-boot. So to load u-boot 
79  * this should be supported */
80 static u_char ecc_pos[] = 
81                 {40, 41, 42, 43, 44, 45, 46, 47,
82                 48, 49, 50, 51, 52, 53, 54, 55,
83                 56, 57, 58, 59, 60, 61, 62, 63};
84 static u_char eccvalid_pos = 4;
85
86 static unsigned long chipsize = (256 << 20);
87
88 #ifdef NAND_16BIT
89 static int bus_width = 16;
90 #else
91 static int bus_width = 8;
92 #endif
93
94 /* NanD_Command: Send a flash command to the flash chip */
95 static int NanD_Command(unsigned char command)
96 {
97         NAND_CTL_SETCLE(NAND_ADDR);
98
99         WRITE_NAND_COMMAND(command, NAND_ADDR);
100         NAND_CTL_CLRCLE(NAND_ADDR);
101
102         if(command == NAND_CMD_RESET){
103                 unsigned char ret_val;
104                 NanD_Command(NAND_CMD_STATUS);
105                 do{
106                         ret_val = READ_NAND(NAND_ADDR);/* wait till ready */
107                 } while((ret_val & 0x40) != 0x40);
108         }
109         
110         NAND_WAIT_READY();
111         return 0;
112 }
113
114
115 /* NanD_Address: Set the current address for the flash chip */
116 static int NanD_Address(unsigned int numbytes, unsigned long ofs)
117 {
118         uchar u;
119
120         NAND_CTL_SETALE(NAND_ADDR);
121
122         if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE 
123                                 || numbytes == ADDR_OOB)
124         {
125                 ushort col = ofs;
126
127                 u = col  & 0xff;
128                 WRITE_NAND_ADDRESS(u, NAND_ADDR);
129
130                 u = (col >> 8) & 0x07;
131                 if (numbytes == ADDR_OOB)
132                         u = u | ((bus_width == 16) ? (1 << 2) : (1 << 3));
133                 WRITE_NAND_ADDRESS(u, NAND_ADDR);
134         }
135
136         if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE
137                                 || numbytes == ADDR_OOB)
138         {
139                 u = (ofs >> 11) & 0xff;
140                 WRITE_NAND_ADDRESS(u, NAND_ADDR);
141                 u = (ofs >> 19) & 0xff;
142                 WRITE_NAND_ADDRESS(u, NAND_ADDR);
143
144                 /* One more address cycle for devices > 128MiB */
145                 if (chipsize > (128 << 20)) {
146                         u = (ofs >> 27) & 0xff;
147                         WRITE_NAND_ADDRESS(u, NAND_ADDR);
148                 }
149         }
150
151         NAND_CTL_CLRALE(NAND_ADDR);
152
153         NAND_WAIT_READY();
154         return 0;
155 }
156
157 int nand_readid(int *mfr, int *id)
158 {
159         NAND_ENABLE_CE();
160
161         if (NanD_Command(NAND_CMD_RESET)) {
162                 NAND_DISABLE_CE();
163                 return 1;
164         }
165  
166         if (NanD_Command(NAND_CMD_READID)) {
167                 NAND_DISABLE_CE();
168                 return 1;
169         }
170  
171         NanD_Address(ADDR_COLUMN, 0);
172
173         *mfr = READ_NAND(NAND_ADDR);
174         *id = READ_NAND(NAND_ADDR);
175
176         NAND_DISABLE_CE();
177         return 0;
178 }
179
180 /* read chip mfr and id
181  * return 0 if they match board config
182  * return 1 if not
183  */
184 int nand_chip()
185 {
186         int mfr, id;
187
188         NAND_ENABLE_CE();
189
190         if (NanD_Command(NAND_CMD_RESET)) {
191                 printf("Err: RESET\n");
192                 NAND_DISABLE_CE();   
193                 return 1;
194         }
195  
196         if (NanD_Command(NAND_CMD_READID)) {
197                 printf("Err: READID\n");
198                 NAND_DISABLE_CE();
199                 return 1;
200         }
201  
202         NanD_Address(ADDR_COLUMN, 0);
203
204         mfr = READ_NAND(NAND_ADDR);
205         id = READ_NAND(NAND_ADDR);
206
207         NAND_DISABLE_CE();
208
209         if (((mfr == MT29F1G_MFR || mfr == MT29F1G_MFR2) &&
210                 (id == MT29F1G_ID || id == MT29F2G_ID || id == MT29F4G_ID)) ||
211              (mfr == K9F1G08R0A_MFR && (id == K9F1G08R0A_ID))) {
212                 return 0;
213         } else {
214                 printf("Unknown chip: mfr was 0x%02x, id was 0x%02x\n", mfr, id);
215                 return 1;
216         }
217 }
218
219 /* read a block data to buf
220  * return 1 if the block is bad or ECC error can't be corrected for any page
221  * return 0 on sucess
222  */ 
223 int nand_read_block(unsigned char *buf, ulong block_addr)
224 {
225         int i, offset = 0;
226
227 #ifdef ECC_CHECK_ENABLE
228         u16 oob_buf[OOB_SIZE >> 1];
229         
230         /* check bad block */
231         /* 0th word in spare area needs be 0xff */
232         if (nand_read_oob(oob_buf, block_addr) || (oob_buf[0] & 0xff) != 0xff){
233                 printf("Skipped bad block at 0x%x\n", block_addr);
234                 return 1;    /* skip bad block */
235         }
236 #endif
237         /* read the block page by page*/
238         for (i=0; i<MAX_NUM_PAGES; i++){
239                 if (nand_read_page(buf+offset, block_addr + offset))
240                         return 1;
241                 offset += PAGE_SIZE;
242         }
243
244         return 0;
245 }
246 static count = 0;
247 /* read a page with ECC */
248 static int nand_read_page(u_char *buf, ulong page_addr)
249 {
250 #ifdef ECC_CHECK_ENABLE
251         u_char ecc_code[ECC_SIZE];
252         u_char ecc_calc[ECC_STEPS];
253         u_char oob_buf[OOB_SIZE];
254 #endif
255         u16 val;
256         int cntr;
257         int len;
258
259 #ifdef NAND_16BIT
260         u16 *p;
261 #else
262         u_char *p;
263 #endif
264
265         NAND_ENABLE_CE();   
266         NanD_Command(NAND_CMD_READ0);
267         NanD_Address(ADDR_COLUMN_PAGE, page_addr);
268         NanD_Command(NAND_CMD_READSTART);
269         NAND_WAIT_READY();
270
271         /* A delay seems to be helping here. needs more investigation */
272         delay(10000);
273         len = (bus_width == 16) ? PAGE_SIZE >> 1 : PAGE_SIZE;
274         p = buf;
275         for (cntr = 0; cntr < len; cntr++){
276                 *p++ = READ_NAND(NAND_ADDR);
277                 delay(10);
278         }
279         
280 #ifdef ECC_CHECK_ENABLE
281         p = oob_buf;
282         len = (bus_width == 16) ? OOB_SIZE >> 1 : OOB_SIZE;
283         for (cntr = 0; cntr < len; cntr++){
284                 *p++ = READ_NAND(NAND_ADDR);
285                 delay(10);
286         }
287         count = 0;
288         NAND_DISABLE_CE();  /* set pin high */
289
290         /* Pick the ECC bytes out of the oob data */
291         for (cntr = 0; cntr < ECC_SIZE; cntr++)
292                 ecc_code[cntr] =  oob_buf[ecc_pos[cntr]];
293
294         for(count = 0; count < ECC_SIZE; count += ECC_STEPS) {
295                 nand_calculate_ecc (buf, &ecc_calc[0]);
296                 if (nand_correct_data (buf, &ecc_code[count], &ecc_calc[0]) == -1) {
297                         printf ("ECC Failed, page 0x%08x\n", page_addr);
298                         for (val=0; val <256; val++)
299                                 printf("%x ", buf[val]);
300                         printf("\n");
301                         for (;;);
302                         return 1;
303                 }
304                 buf += 256;
305                 page_addr += 256;
306         }
307 #endif  
308         return 0;
309 }
310
311 /* read from the 16 bytes of oob data that correspond to a 512 / 2048 byte page.
312  */
313 static int nand_read_oob(u_char *buf, ulong page_addr)
314 {
315         u16 val;
316         int cntr;
317         int len;
318
319 #ifdef NAND_16BIT
320         u16 *p;
321 #else
322         u_char *p;
323 #endif
324         p = buf;
325         len = (bus_width == 16) ? OOB_SIZE >> 1 : OOB_SIZE;
326
327         NAND_ENABLE_CE();  /* set pin low */
328         NanD_Command(NAND_CMD_READ0);
329         NanD_Address(ADDR_OOB, page_addr);
330         NanD_Command(NAND_CMD_READSTART);
331         NAND_WAIT_READY();
332
333         /* A delay seems to be helping here. needs more investigation */
334         delay(10000);
335         for (cntr = 0; cntr < len; cntr++)
336                 *p++ = READ_NAND(NAND_ADDR);
337   
338         NAND_WAIT_READY();
339         NAND_DISABLE_CE();  /* set pin high */
340
341         return 0;
342 }
343
344 #endif