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
  50 #define ADDR_COLUMN             1
  51 #define ADDR_PAGE               2
  52 #define ADDR_COLUMN_PAGE        (ADDR_COLUMN | ADDR_PAGE)
  53
  54 #define ADDR_OOB                (0x4 | ADDR_COLUMN_PAGE)
  55
  56 #define PAGE_SIZE               2048
  57 #define OOB_SIZE                64
  58 #define MAX_NUM_PAGES           64
  59
  60 #define ECC_CHECK_ENABLE
  61 #define ECC_SIZE                24
  62 #define ECC_STEPS               3
  63
  64 /*******************************************************
  65  * Routine: delay
  66  * Description: spinning delay to use before udelay works
  67  ******************************************************/
  68 static inline void delay (unsigned long loops)
  69 {
  70         __asm__ volatile ("1:\n"
  71                                           "subs %0, %0, #1\n"
  72                                           "bne 1b":"=r" (loops):"0" (loops));
  73 }
  74
  75 static int nand_read_page(u_char *buf, ulong page_addr);
  76 static int nand_read_oob(u_char * buf, ulong page_addr);
  77
  78 /* JFFS2 large page layout for 3-byte ECC per 256 bytes ECC layout */
  79 /* This is the only SW ECC supported by u-boot. So to load u-boot
  80  * this should be supported */
  81 static u_char ecc_pos[] =
  82                 {40, 41, 42, 43, 44, 45, 46, 47,
  83                 48, 49, 50, 51, 52, 53, 54, 55,
  84                 56, 57, 58, 59, 60, 61, 62, 63};
  85 static u_char eccvalid_pos = 4;
  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 /* read chip mfr and id
 182  * return 0 if they match board config
 183  * return 1 if not
 184  */
 185 int nand_chip()
 186 {
 187         int mfr, id;
 188
 189         NAND_ENABLE_CE();
 190
 191         if (NanD_Command(NAND_CMD_RESET)) {
 192                 printf("Err: RESET\n");
 193                 NAND_DISABLE_CE();
 194                 return 1;
 195         }
 196
 197         if (NanD_Command(NAND_CMD_READID)) {
 198                 printf("Err: READID\n");
 199                 NAND_DISABLE_CE();
 200                 return 1;
 201         }
 202
 203         NanD_Address(ADDR_COLUMN, 0);
 204
 205         mfr = READ_NAND(NAND_ADDR);
 206         id = READ_NAND(NAND_ADDR);
 207
 208         NAND_DISABLE_CE();
 209
 210         if (((mfr == MT29F1G_MFR || mfr == MT29F1G_MFR2 || mfr == MT29F1G_MFR3) &&
 211                 (id == MT29F1G_ID || id == MT29F2G_ID || id == MT29F4G_ID)) ||
 212              (mfr == K9F1G08R0A_MFR && (id == K9F1G08R0A_ID))) {
 213                 return 0;
 214         } else {
 215                 if ((mfr == 0) && (id == 0)) {
 216                         printf("No NAND detected\n");
 217                         return 0;
 218                 } else {
 219                         printf("Unknown chip: mfr was 0x%02x, id was 0x%02x\n", mfr, id);
 220                         return 1;
 221                 }
 222         }
 223 }
 224
 225 /* read a block data to buf
 226  * return 1 if the block is bad or ECC error can't be corrected for any page
 227  * return 0 on sucess
 228  */
 229 int nand_read_block(unsigned char *buf, ulong block_addr)
 230 {
 231         int i, offset = 0;
 232
 233 #ifdef ECC_CHECK_ENABLE
 234         u16 oob_buf[OOB_SIZE >> 1];
 235
 236         /* check bad block */
 237         /* 0th word in spare area needs be 0xff */
 238         if (nand_read_oob(oob_buf, block_addr) || (oob_buf[0] & 0xff) != 0xff){
 239                 printf("Skipped bad block at 0x%x\n", block_addr);
 240                 return 1;    /* skip bad block */
 241         }
 242 #endif
 243         /* read the block page by page*/
 244         for (i=0; i<MAX_NUM_PAGES; i++){
 245                 if (nand_read_page(buf+offset, block_addr + offset))
 246                         return 1;
 247                 offset += PAGE_SIZE;
 248         }
 249
 250         return 0;
 251 }
 252 static count = 0;
 253 /* read a page with ECC */
 254 static int nand_read_page(u_char *buf, ulong page_addr)
 255 {
 256 #ifdef ECC_CHECK_ENABLE
 257         u_char ecc_code[ECC_SIZE];
 258         u_char ecc_calc[ECC_STEPS];
 259         u_char oob_buf[OOB_SIZE];
 260 #endif
 261         u16 val;
 262         int cntr;
 263         int len;
 264
 265 #ifdef NAND_16BIT
 266         u16 *p;
 267 #else
 268         u_char *p;
 269 #endif
 270
 271         NAND_ENABLE_CE();
 272         NanD_Command(NAND_CMD_READ0);
 273         NanD_Address(ADDR_COLUMN_PAGE, page_addr);
 274         NanD_Command(NAND_CMD_READSTART);
 275         NAND_WAIT_READY();
 276
 277         /* A delay seems to be helping here. needs more investigation */
 278         delay(10000);
 279         len = (bus_width == 16) ? PAGE_SIZE >> 1 : PAGE_SIZE;
 280         p = buf;
 281         for (cntr = 0; cntr < len; cntr++){
 282                 *p++ = READ_NAND(NAND_ADDR);
 283                 delay(10);
 284         }
 285
 286 #ifdef ECC_CHECK_ENABLE
 287         p = oob_buf;
 288         len = (bus_width == 16) ? OOB_SIZE >> 1 : OOB_SIZE;
 289         for (cntr = 0; cntr < len; cntr++){
 290                 *p++ = READ_NAND(NAND_ADDR);
 291                 delay(10);
 292         }
 293         count = 0;
 294         NAND_DISABLE_CE();  /* set pin high */
 295
 296         /* Pick the ECC bytes out of the oob data */
 297         for (cntr = 0; cntr < ECC_SIZE; cntr++)
 298                 ecc_code[cntr] =  oob_buf[ecc_pos[cntr]];
 299
 300         for(count = 0; count < ECC_SIZE; count += ECC_STEPS) {
 301                 nand_calculate_ecc (buf, &ecc_calc[0]);
 302                 if (nand_correct_data (buf, &ecc_code[count], &ecc_calc[0]) == -1) {
 303                         printf ("ECC Failed, page 0x%08x\n", page_addr);
 304                         for (val=0; val <256; val++)
 305                                 printf("%x ", buf[val]);
 306                         printf("\n");
 307                         for (;;);
 308                         return 1;
 309                 }
 310                 buf += 256;
 311                 page_addr += 256;
 312         }
 313 #endif
 314         return 0;
 315 }
 316
 317 /* read from the 16 bytes of oob data that correspond to a 512 / 2048 byte page.
 318  */
 319 static int nand_read_oob(u_char *buf, ulong page_addr)
 320 {
 321         u16 val;
 322         int cntr;
 323         int len;
 324
 325 #ifdef NAND_16BIT
 326         u16 *p;
 327 #else
 328         u_char *p;
 329 #endif
 330         p = buf;
 331         len = (bus_width == 16) ? OOB_SIZE >> 1 : OOB_SIZE;
 332
 333         NAND_ENABLE_CE();  /* set pin low */
 334         NanD_Command(NAND_CMD_READ0);
 335         NanD_Address(ADDR_OOB, page_addr);
 336         NanD_Command(NAND_CMD_READSTART);
 337         NAND_WAIT_READY();
 338
 339         /* A delay seems to be helping here. needs more investigation */
 340         delay(10000);
 341         for (cntr = 0; cntr < len; cntr++)
 342                 *p++ = READ_NAND(NAND_ADDR);
 343
 344         NAND_WAIT_READY();
 345         NAND_DISABLE_CE();  /* set pin high */
 346
 347         return 0;
 348 }
 349
 350 #endif