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