drivers/mtd/nand/mxc_nand.c

   1 /*
   2  * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
   3  * Copyright 2008 Sascha Hauer, kernel@pengutronix.de
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  17  * MA 02110-1301, USA.
  18  */
  19
  20 #include <linux/delay.h>
  21 #include <linux/slab.h>
  22 #include <linux/init.h>
  23 #include <linux/module.h>
  24 #include <linux/mtd/mtd.h>
  25 #include <linux/mtd/nand.h>
  26 #include <linux/mtd/partitions.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/device.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/clk.h>
  31 #include <linux/err.h>
  32 #include <linux/io.h>
  33
  34 #include <asm/mach/flash.h>
  35 #include <mach/mxc_nand.h>
  36 #include <mach/hardware.h>
  37
  38 #define DRIVER_NAME "mxc_nand"
  39
  40 #define nfc_is_v21()            (cpu_is_mx25() || cpu_is_mx35())
  41 #define nfc_is_v1()             (cpu_is_mx31() || cpu_is_mx27())
  42
  43 /* Addresses for NFC registers */
  44 #define NFC_BUF_SIZE            0xE00
  45 #define NFC_BUF_ADDR            0xE04
  46 #define NFC_FLASH_ADDR          0xE06
  47 #define NFC_FLASH_CMD           0xE08
  48 #define NFC_CONFIG              0xE0A
  49 #define NFC_ECC_STATUS_RESULT   0xE0C
  50 #define NFC_RSLTMAIN_AREA       0xE0E
  51 #define NFC_RSLTSPARE_AREA      0xE10
  52 #define NFC_WRPROT              0xE12
  53 #define NFC_V1_UNLOCKSTART_BLKADDR      0xe14
  54 #define NFC_V1_UNLOCKEND_BLKADDR        0xe16
  55 #define NFC_V21_UNLOCKSTART_BLKADDR     0xe20
  56 #define NFC_V21_UNLOCKEND_BLKADDR       0xe22
  57 #define NFC_NF_WRPRST           0xE18
  58 #define NFC_CONFIG1             0xE1A
  59 #define NFC_CONFIG2             0xE1C
  60
  61 /* Set INT to 0, FCMD to 1, rest to 0 in NFC_CONFIG2 Register
  62  * for Command operation */
  63 #define NFC_CMD            0x1
  64
  65 /* Set INT to 0, FADD to 1, rest to 0 in NFC_CONFIG2 Register
  66  * for Address operation */
  67 #define NFC_ADDR           0x2
  68
  69 /* Set INT to 0, FDI to 1, rest to 0 in NFC_CONFIG2 Register
  70  * for Input operation */
  71 #define NFC_INPUT          0x4
  72
  73 /* Set INT to 0, FDO to 001, rest to 0 in NFC_CONFIG2 Register
  74  * for Data Output operation */
  75 #define NFC_OUTPUT         0x8
  76
  77 /* Set INT to 0, FD0 to 010, rest to 0 in NFC_CONFIG2 Register
  78  * for Read ID operation */
  79 #define NFC_ID             0x10
  80
  81 /* Set INT to 0, FDO to 100, rest to 0 in NFC_CONFIG2 Register
  82  * for Read Status operation */
  83 #define NFC_STATUS         0x20
  84
  85 /* Set INT to 1, rest to 0 in NFC_CONFIG2 Register for Read
  86  * Status operation */
  87 #define NFC_INT            0x8000
  88
  89 #define NFC_SP_EN           (1 << 2)
  90 #define NFC_ECC_EN          (1 << 3)
  91 #define NFC_INT_MSK         (1 << 4)
  92 #define NFC_BIG             (1 << 5)
  93 #define NFC_RST             (1 << 6)
  94 #define NFC_CE              (1 << 7)
  95 #define NFC_ONE_CYCLE       (1 << 8)
  96
  97 struct mxc_nand_host {
  98         struct mtd_info         mtd;
  99         struct nand_chip        nand;
 100         struct mtd_partition    *parts;
 101         struct device           *dev;
 102
 103         void                    *spare0;
 104         void                    *main_area0;
 105         void                    *main_area1;
 106
 107         void __iomem            *base;
 108         void __iomem            *regs;
 109         int                     status_request;
 110         struct clk              *clk;
 111         int                     clk_act;
 112         int                     irq;
 113
 114         wait_queue_head_t       irq_waitq;
 115
 116         uint8_t                 *data_buf;
 117         unsigned int            buf_start;
 118         int                     spare_len;
 119 };
 120
 121 /* OOB placement block for use with hardware ecc generation */
 122 static struct nand_ecclayout nandv1_hw_eccoob_smallpage = {
 123         .eccbytes = 5,
 124         .eccpos = {6, 7, 8, 9, 10},
 125         .oobfree = {{0, 5}, {12, 4}, }
 126 };
 127
 128 static struct nand_ecclayout nandv1_hw_eccoob_largepage = {
 129         .eccbytes = 20,
 130         .eccpos = {6, 7, 8, 9, 10, 22, 23, 24, 25, 26,
 131                    38, 39, 40, 41, 42, 54, 55, 56, 57, 58},
 132         .oobfree = {{2, 4}, {11, 10}, {27, 10}, {43, 10}, {59, 5}, }
 133 };
 134
 135 /* OOB description for 512 byte pages with 16 byte OOB */
 136 static struct nand_ecclayout nandv2_hw_eccoob_smallpage = {
 137         .eccbytes = 1 * 9,
 138         .eccpos = {
 139                  7,  8,  9, 10, 11, 12, 13, 14, 15
 140         },
 141         .oobfree = {
 142                 {.offset = 0, .length = 5}
 143         }
 144 };
 145
 146 /* OOB description for 2048 byte pages with 64 byte OOB */
 147 static struct nand_ecclayout nandv2_hw_eccoob_largepage = {
 148         .eccbytes = 4 * 9,
 149         .eccpos = {
 150                  7,  8,  9, 10, 11, 12, 13, 14, 15,
 151                 23, 24, 25, 26, 27, 28, 29, 30, 31,
 152                 39, 40, 41, 42, 43, 44, 45, 46, 47,
 153                 55, 56, 57, 58, 59, 60, 61, 62, 63
 154         },
 155         .oobfree = {
 156                 {.offset = 2, .length = 4},
 157                 {.offset = 16, .length = 7},
 158                 {.offset = 32, .length = 7},
 159                 {.offset = 48, .length = 7}
 160         }
 161 };
 162
 163 #ifdef CONFIG_MTD_PARTITIONS
 164 static const char *part_probes[] = { "RedBoot", "cmdlinepart", NULL };
 165 #endif
 166
 167 static irqreturn_t mxc_nfc_irq(int irq, void *dev_id)
 168 {
 169         struct mxc_nand_host *host = dev_id;
 170
 171         uint16_t tmp;
 172
 173         tmp = readw(host->regs + NFC_CONFIG1);
 174         tmp |= NFC_INT_MSK; /* Disable interrupt */
 175         writew(tmp, host->regs + NFC_CONFIG1);
 176
 177         wake_up(&host->irq_waitq);
 178
 179         return IRQ_HANDLED;
 180 }
 181
 182 /* This function polls the NANDFC to wait for the basic operation to
 183  * complete by checking the INT bit of config2 register.
 184  */
 185 static void wait_op_done(struct mxc_nand_host *host, int useirq)
 186 {
 187         uint32_t tmp;
 188         int max_retries = 2000;
 189
 190         if (useirq) {
 191                 if ((readw(host->regs + NFC_CONFIG2) & NFC_INT) == 0) {
 192
 193                         tmp = readw(host->regs + NFC_CONFIG1);
 194                         tmp  &= ~NFC_INT_MSK;   /* Enable interrupt */
 195                         writew(tmp, host->regs + NFC_CONFIG1);
 196
 197                         wait_event(host->irq_waitq,
 198                                 readw(host->regs + NFC_CONFIG2) & NFC_INT);
 199
 200                         tmp = readw(host->regs + NFC_CONFIG2);
 201                         tmp  &= ~NFC_INT;
 202                         writew(tmp, host->regs + NFC_CONFIG2);
 203                 }
 204         } else {
 205                 while (max_retries-- > 0) {
 206                         if (readw(host->regs + NFC_CONFIG2) & NFC_INT) {
 207                                 tmp = readw(host->regs + NFC_CONFIG2);
 208                                 tmp  &= ~NFC_INT;
 209                                 writew(tmp, host->regs + NFC_CONFIG2);
 210                                 break;
 211                         }
 212                         udelay(1);
 213                 }
 214                 if (max_retries < 0)
 215                         DEBUG(MTD_DEBUG_LEVEL0, "%s: INT not set\n",
 216                               __func__);
 217         }
 218 }
 219
 220 /* This function issues the specified command to the NAND device and
 221  * waits for completion. */
 222 static void send_cmd(struct mxc_nand_host *host, uint16_t cmd, int useirq)
 223 {
 224         DEBUG(MTD_DEBUG_LEVEL3, "send_cmd(host, 0x%x, %d)\n", cmd, useirq);
 225
 226         writew(cmd, host->regs + NFC_FLASH_CMD);
 227         writew(NFC_CMD, host->regs + NFC_CONFIG2);
 228
 229         /* Wait for operation to complete */
 230         wait_op_done(host, useirq);
 231 }
 232
 233 /* This function sends an address (or partial address) to the
 234  * NAND device. The address is used to select the source/destination for
 235  * a NAND command. */
 236 static void send_addr(struct mxc_nand_host *host, uint16_t addr, int islast)
 237 {
 238         DEBUG(MTD_DEBUG_LEVEL3, "send_addr(host, 0x%x %d)\n", addr, islast);
 239
 240         writew(addr, host->regs + NFC_FLASH_ADDR);
 241         writew(NFC_ADDR, host->regs + NFC_CONFIG2);
 242
 243         /* Wait for operation to complete */
 244         wait_op_done(host, islast);
 245 }
 246
 247 static void send_page(struct mtd_info *mtd, unsigned int ops)
 248 {
 249         struct nand_chip *nand_chip = mtd->priv;
 250         struct mxc_nand_host *host = nand_chip->priv;
 251         int bufs, i;
 252
 253         if (nfc_is_v1() && mtd->writesize > 512)
 254                 bufs = 4;
 255         else
 256                 bufs = 1;
 257
 258         for (i = 0; i < bufs; i++) {
 259
 260                 /* NANDFC buffer 0 is used for page read/write */
 261                 writew(i, host->regs + NFC_BUF_ADDR);
 262
 263                 writew(ops, host->regs + NFC_CONFIG2);
 264
 265                 /* Wait for operation to complete */
 266                 wait_op_done(host, true);
 267         }
 268 }
 269
 270 /* Request the NANDFC to perform a read of the NAND device ID. */
 271 static void send_read_id(struct mxc_nand_host *host)
 272 {
 273         struct nand_chip *this = &host->nand;
 274
 275         /* NANDFC buffer 0 is used for device ID output */
 276         writew(0x0, host->regs + NFC_BUF_ADDR);
 277
 278         writew(NFC_ID, host->regs + NFC_CONFIG2);
 279
 280         /* Wait for operation to complete */
 281         wait_op_done(host, true);
 282
 283         if (this->options & NAND_BUSWIDTH_16) {
 284                 void __iomem *main_buf = host->main_area0;
 285                 /* compress the ID info */
 286                 writeb(readb(main_buf + 2), main_buf + 1);
 287                 writeb(readb(main_buf + 4), main_buf + 2);
 288                 writeb(readb(main_buf + 6), main_buf + 3);
 289                 writeb(readb(main_buf + 8), main_buf + 4);
 290                 writeb(readb(main_buf + 10), main_buf + 5);
 291         }
 292         memcpy(host->data_buf, host->main_area0, 16);
 293 }
 294
 295 /* This function requests the NANDFC to perform a read of the
 296  * NAND device status and returns the current status. */
 297 static uint16_t get_dev_status(struct mxc_nand_host *host)
 298 {
 299         void __iomem *main_buf = host->main_area1;
 300         uint32_t store;
 301         uint16_t ret;
 302         /* Issue status request to NAND device */
 303
 304         /* store the main area1 first word, later do recovery */
 305         store = readl(main_buf);
 306         /* NANDFC buffer 1 is used for device status to prevent
 307          * corruption of read/write buffer on status requests. */
 308         writew(1, host->regs + NFC_BUF_ADDR);
 309
 310         writew(NFC_STATUS, host->regs + NFC_CONFIG2);
 311
 312         /* Wait for operation to complete */
 313         wait_op_done(host, true);
 314
 315         /* Status is placed in first word of main buffer */
 316         /* get status, then recovery area 1 data */
 317         ret = readw(main_buf);
 318         writel(store, main_buf);
 319
 320         return ret;
 321 }
 322
 323 /* This functions is used by upper layer to checks if device is ready */
 324 static int mxc_nand_dev_ready(struct mtd_info *mtd)
 325 {
 326         /*
 327          * NFC handles R/B internally. Therefore, this function
 328          * always returns status as ready.
 329          */
 330         return 1;
 331 }
 332
 333 static void mxc_nand_enable_hwecc(struct mtd_info *mtd, int mode)
 334 {
 335         /*
 336          * If HW ECC is enabled, we turn it on during init. There is
 337          * no need to enable again here.
 338          */
 339 }
 340
 341 static int mxc_nand_correct_data(struct mtd_info *mtd, u_char *dat,
 342                                  u_char *read_ecc, u_char *calc_ecc)
 343 {
 344         struct nand_chip *nand_chip = mtd->priv;
 345         struct mxc_nand_host *host = nand_chip->priv;
 346
 347         /*
 348          * 1-Bit errors are automatically corrected in HW.  No need for
 349          * additional correction.  2-Bit errors cannot be corrected by
 350          * HW ECC, so we need to return failure
 351          */
 352         uint16_t ecc_status = readw(host->regs + NFC_ECC_STATUS_RESULT);
 353
 354         if (((ecc_status & 0x3) == 2) || ((ecc_status >> 2) == 2)) {
 355                 DEBUG(MTD_DEBUG_LEVEL0,
 356                       "MXC_NAND: HWECC uncorrectable 2-bit ECC error\n");
 357                 return -1;
 358         }
 359
 360         return 0;
 361 }
 362
 363 static int mxc_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
 364                                   u_char *ecc_code)
 365 {
 366         return 0;
 367 }
 368
 369 static u_char mxc_nand_read_byte(struct mtd_info *mtd)
 370 {
 371         struct nand_chip *nand_chip = mtd->priv;
 372         struct mxc_nand_host *host = nand_chip->priv;
 373         uint8_t ret;
 374
 375         /* Check for status request */
 376         if (host->status_request)
 377                 return get_dev_status(host) & 0xFF;
 378
 379         ret = *(uint8_t *)(host->data_buf + host->buf_start);
 380         host->buf_start++;
 381
 382         return ret;
 383 }
 384
 385 static uint16_t mxc_nand_read_word(struct mtd_info *mtd)
 386 {
 387         struct nand_chip *nand_chip = mtd->priv;
 388         struct mxc_nand_host *host = nand_chip->priv;
 389         uint16_t ret;
 390
 391         ret = *(uint16_t *)(host->data_buf + host->buf_start);
 392         host->buf_start += 2;
 393
 394         return ret;
 395 }
 396
 397 /* Write data of length len to buffer buf. The data to be
 398  * written on NAND Flash is first copied to RAMbuffer. After the Data Input
 399  * Operation by the NFC, the data is written to NAND Flash */
 400 static void mxc_nand_write_buf(struct mtd_info *mtd,
 401                                 const u_char *buf, int len)
 402 {
 403         struct nand_chip *nand_chip = mtd->priv;
 404         struct mxc_nand_host *host = nand_chip->priv;
 405         u16 col = host->buf_start;
 406         int n = mtd->oobsize + mtd->writesize - col;
 407
 408         n = min(n, len);
 409
 410         memcpy(host->data_buf + col, buf, n);
 411
 412         host->buf_start += n;
 413 }
 414
 415 /* Read the data buffer from the NAND Flash. To read the data from NAND
 416  * Flash first the data output cycle is initiated by the NFC, which copies
 417  * the data to RAMbuffer. This data of length len is then copied to buffer buf.
 418  */
 419 static void mxc_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 420 {
 421         struct nand_chip *nand_chip = mtd->priv;
 422         struct mxc_nand_host *host = nand_chip->priv;
 423         u16 col = host->buf_start;
 424         int n = mtd->oobsize + mtd->writesize - col;
 425
 426         n = min(n, len);
 427
 428         memcpy(buf, host->data_buf + col, len);
 429
 430         host->buf_start += len;
 431 }
 432
 433 /* Used by the upper layer to verify the data in NAND Flash
 434  * with the data in the buf. */
 435 static int mxc_nand_verify_buf(struct mtd_info *mtd,
 436                                 const u_char *buf, int len)
 437 {
 438         return -EFAULT;
 439 }
 440
 441 /* This function is used by upper layer for select and
 442  * deselect of the NAND chip */
 443 static void mxc_nand_select_chip(struct mtd_info *mtd, int chip)
 444 {
 445         struct nand_chip *nand_chip = mtd->priv;
 446         struct mxc_nand_host *host = nand_chip->priv;
 447
 448         switch (chip) {
 449         case -1:
 450                 /* Disable the NFC clock */
 451                 if (host->clk_act) {
 452                         clk_disable(host->clk);
 453                         host->clk_act = 0;
 454                 }
 455                 break;
 456         case 0:
 457                 /* Enable the NFC clock */
 458                 if (!host->clk_act) {
 459                         clk_enable(host->clk);
 460                         host->clk_act = 1;
 461                 }
 462                 break;
 463
 464         default:
 465                 break;
 466         }
 467 }
 468
 469 /*
 470  * Function to transfer data to/from spare area.
 471  */
 472 static void copy_spare(struct mtd_info *mtd, bool bfrom)
 473 {
 474         struct nand_chip *this = mtd->priv;
 475         struct mxc_nand_host *host = this->priv;
 476         u16 i, j;
 477         u16 n = mtd->writesize >> 9;
 478         u8 *d = host->data_buf + mtd->writesize;
 479         u8 *s = host->spare0;
 480         u16 t = host->spare_len;
 481
 482         j = (mtd->oobsize / n >> 1) << 1;
 483
 484         if (bfrom) {
 485                 for (i = 0; i < n - 1; i++)
 486                         memcpy(d + i * j, s + i * t, j);
 487
 488                 /* the last section */
 489                 memcpy(d + i * j, s + i * t, mtd->oobsize - i * j);
 490         } else {
 491                 for (i = 0; i < n - 1; i++)
 492                         memcpy(&s[i * t], &d[i * j], j);
 493
 494                 /* the last section */
 495                 memcpy(&s[i * t], &d[i * j], mtd->oobsize - i * j);
 496         }
 497 }
 498
 499 static void mxc_do_addr_cycle(struct mtd_info *mtd, int column, int page_addr)
 500 {
 501         struct nand_chip *nand_chip = mtd->priv;
 502         struct mxc_nand_host *host = nand_chip->priv;
 503
 504         /* Write out column address, if necessary */
 505         if (column != -1) {
 506                 /*
 507                  * MXC NANDFC can only perform full page+spare or
 508                  * spare-only read/write.  When the upper layers
 509                  * layers perform a read/write buf operation,
 510                  * we will used the saved column address to index into
 511                  * the full page.
 512                  */
 513                 send_addr(host, 0, page_addr == -1);
 514                 if (mtd->writesize > 512)
 515                         /* another col addr cycle for 2k page */
 516                         send_addr(host, 0, false);
 517         }
 518
 519         /* Write out page address, if necessary */
 520         if (page_addr != -1) {
 521                 /* paddr_0 - p_addr_7 */
 522                 send_addr(host, (page_addr & 0xff), false);
 523
 524                 if (mtd->writesize > 512) {
 525                         if (mtd->size >= 0x10000000) {
 526                                 /* paddr_8 - paddr_15 */
 527                                 send_addr(host, (page_addr >> 8) & 0xff, false);
 528                                 send_addr(host, (page_addr >> 16) & 0xff, true);
 529                         } else
 530                                 /* paddr_8 - paddr_15 */
 531                                 send_addr(host, (page_addr >> 8) & 0xff, true);
 532                 } else {
 533                         /* One more address cycle for higher density devices */
 534                         if (mtd->size >= 0x4000000) {
 535                                 /* paddr_8 - paddr_15 */
 536                                 send_addr(host, (page_addr >> 8) & 0xff, false);
 537                                 send_addr(host, (page_addr >> 16) & 0xff, true);
 538                         } else
 539                                 /* paddr_8 - paddr_15 */
 540                                 send_addr(host, (page_addr >> 8) & 0xff, true);
 541                 }
 542         }
 543 }
 544
 545 static void preset(struct mtd_info *mtd)
 546 {
 547         struct nand_chip *nand_chip = mtd->priv;
 548         struct mxc_nand_host *host = nand_chip->priv;
 549         uint16_t tmp;
 550
 551         /* disable interrupt, disable spare enable */
 552         tmp = readw(host->regs + NFC_CONFIG1);
 553         tmp |= NFC_INT_MSK;
 554         tmp &= ~NFC_SP_EN;
 555         if (nand_chip->ecc.mode == NAND_ECC_HW) {
 556                 tmp |= NFC_ECC_EN;
 557         } else {
 558                 tmp &= ~NFC_ECC_EN;
 559         }
 560         writew(tmp, host->regs + NFC_CONFIG1);
 561         /* preset operation */
 562
 563         /* Unlock the internal RAM Buffer */
 564         writew(0x2, host->regs + NFC_CONFIG);
 565
 566         /* Blocks to be unlocked */
 567         if (nfc_is_v21()) {
 568                 writew(0x0, host->regs + NFC_V21_UNLOCKSTART_BLKADDR);
 569                 writew(0xffff, host->regs + NFC_V21_UNLOCKEND_BLKADDR);
 570         } else if (nfc_is_v1()) {
 571                 writew(0x0, host->regs + NFC_V1_UNLOCKSTART_BLKADDR);
 572                 writew(0x4000, host->regs + NFC_V1_UNLOCKEND_BLKADDR);
 573         } else
 574                 BUG();
 575
 576         /* Unlock Block Command for given address range */
 577         writew(0x4, host->regs + NFC_WRPROT);
 578 }
 579
 580 /* Used by the upper layer to write command to NAND Flash for
 581  * different operations to be carried out on NAND Flash */
 582 static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
 583                                 int column, int page_addr)
 584 {
 585         struct nand_chip *nand_chip = mtd->priv;
 586         struct mxc_nand_host *host = nand_chip->priv;
 587
 588         DEBUG(MTD_DEBUG_LEVEL3,
 589               "mxc_nand_command (cmd = 0x%x, col = 0x%x, page = 0x%x)\n",
 590               command, column, page_addr);
 591
 592         /* Reset command state information */
 593         host->status_request = false;
 594
 595         /* Command pre-processing step */
 596         switch (command) {
 597         case NAND_CMD_RESET:
 598                 send_cmd(host, command, false);
 599                 preset(mtd);
 600                 break;
 601
 602         case NAND_CMD_STATUS:
 603                 host->buf_start = 0;
 604                 host->status_request = true;
 605
 606                 send_cmd(host, command, true);
 607                 mxc_do_addr_cycle(mtd, column, page_addr);
 608                 break;
 609
 610         case NAND_CMD_READ0:
 611         case NAND_CMD_READOOB:
 612                 if (command == NAND_CMD_READ0)
 613                         host->buf_start = column;
 614                 else
 615                         host->buf_start = column + mtd->writesize;
 616
 617                 if (mtd->writesize > 512)
 618                         command = NAND_CMD_READ0; /* only READ0 is valid */
 619
 620                 send_cmd(host, command, false);
 621                 mxc_do_addr_cycle(mtd, column, page_addr);
 622
 623                 if (mtd->writesize > 512)
 624                         send_cmd(host, NAND_CMD_READSTART, true);
 625
 626                 send_page(mtd, NFC_OUTPUT);
 627
 628                 memcpy(host->data_buf, host->main_area0, mtd->writesize);
 629                 copy_spare(mtd, true);
 630                 break;
 631
 632         case NAND_CMD_SEQIN:
 633                 if (column >= mtd->writesize) {
 634                         /*
 635                          * FIXME: before send SEQIN command for write OOB,
 636                          * We must read one page out.
 637                          * For K9F1GXX has no READ1 command to set current HW
 638                          * pointer to spare area, we must write the whole page
 639                          * including OOB together.
 640                          */
 641                         if (mtd->writesize > 512)
 642                                 /* call ourself to read a page */
 643                                 mxc_nand_command(mtd, NAND_CMD_READ0, 0,
 644                                                 page_addr);
 645
 646                         host->buf_start = column;
 647
 648                         /* Set program pointer to spare region */
 649                         if (mtd->writesize == 512)
 650                                 send_cmd(host, NAND_CMD_READOOB, false);
 651                 } else {
 652                         host->buf_start = column;
 653
 654                         /* Set program pointer to page start */
 655                         if (mtd->writesize == 512)
 656                                 send_cmd(host, NAND_CMD_READ0, false);
 657                 }
 658
 659                 send_cmd(host, command, false);
 660                 mxc_do_addr_cycle(mtd, column, page_addr);
 661                 break;
 662
 663         case NAND_CMD_PAGEPROG:
 664                 memcpy(host->main_area0, host->data_buf, mtd->writesize);
 665                 copy_spare(mtd, false);
 666                 send_page(mtd, NFC_INPUT);
 667                 send_cmd(host, command, true);
 668                 mxc_do_addr_cycle(mtd, column, page_addr);
 669                 break;
 670
 671         case NAND_CMD_READID:
 672                 send_cmd(host, command, true);
 673                 mxc_do_addr_cycle(mtd, column, page_addr);
 674                 send_read_id(host);
 675                 host->buf_start = column;
 676                 break;
 677
 678         case NAND_CMD_ERASE1:
 679         case NAND_CMD_ERASE2:
 680                 send_cmd(host, command, false);
 681                 mxc_do_addr_cycle(mtd, column, page_addr);
 682
 683                 break;
 684         }
 685 }
 686
 687 /*
 688  * The generic flash bbt decriptors overlap with our ecc
 689  * hardware, so define some i.MX specific ones.
 690  */
 691 static uint8_t bbt_pattern[] = { 'B', 'b', 't', '0' };
 692 static uint8_t mirror_pattern[] = { '1', 't', 'b', 'B' };
 693
 694 static struct nand_bbt_descr bbt_main_descr = {
 695         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
 696             | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
 697         .offs = 0,
 698         .len = 4,
 699         .veroffs = 4,
 700         .maxblocks = 4,
 701         .pattern = bbt_pattern,
 702 };
 703
 704 static struct nand_bbt_descr bbt_mirror_descr = {
 705         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
 706             | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
 707         .offs = 0,
 708         .len = 4,
 709         .veroffs = 4,
 710         .maxblocks = 4,
 711         .pattern = mirror_pattern,
 712 };
 713
 714 static int __init mxcnd_probe(struct platform_device *pdev)
 715 {
 716         struct nand_chip *this;
 717         struct mtd_info *mtd;
 718         struct mxc_nand_platform_data *pdata = pdev->dev.platform_data;
 719         struct mxc_nand_host *host;
 720         struct resource *res;
 721         int err = 0, nr_parts = 0;
 722         struct nand_ecclayout *oob_smallpage, *oob_largepage;
 723
 724         /* Allocate memory for MTD device structure and private data */
 725         host = kzalloc(sizeof(struct mxc_nand_host) + NAND_MAX_PAGESIZE +
 726                         NAND_MAX_OOBSIZE, GFP_KERNEL);
 727         if (!host)
 728                 return -ENOMEM;
 729
 730         host->data_buf = (uint8_t *)(host + 1);
 731
 732         host->dev = &pdev->dev;
 733         /* structures must be linked */
 734         this = &host->nand;
 735         mtd = &host->mtd;
 736         mtd->priv = this;
 737         mtd->owner = THIS_MODULE;
 738         mtd->dev.parent = &pdev->dev;
 739         mtd->name = DRIVER_NAME;
 740
 741         /* 50 us command delay time */
 742         this->chip_delay = 5;
 743
 744         this->priv = host;
 745         this->dev_ready = mxc_nand_dev_ready;
 746         this->cmdfunc = mxc_nand_command;
 747         this->select_chip = mxc_nand_select_chip;
 748         this->read_byte = mxc_nand_read_byte;
 749         this->read_word = mxc_nand_read_word;
 750         this->write_buf = mxc_nand_write_buf;
 751         this->read_buf = mxc_nand_read_buf;
 752         this->verify_buf = mxc_nand_verify_buf;
 753
 754         host->clk = clk_get(&pdev->dev, "nfc");
 755         if (IS_ERR(host->clk)) {
 756                 err = PTR_ERR(host->clk);
 757                 goto eclk;
 758         }
 759
 760         clk_enable(host->clk);
 761         host->clk_act = 1;
 762
 763         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 764         if (!res) {
 765                 err = -ENODEV;
 766                 goto eres;
 767         }
 768
 769         host->base = ioremap(res->start, resource_size(res));
 770         if (!host->base) {
 771                 err = -ENOMEM;
 772                 goto eres;
 773         }
 774
 775         host->main_area0 = host->base;
 776         host->main_area1 = host->base + 0x200;
 777
 778         if (nfc_is_v21()) {
 779                 host->regs = host->base + 0x1000;
 780                 host->spare0 = host->base + 0x1000;
 781                 host->spare_len = 64;
 782                 oob_smallpage = &nandv2_hw_eccoob_smallpage;
 783                 oob_largepage = &nandv2_hw_eccoob_largepage;
 784                 this->ecc.bytes = 9;
 785         } else if (nfc_is_v1()) {
 786                 host->regs = host->base;
 787                 host->spare0 = host->base + 0x800;
 788                 host->spare_len = 16;
 789                 oob_smallpage = &nandv1_hw_eccoob_smallpage;
 790                 oob_largepage = &nandv1_hw_eccoob_largepage;
 791                 this->ecc.bytes = 3;
 792         } else
 793                 BUG();
 794
 795         this->ecc.size = 512;
 796         this->ecc.layout = oob_smallpage;
 797
 798         if (pdata->hw_ecc) {
 799                 this->ecc.calculate = mxc_nand_calculate_ecc;
 800                 this->ecc.hwctl = mxc_nand_enable_hwecc;
 801                 this->ecc.correct = mxc_nand_correct_data;
 802                 this->ecc.mode = NAND_ECC_HW;
 803         } else {
 804                 this->ecc.mode = NAND_ECC_SOFT;
 805         }
 806
 807         /* NAND bus width determines access funtions used by upper layer */
 808         if (pdata->width == 2)
 809                 this->options |= NAND_BUSWIDTH_16;
 810
 811         if (pdata->flash_bbt) {
 812                 this->bbt_td = &bbt_main_descr;
 813                 this->bbt_md = &bbt_mirror_descr;
 814                 /* update flash based bbt */
 815                 this->options |= NAND_USE_FLASH_BBT;
 816         }
 817
 818         init_waitqueue_head(&host->irq_waitq);
 819
 820         host->irq = platform_get_irq(pdev, 0);
 821
 822         err = request_irq(host->irq, mxc_nfc_irq, 0, DRIVER_NAME, host);
 823         if (err)
 824                 goto eirq;
 825
 826         /* first scan to find the device and get the page size */
 827         if (nand_scan_ident(mtd, 1)) {
 828                 err = -ENXIO;
 829                 goto escan;
 830         }
 831
 832         if (mtd->writesize == 2048)
 833                 this->ecc.layout = oob_largepage;
 834
 835         /* second phase scan */
 836         if (nand_scan_tail(mtd)) {
 837                 err = -ENXIO;
 838                 goto escan;
 839         }
 840
 841         /* Register the partitions */
 842 #ifdef CONFIG_MTD_PARTITIONS
 843         nr_parts =
 844             parse_mtd_partitions(mtd, part_probes, &host->parts, 0);
 845         if (nr_parts > 0)
 846                 add_mtd_partitions(mtd, host->parts, nr_parts);
 847         else
 848 #endif
 849         {
 850                 pr_info("Registering %s as whole device\n", mtd->name);
 851                 add_mtd_device(mtd);
 852         }
 853
 854         platform_set_drvdata(pdev, host);
 855
 856         return 0;
 857
 858 escan:
 859         free_irq(host->irq, host);
 860 eirq:
 861         iounmap(host->base);
 862 eres:
 863         clk_put(host->clk);
 864 eclk:
 865         kfree(host);
 866
 867         return err;
 868 }
 869
 870 static int __devexit mxcnd_remove(struct platform_device *pdev)
 871 {
 872         struct mxc_nand_host *host = platform_get_drvdata(pdev);
 873
 874         clk_put(host->clk);
 875
 876         platform_set_drvdata(pdev, NULL);
 877
 878         nand_release(&host->mtd);
 879         free_irq(host->irq, host);
 880         iounmap(host->base);
 881         kfree(host);
 882
 883         return 0;
 884 }
 885
 886 #ifdef CONFIG_PM
 887 static int mxcnd_suspend(struct platform_device *pdev, pm_message_t state)
 888 {
 889         struct mtd_info *mtd = platform_get_drvdata(pdev);
 890         struct nand_chip *nand_chip = mtd->priv;
 891         struct mxc_nand_host *host = nand_chip->priv;
 892         int ret = 0;
 893
 894         DEBUG(MTD_DEBUG_LEVEL0, "MXC_ND : NAND suspend\n");
 895         if (mtd) {
 896                 ret = mtd->suspend(mtd);
 897                 /* Disable the NFC clock */
 898                 clk_disable(host->clk);
 899         }
 900
 901         return ret;
 902 }
 903
 904 static int mxcnd_resume(struct platform_device *pdev)
 905 {
 906         struct mtd_info *mtd = platform_get_drvdata(pdev);
 907         struct nand_chip *nand_chip = mtd->priv;
 908         struct mxc_nand_host *host = nand_chip->priv;
 909         int ret = 0;
 910
 911         DEBUG(MTD_DEBUG_LEVEL0, "MXC_ND : NAND resume\n");
 912
 913         if (mtd) {
 914                 /* Enable the NFC clock */
 915                 clk_enable(host->clk);
 916                 mtd->resume(mtd);
 917         }
 918
 919         return ret;
 920 }
 921
 922 #else
 923 # define mxcnd_suspend   NULL
 924 # define mxcnd_resume    NULL
 925 #endif                          /* CONFIG_PM */
 926
 927 static struct platform_driver mxcnd_driver = {
 928         .driver = {
 929                    .name = DRIVER_NAME,
 930                    },
 931         .remove = __devexit_p(mxcnd_remove),
 932         .suspend = mxcnd_suspend,
 933         .resume = mxcnd_resume,
 934 };
 935
 936 static int __init mxc_nd_init(void)
 937 {
 938         return platform_driver_probe(&mxcnd_driver, mxcnd_probe);
 939 }
 940
 941 static void __exit mxc_nd_cleanup(void)
 942 {
 943         /* Unregister the device structure */
 944         platform_driver_unregister(&mxcnd_driver);
 945 }
 946
 947 module_init(mxc_nd_init);
 948 module_exit(mxc_nd_cleanup);
 949
 950 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 951 MODULE_DESCRIPTION("MXC NAND MTD driver");
 952 MODULE_LICENSE("GPL");