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 #include <linux/irq.h>
  34 #include <linux/completion.h>
  35
  36 #include <asm/mach/flash.h>
  37 #include <mach/mxc_nand.h>
  38 #include <mach/hardware.h>
  39
  40 #define DRIVER_NAME "mxc_nand"
  41
  42 #define nfc_is_v21()            (cpu_is_mx25() || cpu_is_mx35())
  43 #define nfc_is_v1()             (cpu_is_mx31() || cpu_is_mx27() || cpu_is_mx21())
  44 #define nfc_is_v3_2()           cpu_is_mx51()
  45 #define nfc_is_v3()             nfc_is_v3_2()
  46
  47 /* Addresses for NFC registers */
  48 #define NFC_V1_V2_BUF_SIZE              (host->regs + 0x00)
  49 #define NFC_V1_V2_BUF_ADDR              (host->regs + 0x04)
  50 #define NFC_V1_V2_FLASH_ADDR            (host->regs + 0x06)
  51 #define NFC_V1_V2_FLASH_CMD             (host->regs + 0x08)
  52 #define NFC_V1_V2_CONFIG                (host->regs + 0x0a)
  53 #define NFC_V1_V2_ECC_STATUS_RESULT     (host->regs + 0x0c)
  54 #define NFC_V1_V2_RSLTMAIN_AREA         (host->regs + 0x0e)
  55 #define NFC_V1_V2_RSLTSPARE_AREA        (host->regs + 0x10)
  56 #define NFC_V1_V2_WRPROT                (host->regs + 0x12)
  57 #define NFC_V1_UNLOCKSTART_BLKADDR      (host->regs + 0x14)
  58 #define NFC_V1_UNLOCKEND_BLKADDR        (host->regs + 0x16)
  59 #define NFC_V21_UNLOCKSTART_BLKADDR     (host->regs + 0x20)
  60 #define NFC_V21_UNLOCKEND_BLKADDR       (host->regs + 0x22)
  61 #define NFC_V1_V2_NF_WRPRST             (host->regs + 0x18)
  62 #define NFC_V1_V2_CONFIG1               (host->regs + 0x1a)
  63 #define NFC_V1_V2_CONFIG2               (host->regs + 0x1c)
  64
  65 #define NFC_V2_CONFIG1_ECC_MODE_4       (1 << 0)
  66 #define NFC_V1_V2_CONFIG1_SP_EN         (1 << 2)
  67 #define NFC_V1_V2_CONFIG1_ECC_EN        (1 << 3)
  68 #define NFC_V1_V2_CONFIG1_INT_MSK       (1 << 4)
  69 #define NFC_V1_V2_CONFIG1_BIG           (1 << 5)
  70 #define NFC_V1_V2_CONFIG1_RST           (1 << 6)
  71 #define NFC_V1_V2_CONFIG1_CE            (1 << 7)
  72 #define NFC_V2_CONFIG1_ONE_CYCLE        (1 << 8)
  73 #define NFC_V2_CONFIG1_PPB(x)           (((x) & 0x3) << 9)
  74 #define NFC_V2_CONFIG1_FP_INT           (1 << 11)
  75
  76 #define NFC_V1_V2_CONFIG2_INT           (1 << 15)
  77
  78 /*
  79  * Operation modes for the NFC. Valid for v1, v2 and v3
  80  * type controllers.
  81  */
  82 #define NFC_CMD                         (1 << 0)
  83 #define NFC_ADDR                        (1 << 1)
  84 #define NFC_INPUT                       (1 << 2)
  85 #define NFC_OUTPUT                      (1 << 3)
  86 #define NFC_ID                          (1 << 4)
  87 #define NFC_STATUS                      (1 << 5)
  88
  89 #define NFC_V3_FLASH_CMD                (host->regs_axi + 0x00)
  90 #define NFC_V3_FLASH_ADDR0              (host->regs_axi + 0x04)
  91
  92 #define NFC_V3_CONFIG1                  (host->regs_axi + 0x34)
  93 #define NFC_V3_CONFIG1_SP_EN            (1 << 0)
  94 #define NFC_V3_CONFIG1_RBA(x)           (((x) & 0x7 ) << 4)
  95
  96 #define NFC_V3_ECC_STATUS_RESULT        (host->regs_axi + 0x38)
  97
  98 #define NFC_V3_LAUNCH                   (host->regs_axi + 0x40)
  99
 100 #define NFC_V3_WRPROT                   (host->regs_ip + 0x0)
 101 #define NFC_V3_WRPROT_LOCK_TIGHT        (1 << 0)
 102 #define NFC_V3_WRPROT_LOCK              (1 << 1)
 103 #define NFC_V3_WRPROT_UNLOCK            (1 << 2)
 104 #define NFC_V3_WRPROT_BLS_UNLOCK        (2 << 6)
 105
 106 #define NFC_V3_WRPROT_UNLOCK_BLK_ADD0   (host->regs_ip + 0x04)
 107
 108 #define NFC_V3_CONFIG2                  (host->regs_ip + 0x24)
 109 #define NFC_V3_CONFIG2_PS_512                   (0 << 0)
 110 #define NFC_V3_CONFIG2_PS_2048                  (1 << 0)
 111 #define NFC_V3_CONFIG2_PS_4096                  (2 << 0)
 112 #define NFC_V3_CONFIG2_ONE_CYCLE                (1 << 2)
 113 #define NFC_V3_CONFIG2_ECC_EN                   (1 << 3)
 114 #define NFC_V3_CONFIG2_2CMD_PHASES              (1 << 4)
 115 #define NFC_V3_CONFIG2_NUM_ADDR_PHASE0          (1 << 5)
 116 #define NFC_V3_CONFIG2_ECC_MODE_8               (1 << 6)
 117 #define NFC_V3_CONFIG2_PPB(x)                   (((x) & 0x3) << 7)
 118 #define NFC_V3_CONFIG2_NUM_ADDR_PHASE1(x)       (((x) & 0x3) << 12)
 119 #define NFC_V3_CONFIG2_INT_MSK                  (1 << 15)
 120 #define NFC_V3_CONFIG2_ST_CMD(x)                (((x) & 0xff) << 24)
 121 #define NFC_V3_CONFIG2_SPAS(x)                  (((x) & 0xff) << 16)
 122
 123 #define NFC_V3_CONFIG3                          (host->regs_ip + 0x28)
 124 #define NFC_V3_CONFIG3_ADD_OP(x)                (((x) & 0x3) << 0)
 125 #define NFC_V3_CONFIG3_FW8                      (1 << 3)
 126 #define NFC_V3_CONFIG3_SBB(x)                   (((x) & 0x7) << 8)
 127 #define NFC_V3_CONFIG3_NUM_OF_DEVICES(x)        (((x) & 0x7) << 12)
 128 #define NFC_V3_CONFIG3_RBB_MODE                 (1 << 15)
 129 #define NFC_V3_CONFIG3_NO_SDMA                  (1 << 20)
 130
 131 #define NFC_V3_IPC                      (host->regs_ip + 0x2C)
 132 #define NFC_V3_IPC_CREQ                 (1 << 0)
 133 #define NFC_V3_IPC_INT                  (1 << 31)
 134
 135 #define NFC_V3_DELAY_LINE               (host->regs_ip + 0x34)
 136
 137 struct mxc_nand_host {
 138         struct mtd_info         mtd;
 139         struct nand_chip        nand;
 140         struct mtd_partition    *parts;
 141         struct device           *dev;
 142
 143         void                    *spare0;
 144         void                    *main_area0;
 145
 146         void __iomem            *base;
 147         void __iomem            *regs;
 148         void __iomem            *regs_axi;
 149         void __iomem            *regs_ip;
 150         int                     status_request;
 151         struct clk              *clk;
 152         int                     clk_act;
 153         int                     irq;
 154         int                     eccsize;
 155
 156         struct completion       op_completion;
 157
 158         uint8_t                 *data_buf;
 159         unsigned int            buf_start;
 160         int                     spare_len;
 161
 162         void                    (*preset)(struct mtd_info *);
 163         void                    (*send_cmd)(struct mxc_nand_host *, uint16_t, int);
 164         void                    (*send_addr)(struct mxc_nand_host *, uint16_t, int);
 165         void                    (*send_page)(struct mtd_info *, unsigned int);
 166         void                    (*send_read_id)(struct mxc_nand_host *);
 167         uint16_t                (*get_dev_status)(struct mxc_nand_host *);
 168         int                     (*check_int)(struct mxc_nand_host *);
 169         void                    (*irq_control)(struct mxc_nand_host *, int);
 170 };
 171
 172 /* OOB placement block for use with hardware ecc generation */
 173 static struct nand_ecclayout nandv1_hw_eccoob_smallpage = {
 174         .eccbytes = 5,
 175         .eccpos = {6, 7, 8, 9, 10},
 176         .oobfree = {{0, 5}, {12, 4}, }
 177 };
 178
 179 static struct nand_ecclayout nandv1_hw_eccoob_largepage = {
 180         .eccbytes = 20,
 181         .eccpos = {6, 7, 8, 9, 10, 22, 23, 24, 25, 26,
 182                    38, 39, 40, 41, 42, 54, 55, 56, 57, 58},
 183         .oobfree = {{2, 4}, {11, 10}, {27, 10}, {43, 10}, {59, 5}, }
 184 };
 185
 186 /* OOB description for 512 byte pages with 16 byte OOB */
 187 static struct nand_ecclayout nandv2_hw_eccoob_smallpage = {
 188         .eccbytes = 1 * 9,
 189         .eccpos = {
 190                  7,  8,  9, 10, 11, 12, 13, 14, 15
 191         },
 192         .oobfree = {
 193                 {.offset = 0, .length = 5}
 194         }
 195 };
 196
 197 /* OOB description for 2048 byte pages with 64 byte OOB */
 198 static struct nand_ecclayout nandv2_hw_eccoob_largepage = {
 199         .eccbytes = 4 * 9,
 200         .eccpos = {
 201                  7,  8,  9, 10, 11, 12, 13, 14, 15,
 202                 23, 24, 25, 26, 27, 28, 29, 30, 31,
 203                 39, 40, 41, 42, 43, 44, 45, 46, 47,
 204                 55, 56, 57, 58, 59, 60, 61, 62, 63
 205         },
 206         .oobfree = {
 207                 {.offset = 2, .length = 4},
 208                 {.offset = 16, .length = 7},
 209                 {.offset = 32, .length = 7},
 210                 {.offset = 48, .length = 7}
 211         }
 212 };
 213
 214 /* OOB description for 4096 byte pages with 128 byte OOB */
 215 static struct nand_ecclayout nandv2_hw_eccoob_4k = {
 216         .eccbytes = 8 * 9,
 217         .eccpos = {
 218                 7,  8,  9, 10, 11, 12, 13, 14, 15,
 219                 23, 24, 25, 26, 27, 28, 29, 30, 31,
 220                 39, 40, 41, 42, 43, 44, 45, 46, 47,
 221                 55, 56, 57, 58, 59, 60, 61, 62, 63,
 222                 71, 72, 73, 74, 75, 76, 77, 78, 79,
 223                 87, 88, 89, 90, 91, 92, 93, 94, 95,
 224                 103, 104, 105, 106, 107, 108, 109, 110, 111,
 225                 119, 120, 121, 122, 123, 124, 125, 126, 127,
 226         },
 227         .oobfree = {
 228                 {.offset = 2, .length = 4},
 229                 {.offset = 16, .length = 7},
 230                 {.offset = 32, .length = 7},
 231                 {.offset = 48, .length = 7},
 232                 {.offset = 64, .length = 7},
 233                 {.offset = 80, .length = 7},
 234                 {.offset = 96, .length = 7},
 235                 {.offset = 112, .length = 7},
 236         }
 237 };
 238
 239 #ifdef CONFIG_MTD_PARTITIONS
 240 static const char *part_probes[] = { "RedBoot", "cmdlinepart", NULL };
 241 #endif
 242
 243 static irqreturn_t mxc_nfc_irq(int irq, void *dev_id)
 244 {
 245         struct mxc_nand_host *host = dev_id;
 246
 247         if (!host->check_int(host))
 248                 return IRQ_NONE;
 249
 250         host->irq_control(host, 0);
 251
 252         complete(&host->op_completion);
 253
 254         return IRQ_HANDLED;
 255 }
 256
 257 static int check_int_v3(struct mxc_nand_host *host)
 258 {
 259         uint32_t tmp;
 260
 261         tmp = readl(NFC_V3_IPC);
 262         if (!(tmp & NFC_V3_IPC_INT))
 263                 return 0;
 264
 265         tmp &= ~NFC_V3_IPC_INT;
 266         writel(tmp, NFC_V3_IPC);
 267
 268         return 1;
 269 }
 270
 271 static int check_int_v1_v2(struct mxc_nand_host *host)
 272 {
 273         uint32_t tmp;
 274
 275         tmp = readw(NFC_V1_V2_CONFIG2);
 276         if (!(tmp & NFC_V1_V2_CONFIG2_INT))
 277                 return 0;
 278
 279         if (!cpu_is_mx21())
 280                 writew(tmp & ~NFC_V1_V2_CONFIG2_INT, NFC_V1_V2_CONFIG2);
 281
 282         return 1;
 283 }
 284
 285 /*
 286  * It has been observed that the i.MX21 cannot read the CONFIG2:INT bit
 287  * if interrupts are masked (CONFIG1:INT_MSK is set). To handle this, the
 288  * driver can enable/disable the irq line rather than simply masking the
 289  * interrupts.
 290  */
 291 static void irq_control_mx21(struct mxc_nand_host *host, int activate)
 292 {
 293         if (activate)
 294                 enable_irq(host->irq);
 295         else
 296                 disable_irq_nosync(host->irq);
 297 }
 298
 299 static void irq_control_v1_v2(struct mxc_nand_host *host, int activate)
 300 {
 301         uint16_t tmp;
 302
 303         tmp = readw(NFC_V1_V2_CONFIG1);
 304
 305         if (activate)
 306                 tmp &= ~NFC_V1_V2_CONFIG1_INT_MSK;
 307         else
 308                 tmp |= NFC_V1_V2_CONFIG1_INT_MSK;
 309
 310         writew(tmp, NFC_V1_V2_CONFIG1);
 311 }
 312
 313 static void irq_control_v3(struct mxc_nand_host *host, int activate)
 314 {
 315         uint32_t tmp;
 316
 317         tmp = readl(NFC_V3_CONFIG2);
 318
 319         if (activate)
 320                 tmp &= ~NFC_V3_CONFIG2_INT_MSK;
 321         else
 322                 tmp |= NFC_V3_CONFIG2_INT_MSK;
 323
 324         writel(tmp, NFC_V3_CONFIG2);
 325 }
 326
 327 /* This function polls the NANDFC to wait for the basic operation to
 328  * complete by checking the INT bit of config2 register.
 329  */
 330 static void wait_op_done(struct mxc_nand_host *host, int useirq)
 331 {
 332         int max_retries = 8000;
 333
 334         if (useirq) {
 335                 if (!host->check_int(host)) {
 336                         INIT_COMPLETION(host->op_completion);
 337                         host->irq_control(host, 1);
 338                         wait_for_completion(&host->op_completion);
 339                 }
 340         } else {
 341                 while (max_retries-- > 0) {
 342                         if (host->check_int(host))
 343                                 break;
 344
 345                         udelay(1);
 346                 }
 347                 if (max_retries < 0)
 348                         DEBUG(MTD_DEBUG_LEVEL0, "%s: INT not set\n",
 349                               __func__);
 350         }
 351 }
 352
 353 static void send_cmd_v3(struct mxc_nand_host *host, uint16_t cmd, int useirq)
 354 {
 355         /* fill command */
 356         writel(cmd, NFC_V3_FLASH_CMD);
 357
 358         /* send out command */
 359         writel(NFC_CMD, NFC_V3_LAUNCH);
 360
 361         /* Wait for operation to complete */
 362         wait_op_done(host, useirq);
 363 }
 364
 365 /* This function issues the specified command to the NAND device and
 366  * waits for completion. */
 367 static void send_cmd_v1_v2(struct mxc_nand_host *host, uint16_t cmd, int useirq)
 368 {
 369         DEBUG(MTD_DEBUG_LEVEL3, "send_cmd(host, 0x%x, %d)\n", cmd, useirq);
 370
 371         writew(cmd, NFC_V1_V2_FLASH_CMD);
 372         writew(NFC_CMD, NFC_V1_V2_CONFIG2);
 373
 374         if (cpu_is_mx21() && (cmd == NAND_CMD_RESET)) {
 375                 int max_retries = 100;
 376                 /* Reset completion is indicated by NFC_CONFIG2 */
 377                 /* being set to 0 */
 378                 while (max_retries-- > 0) {
 379                         if (readw(NFC_V1_V2_CONFIG2) == 0) {
 380                                 break;
 381                         }
 382                         udelay(1);
 383                 }
 384                 if (max_retries < 0)
 385                         DEBUG(MTD_DEBUG_LEVEL0, "%s: RESET failed\n",
 386                               __func__);
 387         } else {
 388                 /* Wait for operation to complete */
 389                 wait_op_done(host, useirq);
 390         }
 391 }
 392
 393 static void send_addr_v3(struct mxc_nand_host *host, uint16_t addr, int islast)
 394 {
 395         /* fill address */
 396         writel(addr, NFC_V3_FLASH_ADDR0);
 397
 398         /* send out address */
 399         writel(NFC_ADDR, NFC_V3_LAUNCH);
 400
 401         wait_op_done(host, 0);
 402 }
 403
 404 /* This function sends an address (or partial address) to the
 405  * NAND device. The address is used to select the source/destination for
 406  * a NAND command. */
 407 static void send_addr_v1_v2(struct mxc_nand_host *host, uint16_t addr, int islast)
 408 {
 409         DEBUG(MTD_DEBUG_LEVEL3, "send_addr(host, 0x%x %d)\n", addr, islast);
 410
 411         writew(addr, NFC_V1_V2_FLASH_ADDR);
 412         writew(NFC_ADDR, NFC_V1_V2_CONFIG2);
 413
 414         /* Wait for operation to complete */
 415         wait_op_done(host, islast);
 416 }
 417
 418 static void send_page_v3(struct mtd_info *mtd, unsigned int ops)
 419 {
 420         struct nand_chip *nand_chip = mtd->priv;
 421         struct mxc_nand_host *host = nand_chip->priv;
 422         uint32_t tmp;
 423
 424         tmp = readl(NFC_V3_CONFIG1);
 425         tmp &= ~(7 << 4);
 426         writel(tmp, NFC_V3_CONFIG1);
 427
 428         /* transfer data from NFC ram to nand */
 429         writel(ops, NFC_V3_LAUNCH);
 430
 431         wait_op_done(host, false);
 432 }
 433
 434 static void send_page_v1_v2(struct mtd_info *mtd, unsigned int ops)
 435 {
 436         struct nand_chip *nand_chip = mtd->priv;
 437         struct mxc_nand_host *host = nand_chip->priv;
 438         int bufs, i;
 439
 440         if (nfc_is_v1() && mtd->writesize > 512)
 441                 bufs = 4;
 442         else
 443                 bufs = 1;
 444
 445         for (i = 0; i < bufs; i++) {
 446
 447                 /* NANDFC buffer 0 is used for page read/write */
 448                 writew(i, NFC_V1_V2_BUF_ADDR);
 449
 450                 writew(ops, NFC_V1_V2_CONFIG2);
 451
 452                 /* Wait for operation to complete */
 453                 wait_op_done(host, true);
 454         }
 455 }
 456
 457 static void send_read_id_v3(struct mxc_nand_host *host)
 458 {
 459         /* Read ID into main buffer */
 460         writel(NFC_ID, NFC_V3_LAUNCH);
 461
 462         wait_op_done(host, true);
 463
 464         memcpy(host->data_buf, host->main_area0, 16);
 465 }
 466
 467 /* Request the NANDFC to perform a read of the NAND device ID. */
 468 static void send_read_id_v1_v2(struct mxc_nand_host *host)
 469 {
 470         struct nand_chip *this = &host->nand;
 471
 472         /* NANDFC buffer 0 is used for device ID output */
 473         writew(0x0, NFC_V1_V2_BUF_ADDR);
 474
 475         writew(NFC_ID, NFC_V1_V2_CONFIG2);
 476
 477         /* Wait for operation to complete */
 478         wait_op_done(host, true);
 479
 480         memcpy(host->data_buf, host->main_area0, 16);
 481
 482         if (this->options & NAND_BUSWIDTH_16) {
 483                 /* compress the ID info */
 484                 host->data_buf[1] = host->data_buf[2];
 485                 host->data_buf[2] = host->data_buf[4];
 486                 host->data_buf[3] = host->data_buf[6];
 487                 host->data_buf[4] = host->data_buf[8];
 488                 host->data_buf[5] = host->data_buf[10];
 489         }
 490 }
 491
 492 static uint16_t get_dev_status_v3(struct mxc_nand_host *host)
 493 {
 494         writew(NFC_STATUS, NFC_V3_LAUNCH);
 495         wait_op_done(host, true);
 496
 497         return readl(NFC_V3_CONFIG1) >> 16;
 498 }
 499
 500 /* This function requests the NANDFC to perform a read of the
 501  * NAND device status and returns the current status. */
 502 static uint16_t get_dev_status_v1_v2(struct mxc_nand_host *host)
 503 {
 504         void __iomem *main_buf = host->main_area0;
 505         uint32_t store;
 506         uint16_t ret;
 507
 508         writew(0x0, NFC_V1_V2_BUF_ADDR);
 509
 510         /*
 511          * The device status is stored in main_area0. To
 512          * prevent corruption of the buffer save the value
 513          * and restore it afterwards.
 514          */
 515         store = readl(main_buf);
 516
 517         writew(NFC_STATUS, NFC_V1_V2_CONFIG2);
 518         wait_op_done(host, true);
 519
 520         ret = readw(main_buf);
 521
 522         writel(store, main_buf);
 523
 524         return ret;
 525 }
 526
 527 /* This functions is used by upper layer to checks if device is ready */
 528 static int mxc_nand_dev_ready(struct mtd_info *mtd)
 529 {
 530         /*
 531          * NFC handles R/B internally. Therefore, this function
 532          * always returns status as ready.
 533          */
 534         return 1;
 535 }
 536
 537 static void mxc_nand_enable_hwecc(struct mtd_info *mtd, int mode)
 538 {
 539         /*
 540          * If HW ECC is enabled, we turn it on during init. There is
 541          * no need to enable again here.
 542          */
 543 }
 544
 545 static int mxc_nand_correct_data_v1(struct mtd_info *mtd, u_char *dat,
 546                                  u_char *read_ecc, u_char *calc_ecc)
 547 {
 548         struct nand_chip *nand_chip = mtd->priv;
 549         struct mxc_nand_host *host = nand_chip->priv;
 550
 551         /*
 552          * 1-Bit errors are automatically corrected in HW.  No need for
 553          * additional correction.  2-Bit errors cannot be corrected by
 554          * HW ECC, so we need to return failure
 555          */
 556         uint16_t ecc_status = readw(NFC_V1_V2_ECC_STATUS_RESULT);
 557
 558         if (((ecc_status & 0x3) == 2) || ((ecc_status >> 2) == 2)) {
 559                 DEBUG(MTD_DEBUG_LEVEL0,
 560                       "MXC_NAND: HWECC uncorrectable 2-bit ECC error\n");
 561                 return -1;
 562         }
 563
 564         return 0;
 565 }
 566
 567 static int mxc_nand_correct_data_v2_v3(struct mtd_info *mtd, u_char *dat,
 568                                  u_char *read_ecc, u_char *calc_ecc)
 569 {
 570         struct nand_chip *nand_chip = mtd->priv;
 571         struct mxc_nand_host *host = nand_chip->priv;
 572         u32 ecc_stat, err;
 573         int no_subpages = 1;
 574         int ret = 0;
 575         u8 ecc_bit_mask, err_limit;
 576
 577         ecc_bit_mask = (host->eccsize == 4) ? 0x7 : 0xf;
 578         err_limit = (host->eccsize == 4) ? 0x4 : 0x8;
 579
 580         no_subpages = mtd->writesize >> 9;
 581
 582         if (nfc_is_v21())
 583                 ecc_stat = readl(NFC_V1_V2_ECC_STATUS_RESULT);
 584         else
 585                 ecc_stat = readl(NFC_V3_ECC_STATUS_RESULT);
 586
 587         do {
 588                 err = ecc_stat & ecc_bit_mask;
 589                 if (err > err_limit) {
 590                         printk(KERN_WARNING "UnCorrectable RS-ECC Error\n");
 591                         return -1;
 592                 } else {
 593                         ret += err;
 594                 }
 595                 ecc_stat >>= 4;
 596         } while (--no_subpages);
 597
 598         mtd->ecc_stats.corrected += ret;
 599         pr_debug("%d Symbol Correctable RS-ECC Error\n", ret);
 600
 601         return ret;
 602 }
 603
 604 static int mxc_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
 605                                   u_char *ecc_code)
 606 {
 607         return 0;
 608 }
 609
 610 static u_char mxc_nand_read_byte(struct mtd_info *mtd)
 611 {
 612         struct nand_chip *nand_chip = mtd->priv;
 613         struct mxc_nand_host *host = nand_chip->priv;
 614         uint8_t ret;
 615
 616         /* Check for status request */
 617         if (host->status_request)
 618                 return host->get_dev_status(host) & 0xFF;
 619
 620         ret = *(uint8_t *)(host->data_buf + host->buf_start);
 621         host->buf_start++;
 622
 623         return ret;
 624 }
 625
 626 static uint16_t mxc_nand_read_word(struct mtd_info *mtd)
 627 {
 628         struct nand_chip *nand_chip = mtd->priv;
 629         struct mxc_nand_host *host = nand_chip->priv;
 630         uint16_t ret;
 631
 632         ret = *(uint16_t *)(host->data_buf + host->buf_start);
 633         host->buf_start += 2;
 634
 635         return ret;
 636 }
 637
 638 /* Write data of length len to buffer buf. The data to be
 639  * written on NAND Flash is first copied to RAMbuffer. After the Data Input
 640  * Operation by the NFC, the data is written to NAND Flash */
 641 static void mxc_nand_write_buf(struct mtd_info *mtd,
 642                                 const u_char *buf, int len)
 643 {
 644         struct nand_chip *nand_chip = mtd->priv;
 645         struct mxc_nand_host *host = nand_chip->priv;
 646         u16 col = host->buf_start;
 647         int n = mtd->oobsize + mtd->writesize - col;
 648
 649         n = min(n, len);
 650
 651         memcpy(host->data_buf + col, buf, n);
 652
 653         host->buf_start += n;
 654 }
 655
 656 /* Read the data buffer from the NAND Flash. To read the data from NAND
 657  * Flash first the data output cycle is initiated by the NFC, which copies
 658  * the data to RAMbuffer. This data of length len is then copied to buffer buf.
 659  */
 660 static void mxc_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 661 {
 662         struct nand_chip *nand_chip = mtd->priv;
 663         struct mxc_nand_host *host = nand_chip->priv;
 664         u16 col = host->buf_start;
 665         int n = mtd->oobsize + mtd->writesize - col;
 666
 667         n = min(n, len);
 668
 669         memcpy(buf, host->data_buf + col, n);
 670
 671         host->buf_start += n;
 672 }
 673
 674 /* Used by the upper layer to verify the data in NAND Flash
 675  * with the data in the buf. */
 676 static int mxc_nand_verify_buf(struct mtd_info *mtd,
 677                                 const u_char *buf, int len)
 678 {
 679         return -EFAULT;
 680 }
 681
 682 /* This function is used by upper layer for select and
 683  * deselect of the NAND chip */
 684 static void mxc_nand_select_chip(struct mtd_info *mtd, int chip)
 685 {
 686         struct nand_chip *nand_chip = mtd->priv;
 687         struct mxc_nand_host *host = nand_chip->priv;
 688
 689         switch (chip) {
 690         case -1:
 691                 /* Disable the NFC clock */
 692                 if (host->clk_act) {
 693                         clk_disable(host->clk);
 694                         host->clk_act = 0;
 695                 }
 696                 break;
 697         case 0:
 698                 /* Enable the NFC clock */
 699                 if (!host->clk_act) {
 700                         clk_enable(host->clk);
 701                         host->clk_act = 1;
 702                 }
 703                 break;
 704
 705         default:
 706                 break;
 707         }
 708 }
 709
 710 /*
 711  * Function to transfer data to/from spare area.
 712  */
 713 static void copy_spare(struct mtd_info *mtd, bool bfrom)
 714 {
 715         struct nand_chip *this = mtd->priv;
 716         struct mxc_nand_host *host = this->priv;
 717         u16 i, j;
 718         u16 n = mtd->writesize >> 9;
 719         u8 *d = host->data_buf + mtd->writesize;
 720         u8 *s = host->spare0;
 721         u16 t = host->spare_len;
 722
 723         j = (mtd->oobsize / n >> 1) << 1;
 724
 725         if (bfrom) {
 726                 for (i = 0; i < n - 1; i++)
 727                         memcpy(d + i * j, s + i * t, j);
 728
 729                 /* the last section */
 730                 memcpy(d + i * j, s + i * t, mtd->oobsize - i * j);
 731         } else {
 732                 for (i = 0; i < n - 1; i++)
 733                         memcpy(&s[i * t], &d[i * j], j);
 734
 735                 /* the last section */
 736                 memcpy(&s[i * t], &d[i * j], mtd->oobsize - i * j);
 737         }
 738 }
 739
 740 static void mxc_do_addr_cycle(struct mtd_info *mtd, int column, int page_addr)
 741 {
 742         struct nand_chip *nand_chip = mtd->priv;
 743         struct mxc_nand_host *host = nand_chip->priv;
 744
 745         /* Write out column address, if necessary */
 746         if (column != -1) {
 747                 /*
 748                  * MXC NANDFC can only perform full page+spare or
 749                  * spare-only read/write.  When the upper layers
 750                  * perform a read/write buf operation, the saved column
 751                   * address is used to index into the full page.
 752                  */
 753                 host->send_addr(host, 0, page_addr == -1);
 754                 if (mtd->writesize > 512)
 755                         /* another col addr cycle for 2k page */
 756                         host->send_addr(host, 0, false);
 757         }
 758
 759         /* Write out page address, if necessary */
 760         if (page_addr != -1) {
 761                 /* paddr_0 - p_addr_7 */
 762                 host->send_addr(host, (page_addr & 0xff), false);
 763
 764                 if (mtd->writesize > 512) {
 765                         if (mtd->size >= 0x10000000) {
 766                                 /* paddr_8 - paddr_15 */
 767                                 host->send_addr(host, (page_addr >> 8) & 0xff, false);
 768                                 host->send_addr(host, (page_addr >> 16) & 0xff, true);
 769                         } else
 770                                 /* paddr_8 - paddr_15 */
 771                                 host->send_addr(host, (page_addr >> 8) & 0xff, true);
 772                 } else {
 773                         /* One more address cycle for higher density devices */
 774                         if (mtd->size >= 0x4000000) {
 775                                 /* paddr_8 - paddr_15 */
 776                                 host->send_addr(host, (page_addr >> 8) & 0xff, false);
 777                                 host->send_addr(host, (page_addr >> 16) & 0xff, true);
 778                         } else
 779                                 /* paddr_8 - paddr_15 */
 780                                 host->send_addr(host, (page_addr >> 8) & 0xff, true);
 781                 }
 782         }
 783 }
 784
 785 /*
 786  * v2 and v3 type controllers can do 4bit or 8bit ecc depending
 787  * on how much oob the nand chip has. For 8bit ecc we need at least
 788  * 26 bytes of oob data per 512 byte block.
 789  */
 790 static int get_eccsize(struct mtd_info *mtd)
 791 {
 792         int oobbytes_per_512 = 0;
 793
 794         oobbytes_per_512 = mtd->oobsize * 512 / mtd->writesize;
 795
 796         if (oobbytes_per_512 < 26)
 797                 return 4;
 798         else
 799                 return 8;
 800 }
 801
 802 static void preset_v1_v2(struct mtd_info *mtd)
 803 {
 804         struct nand_chip *nand_chip = mtd->priv;
 805         struct mxc_nand_host *host = nand_chip->priv;
 806         uint16_t config1 = 0;
 807
 808         if (nand_chip->ecc.mode == NAND_ECC_HW)
 809                 config1 |= NFC_V1_V2_CONFIG1_ECC_EN;
 810
 811         if (nfc_is_v21())
 812                 config1 |= NFC_V2_CONFIG1_FP_INT;
 813
 814         if (!cpu_is_mx21())
 815                 config1 |= NFC_V1_V2_CONFIG1_INT_MSK;
 816
 817         if (nfc_is_v21() && mtd->writesize) {
 818                 uint16_t pages_per_block = mtd->erasesize / mtd->writesize;
 819
 820                 host->eccsize = get_eccsize(mtd);
 821                 if (host->eccsize == 4)
 822                         config1 |= NFC_V2_CONFIG1_ECC_MODE_4;
 823
 824                 config1 |= NFC_V2_CONFIG1_PPB(ffs(pages_per_block) - 6);
 825         } else {
 826                 host->eccsize = 1;
 827         }
 828
 829         writew(config1, NFC_V1_V2_CONFIG1);
 830         /* preset operation */
 831
 832         /* Unlock the internal RAM Buffer */
 833         writew(0x2, NFC_V1_V2_CONFIG);
 834
 835         /* Blocks to be unlocked */
 836         if (nfc_is_v21()) {
 837                 writew(0x0, NFC_V21_UNLOCKSTART_BLKADDR);
 838                 writew(0xffff, NFC_V21_UNLOCKEND_BLKADDR);
 839         } else if (nfc_is_v1()) {
 840                 writew(0x0, NFC_V1_UNLOCKSTART_BLKADDR);
 841                 writew(0x4000, NFC_V1_UNLOCKEND_BLKADDR);
 842         } else
 843                 BUG();
 844
 845         /* Unlock Block Command for given address range */
 846         writew(0x4, NFC_V1_V2_WRPROT);
 847 }
 848
 849 static void preset_v3(struct mtd_info *mtd)
 850 {
 851         struct nand_chip *chip = mtd->priv;
 852         struct mxc_nand_host *host = chip->priv;
 853         uint32_t config2, config3;
 854         int i, addr_phases;
 855
 856         writel(NFC_V3_CONFIG1_RBA(0), NFC_V3_CONFIG1);
 857         writel(NFC_V3_IPC_CREQ, NFC_V3_IPC);
 858
 859         /* Unlock the internal RAM Buffer */
 860         writel(NFC_V3_WRPROT_BLS_UNLOCK | NFC_V3_WRPROT_UNLOCK,
 861                         NFC_V3_WRPROT);
 862
 863         /* Blocks to be unlocked */
 864         for (i = 0; i < NAND_MAX_CHIPS; i++)
 865                 writel(0x0 |    (0xffff << 16),
 866                                 NFC_V3_WRPROT_UNLOCK_BLK_ADD0 + (i << 2));
 867
 868         writel(0, NFC_V3_IPC);
 869
 870         config2 = NFC_V3_CONFIG2_ONE_CYCLE |
 871                 NFC_V3_CONFIG2_2CMD_PHASES |
 872                 NFC_V3_CONFIG2_SPAS(mtd->oobsize >> 1) |
 873                 NFC_V3_CONFIG2_ST_CMD(0x70) |
 874                 NFC_V3_CONFIG2_INT_MSK |
 875                 NFC_V3_CONFIG2_NUM_ADDR_PHASE0;
 876
 877         if (chip->ecc.mode == NAND_ECC_HW)
 878                 config2 |= NFC_V3_CONFIG2_ECC_EN;
 879
 880         addr_phases = fls(chip->pagemask) >> 3;
 881
 882         if (mtd->writesize == 2048) {
 883                 config2 |= NFC_V3_CONFIG2_PS_2048;
 884                 config2 |= NFC_V3_CONFIG2_NUM_ADDR_PHASE1(addr_phases);
 885         } else if (mtd->writesize == 4096) {
 886                 config2 |= NFC_V3_CONFIG2_PS_4096;
 887                 config2 |= NFC_V3_CONFIG2_NUM_ADDR_PHASE1(addr_phases);
 888         } else {
 889                 config2 |= NFC_V3_CONFIG2_PS_512;
 890                 config2 |= NFC_V3_CONFIG2_NUM_ADDR_PHASE1(addr_phases - 1);
 891         }
 892
 893         if (mtd->writesize) {
 894                 config2 |= NFC_V3_CONFIG2_PPB(ffs(mtd->erasesize / mtd->writesize) - 6);
 895                 host->eccsize = get_eccsize(mtd);
 896                 if (host->eccsize == 8)
 897                         config2 |= NFC_V3_CONFIG2_ECC_MODE_8;
 898         }
 899
 900         writel(config2, NFC_V3_CONFIG2);
 901
 902         config3 = NFC_V3_CONFIG3_NUM_OF_DEVICES(0) |
 903                         NFC_V3_CONFIG3_NO_SDMA |
 904                         NFC_V3_CONFIG3_RBB_MODE |
 905                         NFC_V3_CONFIG3_SBB(6) | /* Reset default */
 906                         NFC_V3_CONFIG3_ADD_OP(0);
 907
 908         if (!(chip->options & NAND_BUSWIDTH_16))
 909                 config3 |= NFC_V3_CONFIG3_FW8;
 910
 911         writel(config3, NFC_V3_CONFIG3);
 912
 913         writel(0, NFC_V3_DELAY_LINE);
 914 }
 915
 916 /* Used by the upper layer to write command to NAND Flash for
 917  * different operations to be carried out on NAND Flash */
 918 static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
 919                                 int column, int page_addr)
 920 {
 921         struct nand_chip *nand_chip = mtd->priv;
 922         struct mxc_nand_host *host = nand_chip->priv;
 923
 924         DEBUG(MTD_DEBUG_LEVEL3,
 925               "mxc_nand_command (cmd = 0x%x, col = 0x%x, page = 0x%x)\n",
 926               command, column, page_addr);
 927
 928         /* Reset command state information */
 929         host->status_request = false;
 930
 931         /* Command pre-processing step */
 932         switch (command) {
 933         case NAND_CMD_RESET:
 934                 host->preset(mtd);
 935                 host->send_cmd(host, command, false);
 936                 break;
 937
 938         case NAND_CMD_STATUS:
 939                 host->buf_start = 0;
 940                 host->status_request = true;
 941
 942                 host->send_cmd(host, command, true);
 943                 mxc_do_addr_cycle(mtd, column, page_addr);
 944                 break;
 945
 946         case NAND_CMD_READ0:
 947         case NAND_CMD_READOOB:
 948                 if (command == NAND_CMD_READ0)
 949                         host->buf_start = column;
 950                 else
 951                         host->buf_start = column + mtd->writesize;
 952
 953                 command = NAND_CMD_READ0; /* only READ0 is valid */
 954
 955                 host->send_cmd(host, command, false);
 956                 mxc_do_addr_cycle(mtd, column, page_addr);
 957
 958                 if (mtd->writesize > 512)
 959                         host->send_cmd(host, NAND_CMD_READSTART, true);
 960
 961                 host->send_page(mtd, NFC_OUTPUT);
 962
 963                 memcpy(host->data_buf, host->main_area0, mtd->writesize);
 964                 copy_spare(mtd, true);
 965                 break;
 966
 967         case NAND_CMD_SEQIN:
 968                 if (column >= mtd->writesize)
 969                         /* call ourself to read a page */
 970                         mxc_nand_command(mtd, NAND_CMD_READ0, 0, page_addr);
 971
 972                 host->buf_start = column;
 973
 974                 host->send_cmd(host, command, false);
 975                 mxc_do_addr_cycle(mtd, column, page_addr);
 976                 break;
 977
 978         case NAND_CMD_PAGEPROG:
 979                 memcpy(host->main_area0, host->data_buf, mtd->writesize);
 980                 copy_spare(mtd, false);
 981                 host->send_page(mtd, NFC_INPUT);
 982                 host->send_cmd(host, command, true);
 983                 mxc_do_addr_cycle(mtd, column, page_addr);
 984                 break;
 985
 986         case NAND_CMD_READID:
 987                 host->send_cmd(host, command, true);
 988                 mxc_do_addr_cycle(mtd, column, page_addr);
 989                 host->send_read_id(host);
 990                 host->buf_start = column;
 991                 break;
 992
 993         case NAND_CMD_ERASE1:
 994         case NAND_CMD_ERASE2:
 995                 host->send_cmd(host, command, false);
 996                 mxc_do_addr_cycle(mtd, column, page_addr);
 997
 998                 break;
 999         }
1000 }
1001
1002 /*
1003  * The generic flash bbt decriptors overlap with our ecc
1004  * hardware, so define some i.MX specific ones.
1005  */
1006 static uint8_t bbt_pattern[] = { 'B', 'b', 't', '0' };
1007 static uint8_t mirror_pattern[] = { '1', 't', 'b', 'B' };
1008
1009 static struct nand_bbt_descr bbt_main_descr = {
1010         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1011             | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1012         .offs = 0,
1013         .len = 4,
1014         .veroffs = 4,
1015         .maxblocks = 4,
1016         .pattern = bbt_pattern,
1017 };
1018
1019 static struct nand_bbt_descr bbt_mirror_descr = {
1020         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1021             | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1022         .offs = 0,
1023         .len = 4,
1024         .veroffs = 4,
1025         .maxblocks = 4,
1026         .pattern = mirror_pattern,
1027 };
1028
1029 static int __init mxcnd_probe(struct platform_device *pdev)
1030 {
1031         struct nand_chip *this;
1032         struct mtd_info *mtd;
1033         struct mxc_nand_platform_data *pdata = pdev->dev.platform_data;
1034         struct mxc_nand_host *host;
1035         struct resource *res;
1036         int err = 0, __maybe_unused nr_parts = 0;
1037         struct nand_ecclayout *oob_smallpage, *oob_largepage;
1038
1039         /* Allocate memory for MTD device structure and private data */
1040         host = kzalloc(sizeof(struct mxc_nand_host) + NAND_MAX_PAGESIZE +
1041                         NAND_MAX_OOBSIZE, GFP_KERNEL);
1042         if (!host)
1043                 return -ENOMEM;
1044
1045         host->data_buf = (uint8_t *)(host + 1);
1046
1047         host->dev = &pdev->dev;
1048         /* structures must be linked */
1049         this = &host->nand;
1050         mtd = &host->mtd;
1051         mtd->priv = this;
1052         mtd->owner = THIS_MODULE;
1053         mtd->dev.parent = &pdev->dev;
1054         mtd->name = DRIVER_NAME;
1055
1056         /* 50 us command delay time */
1057         this->chip_delay = 5;
1058
1059         this->priv = host;
1060         this->dev_ready = mxc_nand_dev_ready;
1061         this->cmdfunc = mxc_nand_command;
1062         this->select_chip = mxc_nand_select_chip;
1063         this->read_byte = mxc_nand_read_byte;
1064         this->read_word = mxc_nand_read_word;
1065         this->write_buf = mxc_nand_write_buf;
1066         this->read_buf = mxc_nand_read_buf;
1067         this->verify_buf = mxc_nand_verify_buf;
1068
1069         host->clk = clk_get(&pdev->dev, "nfc");
1070         if (IS_ERR(host->clk)) {
1071                 err = PTR_ERR(host->clk);
1072                 goto eclk;
1073         }
1074
1075         clk_enable(host->clk);
1076         host->clk_act = 1;
1077
1078         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1079         if (!res) {
1080                 err = -ENODEV;
1081                 goto eres;
1082         }
1083
1084         host->base = ioremap(res->start, resource_size(res));
1085         if (!host->base) {
1086                 err = -ENOMEM;
1087                 goto eres;
1088         }
1089
1090         host->main_area0 = host->base;
1091
1092         if (nfc_is_v1() || nfc_is_v21()) {
1093                 host->preset = preset_v1_v2;
1094                 host->send_cmd = send_cmd_v1_v2;
1095                 host->send_addr = send_addr_v1_v2;
1096                 host->send_page = send_page_v1_v2;
1097                 host->send_read_id = send_read_id_v1_v2;
1098                 host->get_dev_status = get_dev_status_v1_v2;
1099                 host->check_int = check_int_v1_v2;
1100                 if (cpu_is_mx21())
1101                         host->irq_control = irq_control_mx21;
1102                 else
1103                         host->irq_control = irq_control_v1_v2;
1104         }
1105
1106         if (nfc_is_v21()) {
1107                 host->regs = host->base + 0x1e00;
1108                 host->spare0 = host->base + 0x1000;
1109                 host->spare_len = 64;
1110                 oob_smallpage = &nandv2_hw_eccoob_smallpage;
1111                 oob_largepage = &nandv2_hw_eccoob_largepage;
1112                 this->ecc.bytes = 9;
1113         } else if (nfc_is_v1()) {
1114                 host->regs = host->base + 0xe00;
1115                 host->spare0 = host->base + 0x800;
1116                 host->spare_len = 16;
1117                 oob_smallpage = &nandv1_hw_eccoob_smallpage;
1118                 oob_largepage = &nandv1_hw_eccoob_largepage;
1119                 this->ecc.bytes = 3;
1120                 host->eccsize = 1;
1121         } else if (nfc_is_v3_2()) {
1122                 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1123                 if (!res) {
1124                         err = -ENODEV;
1125                         goto eirq;
1126                 }
1127                 host->regs_ip = ioremap(res->start, resource_size(res));
1128                 if (!host->regs_ip) {
1129                         err = -ENOMEM;
1130                         goto eirq;
1131                 }
1132                 host->regs_axi = host->base + 0x1e00;
1133                 host->spare0 = host->base + 0x1000;
1134                 host->spare_len = 64;
1135                 host->preset = preset_v3;
1136                 host->send_cmd = send_cmd_v3;
1137                 host->send_addr = send_addr_v3;
1138                 host->send_page = send_page_v3;
1139                 host->send_read_id = send_read_id_v3;
1140                 host->check_int = check_int_v3;
1141                 host->get_dev_status = get_dev_status_v3;
1142                 host->irq_control = irq_control_v3;
1143                 oob_smallpage = &nandv2_hw_eccoob_smallpage;
1144                 oob_largepage = &nandv2_hw_eccoob_largepage;
1145         } else
1146                 BUG();
1147
1148         this->ecc.size = 512;
1149         this->ecc.layout = oob_smallpage;
1150
1151         if (pdata->hw_ecc) {
1152                 this->ecc.calculate = mxc_nand_calculate_ecc;
1153                 this->ecc.hwctl = mxc_nand_enable_hwecc;
1154                 if (nfc_is_v1())
1155                         this->ecc.correct = mxc_nand_correct_data_v1;
1156                 else
1157                         this->ecc.correct = mxc_nand_correct_data_v2_v3;
1158                 this->ecc.mode = NAND_ECC_HW;
1159         } else {
1160                 this->ecc.mode = NAND_ECC_SOFT;
1161         }
1162
1163         /* NAND bus width determines access funtions used by upper layer */
1164         if (pdata->width == 2)
1165                 this->options |= NAND_BUSWIDTH_16;
1166
1167         if (pdata->flash_bbt) {
1168                 this->bbt_td = &bbt_main_descr;
1169                 this->bbt_md = &bbt_mirror_descr;
1170                 /* update flash based bbt */
1171                 this->options |= NAND_USE_FLASH_BBT;
1172         }
1173
1174         init_completion(&host->op_completion);
1175
1176         host->irq = platform_get_irq(pdev, 0);
1177
1178         /*
1179          * mask the interrupt. For i.MX21 explicitely call
1180          * irq_control_v1_v2 to use the mask bit. We can't call
1181          * disable_irq_nosync() for an interrupt we do not own yet.
1182          */
1183         if (cpu_is_mx21())
1184                 irq_control_v1_v2(host, 0);
1185         else
1186                 host->irq_control(host, 0);
1187
1188         err = request_irq(host->irq, mxc_nfc_irq, IRQF_DISABLED, DRIVER_NAME, host);
1189         if (err)
1190                 goto eirq;
1191
1192         host->irq_control(host, 0);
1193
1194         /*
1195          * Now that the interrupt is disabled make sure the interrupt
1196          * mask bit is cleared on i.MX21. Otherwise we can't read
1197          * the interrupt status bit on this machine.
1198          */
1199         if (cpu_is_mx21())
1200                 irq_control_v1_v2(host, 1);
1201
1202         /* first scan to find the device and get the page size */
1203         if (nand_scan_ident(mtd, 1, NULL)) {
1204                 err = -ENXIO;
1205                 goto escan;
1206         }
1207
1208         /* Call preset again, with correct writesize this time */
1209         host->preset(mtd);
1210
1211         if (mtd->writesize == 2048)
1212                 this->ecc.layout = oob_largepage;
1213         if (nfc_is_v21() && mtd->writesize == 4096)
1214                 this->ecc.layout = &nandv2_hw_eccoob_4k;
1215
1216         /* second phase scan */
1217         if (nand_scan_tail(mtd)) {
1218                 err = -ENXIO;
1219                 goto escan;
1220         }
1221
1222         /* Register the partitions */
1223 #ifdef CONFIG_MTD_PARTITIONS
1224         nr_parts =
1225             parse_mtd_partitions(mtd, part_probes, &host->parts, 0);
1226         if (nr_parts > 0)
1227                 add_mtd_partitions(mtd, host->parts, nr_parts);
1228         else if (pdata->parts)
1229                 add_mtd_partitions(mtd, pdata->parts, pdata->nr_parts);
1230         else
1231 #endif
1232         {
1233                 pr_info("Registering %s as whole device\n", mtd->name);
1234                 add_mtd_device(mtd);
1235         }
1236
1237         platform_set_drvdata(pdev, host);
1238
1239         return 0;
1240
1241 escan:
1242         free_irq(host->irq, host);
1243 eirq:
1244         if (host->regs_ip)
1245                 iounmap(host->regs_ip);
1246         iounmap(host->base);
1247 eres:
1248         clk_put(host->clk);
1249 eclk:
1250         kfree(host);
1251
1252         return err;
1253 }
1254
1255 static int __devexit mxcnd_remove(struct platform_device *pdev)
1256 {
1257         struct mxc_nand_host *host = platform_get_drvdata(pdev);
1258
1259         clk_put(host->clk);
1260
1261         platform_set_drvdata(pdev, NULL);
1262
1263         nand_release(&host->mtd);
1264         free_irq(host->irq, host);
1265         if (host->regs_ip)
1266                 iounmap(host->regs_ip);
1267         iounmap(host->base);
1268         kfree(host);
1269
1270         return 0;
1271 }
1272
1273 static struct platform_driver mxcnd_driver = {
1274         .driver = {
1275                    .name = DRIVER_NAME,
1276         },
1277         .remove = __devexit_p(mxcnd_remove),
1278 };
1279
1280 static int __init mxc_nd_init(void)
1281 {
1282         return platform_driver_probe(&mxcnd_driver, mxcnd_probe);
1283 }
1284
1285 static void __exit mxc_nd_cleanup(void)
1286 {
1287         /* Unregister the device structure */
1288         platform_driver_unregister(&mxcnd_driver);
1289 }
1290
1291 module_init(mxc_nd_init);
1292 module_exit(mxc_nd_cleanup);
1293
1294 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
1295 MODULE_DESCRIPTION("MXC NAND MTD driver");
1296 MODULE_LICENSE("GPL");