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 /* Used by the upper layer to write command to NAND Flash for
 546  * different operations to be carried out on NAND Flash */
 547 static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
 548                                 int column, int page_addr)
 549 {
 550         struct nand_chip *nand_chip = mtd->priv;
 551         struct mxc_nand_host *host = nand_chip->priv;
 552
 553         DEBUG(MTD_DEBUG_LEVEL3,
 554               "mxc_nand_command (cmd = 0x%x, col = 0x%x, page = 0x%x)\n",
 555               command, column, page_addr);
 556
 557         /* Reset command state information */
 558         host->status_request = false;
 559
 560         /* Command pre-processing step */
 561         switch (command) {
 562
 563         case NAND_CMD_STATUS:
 564                 host->buf_start = 0;
 565                 host->status_request = true;
 566
 567                 send_cmd(host, command, true);
 568                 mxc_do_addr_cycle(mtd, column, page_addr);
 569                 break;
 570
 571         case NAND_CMD_READ0:
 572         case NAND_CMD_READOOB:
 573                 if (command == NAND_CMD_READ0)
 574                         host->buf_start = column;
 575                 else
 576                         host->buf_start = column + mtd->writesize;
 577
 578                 if (mtd->writesize > 512)
 579                         command = NAND_CMD_READ0; /* only READ0 is valid */
 580
 581                 send_cmd(host, command, false);
 582                 mxc_do_addr_cycle(mtd, column, page_addr);
 583
 584                 if (mtd->writesize > 512)
 585                         send_cmd(host, NAND_CMD_READSTART, true);
 586
 587                 send_page(mtd, NFC_OUTPUT);
 588
 589                 memcpy(host->data_buf, host->main_area0, mtd->writesize);
 590                 copy_spare(mtd, true);
 591                 break;
 592
 593         case NAND_CMD_SEQIN:
 594                 if (column >= mtd->writesize) {
 595                         /*
 596                          * FIXME: before send SEQIN command for write OOB,
 597                          * We must read one page out.
 598                          * For K9F1GXX has no READ1 command to set current HW
 599                          * pointer to spare area, we must write the whole page
 600                          * including OOB together.
 601                          */
 602                         if (mtd->writesize > 512)
 603                                 /* call ourself to read a page */
 604                                 mxc_nand_command(mtd, NAND_CMD_READ0, 0,
 605                                                 page_addr);
 606
 607                         host->buf_start = column;
 608
 609                         /* Set program pointer to spare region */
 610                         if (mtd->writesize == 512)
 611                                 send_cmd(host, NAND_CMD_READOOB, false);
 612                 } else {
 613                         host->buf_start = column;
 614
 615                         /* Set program pointer to page start */
 616                         if (mtd->writesize == 512)
 617                                 send_cmd(host, NAND_CMD_READ0, false);
 618                 }
 619
 620                 send_cmd(host, command, false);
 621                 mxc_do_addr_cycle(mtd, column, page_addr);
 622                 break;
 623
 624         case NAND_CMD_PAGEPROG:
 625                 memcpy(host->main_area0, host->data_buf, mtd->writesize);
 626                 copy_spare(mtd, false);
 627                 send_page(mtd, NFC_INPUT);
 628                 send_cmd(host, command, true);
 629                 mxc_do_addr_cycle(mtd, column, page_addr);
 630                 break;
 631
 632         case NAND_CMD_READID:
 633                 send_cmd(host, command, true);
 634                 mxc_do_addr_cycle(mtd, column, page_addr);
 635                 send_read_id(host);
 636                 host->buf_start = column;
 637                 break;
 638
 639         case NAND_CMD_ERASE1:
 640         case NAND_CMD_ERASE2:
 641         case NAND_CMD_RESET:
 642                 send_cmd(host, command, false);
 643                 mxc_do_addr_cycle(mtd, column, page_addr);
 644
 645                 break;
 646         }
 647 }
 648
 649 /*
 650  * The generic flash bbt decriptors overlap with our ecc
 651  * hardware, so define some i.MX specific ones.
 652  */
 653 static uint8_t bbt_pattern[] = { 'B', 'b', 't', '0' };
 654 static uint8_t mirror_pattern[] = { '1', 't', 'b', 'B' };
 655
 656 static struct nand_bbt_descr bbt_main_descr = {
 657         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
 658             | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
 659         .offs = 0,
 660         .len = 4,
 661         .veroffs = 4,
 662         .maxblocks = 4,
 663         .pattern = bbt_pattern,
 664 };
 665
 666 static struct nand_bbt_descr bbt_mirror_descr = {
 667         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
 668             | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
 669         .offs = 0,
 670         .len = 4,
 671         .veroffs = 4,
 672         .maxblocks = 4,
 673         .pattern = mirror_pattern,
 674 };
 675
 676 static int __init mxcnd_probe(struct platform_device *pdev)
 677 {
 678         struct nand_chip *this;
 679         struct mtd_info *mtd;
 680         struct mxc_nand_platform_data *pdata = pdev->dev.platform_data;
 681         struct mxc_nand_host *host;
 682         struct resource *res;
 683         uint16_t tmp;
 684         int err = 0, nr_parts = 0;
 685         struct nand_ecclayout *oob_smallpage, *oob_largepage;
 686
 687         /* Allocate memory for MTD device structure and private data */
 688         host = kzalloc(sizeof(struct mxc_nand_host) + NAND_MAX_PAGESIZE +
 689                         NAND_MAX_OOBSIZE, GFP_KERNEL);
 690         if (!host)
 691                 return -ENOMEM;
 692
 693         host->data_buf = (uint8_t *)(host + 1);
 694
 695         host->dev = &pdev->dev;
 696         /* structures must be linked */
 697         this = &host->nand;
 698         mtd = &host->mtd;
 699         mtd->priv = this;
 700         mtd->owner = THIS_MODULE;
 701         mtd->dev.parent = &pdev->dev;
 702         mtd->name = DRIVER_NAME;
 703
 704         /* 50 us command delay time */
 705         this->chip_delay = 5;
 706
 707         this->priv = host;
 708         this->dev_ready = mxc_nand_dev_ready;
 709         this->cmdfunc = mxc_nand_command;
 710         this->select_chip = mxc_nand_select_chip;
 711         this->read_byte = mxc_nand_read_byte;
 712         this->read_word = mxc_nand_read_word;
 713         this->write_buf = mxc_nand_write_buf;
 714         this->read_buf = mxc_nand_read_buf;
 715         this->verify_buf = mxc_nand_verify_buf;
 716
 717         host->clk = clk_get(&pdev->dev, "nfc");
 718         if (IS_ERR(host->clk)) {
 719                 err = PTR_ERR(host->clk);
 720                 goto eclk;
 721         }
 722
 723         clk_enable(host->clk);
 724         host->clk_act = 1;
 725
 726         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 727         if (!res) {
 728                 err = -ENODEV;
 729                 goto eres;
 730         }
 731
 732         host->base = ioremap(res->start, resource_size(res));
 733         if (!host->base) {
 734                 err = -ENOMEM;
 735                 goto eres;
 736         }
 737
 738         host->main_area0 = host->base;
 739         host->main_area1 = host->base + 0x200;
 740
 741         if (nfc_is_v21()) {
 742                 host->regs = host->base + 0x1000;
 743                 host->spare0 = host->base + 0x1000;
 744                 host->spare_len = 64;
 745                 oob_smallpage = &nandv2_hw_eccoob_smallpage;
 746                 oob_largepage = &nandv2_hw_eccoob_largepage;
 747         } else if (nfc_is_v1()) {
 748                 host->regs = host->base;
 749                 host->spare0 = host->base + 0x800;
 750                 host->spare_len = 16;
 751                 oob_smallpage = &nandv1_hw_eccoob_smallpage;
 752                 oob_largepage = &nandv1_hw_eccoob_largepage;
 753         } else
 754                 BUG();
 755
 756         /* disable interrupt and spare enable */
 757         tmp = readw(host->regs + NFC_CONFIG1);
 758         tmp |= NFC_INT_MSK;
 759         tmp &= ~NFC_SP_EN;
 760         writew(tmp, host->regs + NFC_CONFIG1);
 761
 762         init_waitqueue_head(&host->irq_waitq);
 763
 764         host->irq = platform_get_irq(pdev, 0);
 765
 766         err = request_irq(host->irq, mxc_nfc_irq, 0, DRIVER_NAME, host);
 767         if (err)
 768                 goto eirq;
 769
 770         /* Reset NAND */
 771         this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
 772
 773         /* preset operation */
 774         /* Unlock the internal RAM Buffer */
 775         writew(0x2, host->regs + NFC_CONFIG);
 776
 777         /* Blocks to be unlocked */
 778         if (nfc_is_v21()) {
 779                 writew(0x0, host->regs + NFC_V21_UNLOCKSTART_BLKADDR);
 780                 writew(0xffff, host->regs + NFC_V21_UNLOCKEND_BLKADDR);
 781                 this->ecc.bytes = 9;
 782         } else if (nfc_is_v1()) {
 783                 writew(0x0, host->regs + NFC_V1_UNLOCKSTART_BLKADDR);
 784                 writew(0x4000, host->regs + NFC_V1_UNLOCKEND_BLKADDR);
 785                 this->ecc.bytes = 3;
 786         } else
 787                 BUG();
 788
 789         /* Unlock Block Command for given address range */
 790         writew(0x4, host->regs + NFC_WRPROT);
 791
 792         this->ecc.size = 512;
 793         this->ecc.layout = oob_smallpage;
 794
 795         if (pdata->hw_ecc) {
 796                 this->ecc.calculate = mxc_nand_calculate_ecc;
 797                 this->ecc.hwctl = mxc_nand_enable_hwecc;
 798                 this->ecc.correct = mxc_nand_correct_data;
 799                 this->ecc.mode = NAND_ECC_HW;
 800                 tmp = readw(host->regs + NFC_CONFIG1);
 801                 tmp |= NFC_ECC_EN;
 802                 writew(tmp, host->regs + NFC_CONFIG1);
 803         } else {
 804                 this->ecc.mode = NAND_ECC_SOFT;
 805                 tmp = readw(host->regs + NFC_CONFIG1);
 806                 tmp &= ~NFC_ECC_EN;
 807                 writew(tmp, host->regs + NFC_CONFIG1);
 808         }
 809
 810         /* NAND bus width determines access funtions used by upper layer */
 811         if (pdata->width == 2)
 812                 this->options |= NAND_BUSWIDTH_16;
 813
 814         if (pdata->flash_bbt) {
 815                 this->bbt_td = &bbt_main_descr;
 816                 this->bbt_md = &bbt_mirror_descr;
 817                 /* update flash based bbt */
 818                 this->options |= NAND_USE_FLASH_BBT;
 819         }
 820
 821         /* first scan to find the device and get the page size */
 822         if (nand_scan_ident(mtd, 1, NULL)) {
 823                 err = -ENXIO;
 824                 goto escan;
 825         }
 826
 827         if (mtd->writesize == 2048)
 828                 this->ecc.layout = oob_largepage;
 829
 830         /* second phase scan */
 831         if (nand_scan_tail(mtd)) {
 832                 err = -ENXIO;
 833                 goto escan;
 834         }
 835
 836         /* Register the partitions */
 837 #ifdef CONFIG_MTD_PARTITIONS
 838         nr_parts =
 839             parse_mtd_partitions(mtd, part_probes, &host->parts, 0);
 840         if (nr_parts > 0)
 841                 add_mtd_partitions(mtd, host->parts, nr_parts);
 842         else
 843 #endif
 844         {
 845                 pr_info("Registering %s as whole device\n", mtd->name);
 846                 add_mtd_device(mtd);
 847         }
 848
 849         platform_set_drvdata(pdev, host);
 850
 851         return 0;
 852
 853 escan:
 854         free_irq(host->irq, host);
 855 eirq:
 856         iounmap(host->base);
 857 eres:
 858         clk_put(host->clk);
 859 eclk:
 860         kfree(host);
 861
 862         return err;
 863 }
 864
 865 static int __devexit mxcnd_remove(struct platform_device *pdev)
 866 {
 867         struct mxc_nand_host *host = platform_get_drvdata(pdev);
 868
 869         clk_put(host->clk);
 870
 871         platform_set_drvdata(pdev, NULL);
 872
 873         nand_release(&host->mtd);
 874         free_irq(host->irq, host);
 875         iounmap(host->base);
 876         kfree(host);
 877
 878         return 0;
 879 }
 880
 881 #ifdef CONFIG_PM
 882 static int mxcnd_suspend(struct platform_device *pdev, pm_message_t state)
 883 {
 884         struct mtd_info *mtd = platform_get_drvdata(pdev);
 885         struct nand_chip *nand_chip = mtd->priv;
 886         struct mxc_nand_host *host = nand_chip->priv;
 887         int ret = 0;
 888
 889         DEBUG(MTD_DEBUG_LEVEL0, "MXC_ND : NAND suspend\n");
 890
 891         ret = mtd->suspend(mtd);
 892
 893         /*
 894          * nand_suspend locks the device for exclusive access, so
 895          * the clock must already be off.
 896          */
 897         BUG_ON(!ret && host->clk_act);
 898
 899         return ret;
 900 }
 901
 902 static int mxcnd_resume(struct platform_device *pdev)
 903 {
 904         struct mtd_info *mtd = platform_get_drvdata(pdev);
 905         struct nand_chip *nand_chip = mtd->priv;
 906         struct mxc_nand_host *host = nand_chip->priv;
 907         int ret = 0;
 908
 909         DEBUG(MTD_DEBUG_LEVEL0, "MXC_ND : NAND resume\n");
 910
 911         mtd->resume(mtd);
 912
 913         return ret;
 914 }
 915
 916 #else
 917 # define mxcnd_suspend   NULL
 918 # define mxcnd_resume    NULL
 919 #endif                          /* CONFIG_PM */
 920
 921 static struct platform_driver mxcnd_driver = {
 922         .driver = {
 923                    .name = DRIVER_NAME,
 924                    },
 925         .remove = __devexit_p(mxcnd_remove),
 926         .suspend = mxcnd_suspend,
 927         .resume = mxcnd_resume,
 928 };
 929
 930 static int __init mxc_nd_init(void)
 931 {
 932         return platform_driver_probe(&mxcnd_driver, mxcnd_probe);
 933 }
 934
 935 static void __exit mxc_nd_cleanup(void)
 936 {
 937         /* Unregister the device structure */
 938         platform_driver_unregister(&mxcnd_driver);
 939 }
 940
 941 module_init(mxc_nd_init);
 942 module_exit(mxc_nd_cleanup);
 943
 944 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 945 MODULE_DESCRIPTION("MXC NAND MTD driver");
 946 MODULE_LICENSE("GPL");