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