drivers/k9f1g08r0a.c: additional nand vendor/device id's
[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 /* read chip mfr and id
158  * return 0 if they match board config
159  * return 1 if not
160  */
161 int nand_chip()
162 {
163         int mfr, id;
164
165         NAND_ENABLE_CE();
166
167         if (NanD_Command(NAND_CMD_RESET)) {
168                 printf("Err: RESET\n");
169                 NAND_DISABLE_CE();   
170                 return 1;
171         }
172  
173         if (NanD_Command(NAND_CMD_READID)) {
174                 printf("Err: READID\n");
175                 NAND_DISABLE_CE();
176                 return 1;
177         }
178  
179         NanD_Address(ADDR_COLUMN, 0);
180
181         mfr = READ_NAND(NAND_ADDR);
182         id = READ_NAND(NAND_ADDR);
183
184         NAND_DISABLE_CE();
185
186         if (((mfr == MT29F1G_MFR || mfr == MT29F1G_MFR2) &&
187                 (id == MT29F1G_ID || id == MT29F2G_ID || id == MT29F4G_ID)) ||
188              (mfr == K9F1G08R0A_MFR && (id == K9F1G08R0A_ID))) {
189                 return 0;
190         } else {
191                 printf("Unknown chip: mfr was 0x%02x, id was 0x%02x\n", mfr, id);
192                 return 1;
193         }
194 }
195
196 /* read a block data to buf
197  * return 1 if the block is bad or ECC error can't be corrected for any page
198  * return 0 on sucess
199  */ 
200 int nand_read_block(unsigned char *buf, ulong block_addr)
201 {
202         int i, offset = 0;
203
204 #ifdef ECC_CHECK_ENABLE
205         u16 oob_buf[OOB_SIZE >> 1];
206         
207         /* check bad block */
208         /* 0th word in spare area needs be 0xff */
209         if (nand_read_oob(oob_buf, block_addr) || (oob_buf[0] & 0xff) != 0xff){
210                 printf("Skipped bad block at 0x%x\n", block_addr);
211                 return 1;    /* skip bad block */
212         }
213 #endif
214         /* read the block page by page*/
215         for (i=0; i<MAX_NUM_PAGES; i++){
216                 if (nand_read_page(buf+offset, block_addr + offset))
217                         return 1;
218                 offset += PAGE_SIZE;
219         }
220
221         return 0;
222 }
223 static count = 0;
224 /* read a page with ECC */
225 static int nand_read_page(u_char *buf, ulong page_addr)
226 {
227 #ifdef ECC_CHECK_ENABLE
228         u_char ecc_code[ECC_SIZE];
229         u_char ecc_calc[ECC_STEPS];
230         u_char oob_buf[OOB_SIZE];
231 #endif
232         u16 val;
233         int cntr;
234         int len;
235
236 #ifdef NAND_16BIT
237         u16 *p;
238 #else
239         u_char *p;
240 #endif
241
242         NAND_ENABLE_CE();   
243         NanD_Command(NAND_CMD_READ0);
244         NanD_Address(ADDR_COLUMN_PAGE, page_addr);
245         NanD_Command(NAND_CMD_READSTART);
246         NAND_WAIT_READY();
247
248         /* A delay seems to be helping here. needs more investigation */
249         delay(10000);
250         len = (bus_width == 16) ? PAGE_SIZE >> 1 : PAGE_SIZE;
251         p = buf;
252         for (cntr = 0; cntr < len; cntr++){
253                 *p++ = READ_NAND(NAND_ADDR);
254                 delay(10);
255         }
256         
257 #ifdef ECC_CHECK_ENABLE
258         p = oob_buf;
259         len = (bus_width == 16) ? OOB_SIZE >> 1 : OOB_SIZE;
260         for (cntr = 0; cntr < len; cntr++){
261                 *p++ = READ_NAND(NAND_ADDR);
262                 delay(10);
263         }
264         count = 0;
265         NAND_DISABLE_CE();  /* set pin high */
266
267         /* Pick the ECC bytes out of the oob data */
268         for (cntr = 0; cntr < ECC_SIZE; cntr++)
269                 ecc_code[cntr] =  oob_buf[ecc_pos[cntr]];
270
271         for(count = 0; count < ECC_SIZE; count += ECC_STEPS) {
272                 nand_calculate_ecc (buf, &ecc_calc[0]);
273                 if (nand_correct_data (buf, &ecc_code[count], &ecc_calc[0]) == -1) {
274                         printf ("ECC Failed, page 0x%08x\n", page_addr);
275                         for (val=0; val <256; val++)
276                                 printf("%x ", buf[val]);
277                         printf("\n");
278                         for (;;);
279                         return 1;
280                 }
281                 buf += 256;
282                 page_addr += 256;
283         }
284 #endif  
285         return 0;
286 }
287
288 /* read from the 16 bytes of oob data that correspond to a 512 / 2048 byte page.
289  */
290 static int nand_read_oob(u_char *buf, ulong page_addr)
291 {
292         u16 val;
293         int cntr;
294         int len;
295
296 #ifdef NAND_16BIT
297         u16 *p;
298 #else
299         u_char *p;
300 #endif
301         p = buf;
302         len = (bus_width == 16) ? OOB_SIZE >> 1 : OOB_SIZE;
303
304         NAND_ENABLE_CE();  /* set pin low */
305         NanD_Command(NAND_CMD_READ0);
306         NanD_Address(ADDR_OOB, page_addr);
307         NanD_Command(NAND_CMD_READSTART);
308         NAND_WAIT_READY();
309
310         /* A delay seems to be helping here. needs more investigation */
311         delay(10000);
312         for (cntr = 0; cntr < len; cntr++)
313                 *p++ = READ_NAND(NAND_ADDR);
314   
315         NAND_WAIT_READY();
316         NAND_DISABLE_CE();  /* set pin high */
317
318         return 0;
319 }
320
321 #endif