1/* 2 * Freescale Integrated Flash Controller NAND driver 3 * 4 * Copyright 2011-2012 Freescale Semiconductor, Inc 5 * 6 * Author: Dipen Dudhat <Dipen.Dudhat@freescale.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23#include <linux/module.h> 24#include <linux/types.h> 25#include <linux/kernel.h> 26#include <linux/of_address.h> 27#include <linux/slab.h> 28#include <linux/mtd/mtd.h> 29#include <linux/mtd/nand.h> 30#include <linux/mtd/partitions.h> 31#include <linux/mtd/nand_ecc.h> 32#include <linux/fsl_ifc.h> 33 34#define FSL_IFC_V1_1_0 0x01010000 35#define ERR_BYTE 0xFF /* Value returned for read 36 bytes when read failed */ 37#define IFC_TIMEOUT_MSECS 500 /* Maximum number of mSecs to wait 38 for IFC NAND Machine */ 39 40struct fsl_ifc_ctrl; 41 42/* mtd information per set */ 43struct fsl_ifc_mtd { 44 struct mtd_info mtd; 45 struct nand_chip chip; 46 struct fsl_ifc_ctrl *ctrl; 47 48 struct device *dev; 49 int bank; /* Chip select bank number */ 50 unsigned int bufnum_mask; /* bufnum = page & bufnum_mask */ 51 u8 __iomem *vbase; /* Chip select base virtual address */ 52}; 53 54/* overview of the fsl ifc controller */ 55struct fsl_ifc_nand_ctrl { 56 struct nand_hw_control controller; 57 struct fsl_ifc_mtd *chips[FSL_IFC_BANK_COUNT]; 58 59 void __iomem *addr; /* Address of assigned IFC buffer */ 60 unsigned int page; /* Last page written to / read from */ 61 unsigned int read_bytes;/* Number of bytes read during command */ 62 unsigned int column; /* Saved column from SEQIN */ 63 unsigned int index; /* Pointer to next byte to 'read' */ 64 unsigned int oob; /* Non zero if operating on OOB data */ 65 unsigned int eccread; /* Non zero for a full-page ECC read */ 66 unsigned int counter; /* counter for the initializations */ 67 unsigned int max_bitflips; /* Saved during READ0 cmd */ 68}; 69 70static struct fsl_ifc_nand_ctrl *ifc_nand_ctrl; 71 72/* 512-byte page with 4-bit ECC, 8-bit */ 73static struct nand_ecclayout oob_512_8bit_ecc4 = { 74 .eccbytes = 8, 75 .eccpos = {8, 9, 10, 11, 12, 13, 14, 15}, 76 .oobfree = { {0, 5}, {6, 2} }, 77}; 78 79/* 512-byte page with 4-bit ECC, 16-bit */ 80static struct nand_ecclayout oob_512_16bit_ecc4 = { 81 .eccbytes = 8, 82 .eccpos = {8, 9, 10, 11, 12, 13, 14, 15}, 83 .oobfree = { {2, 6}, }, 84}; 85 86/* 2048-byte page size with 4-bit ECC */ 87static struct nand_ecclayout oob_2048_ecc4 = { 88 .eccbytes = 32, 89 .eccpos = { 90 8, 9, 10, 11, 12, 13, 14, 15, 91 16, 17, 18, 19, 20, 21, 22, 23, 92 24, 25, 26, 27, 28, 29, 30, 31, 93 32, 33, 34, 35, 36, 37, 38, 39, 94 }, 95 .oobfree = { {2, 6}, {40, 24} }, 96}; 97 98/* 4096-byte page size with 4-bit ECC */ 99static struct nand_ecclayout oob_4096_ecc4 = { 100 .eccbytes = 64, 101 .eccpos = { 102 8, 9, 10, 11, 12, 13, 14, 15, 103 16, 17, 18, 19, 20, 21, 22, 23, 104 24, 25, 26, 27, 28, 29, 30, 31, 105 32, 33, 34, 35, 36, 37, 38, 39, 106 40, 41, 42, 43, 44, 45, 46, 47, 107 48, 49, 50, 51, 52, 53, 54, 55, 108 56, 57, 58, 59, 60, 61, 62, 63, 109 64, 65, 66, 67, 68, 69, 70, 71, 110 }, 111 .oobfree = { {2, 6}, {72, 56} }, 112}; 113 114/* 4096-byte page size with 8-bit ECC -- requires 218-byte OOB */ 115static struct nand_ecclayout oob_4096_ecc8 = { 116 .eccbytes = 128, 117 .eccpos = { 118 8, 9, 10, 11, 12, 13, 14, 15, 119 16, 17, 18, 19, 20, 21, 22, 23, 120 24, 25, 26, 27, 28, 29, 30, 31, 121 32, 33, 34, 35, 36, 37, 38, 39, 122 40, 41, 42, 43, 44, 45, 46, 47, 123 48, 49, 50, 51, 52, 53, 54, 55, 124 56, 57, 58, 59, 60, 61, 62, 63, 125 64, 65, 66, 67, 68, 69, 70, 71, 126 72, 73, 74, 75, 76, 77, 78, 79, 127 80, 81, 82, 83, 84, 85, 86, 87, 128 88, 89, 90, 91, 92, 93, 94, 95, 129 96, 97, 98, 99, 100, 101, 102, 103, 130 104, 105, 106, 107, 108, 109, 110, 111, 131 112, 113, 114, 115, 116, 117, 118, 119, 132 120, 121, 122, 123, 124, 125, 126, 127, 133 128, 129, 130, 131, 132, 133, 134, 135, 134 }, 135 .oobfree = { {2, 6}, {136, 82} }, 136}; 137 138/* 8192-byte page size with 4-bit ECC */ 139static struct nand_ecclayout oob_8192_ecc4 = { 140 .eccbytes = 128, 141 .eccpos = { 142 8, 9, 10, 11, 12, 13, 14, 15, 143 16, 17, 18, 19, 20, 21, 22, 23, 144 24, 25, 26, 27, 28, 29, 30, 31, 145 32, 33, 34, 35, 36, 37, 38, 39, 146 40, 41, 42, 43, 44, 45, 46, 47, 147 48, 49, 50, 51, 52, 53, 54, 55, 148 56, 57, 58, 59, 60, 61, 62, 63, 149 64, 65, 66, 67, 68, 69, 70, 71, 150 72, 73, 74, 75, 76, 77, 78, 79, 151 80, 81, 82, 83, 84, 85, 86, 87, 152 88, 89, 90, 91, 92, 93, 94, 95, 153 96, 97, 98, 99, 100, 101, 102, 103, 154 104, 105, 106, 107, 108, 109, 110, 111, 155 112, 113, 114, 115, 116, 117, 118, 119, 156 120, 121, 122, 123, 124, 125, 126, 127, 157 128, 129, 130, 131, 132, 133, 134, 135, 158 }, 159 .oobfree = { {2, 6}, {136, 208} }, 160}; 161 162/* 8192-byte page size with 8-bit ECC -- requires 218-byte OOB */ 163static struct nand_ecclayout oob_8192_ecc8 = { 164 .eccbytes = 256, 165 .eccpos = { 166 8, 9, 10, 11, 12, 13, 14, 15, 167 16, 17, 18, 19, 20, 21, 22, 23, 168 24, 25, 26, 27, 28, 29, 30, 31, 169 32, 33, 34, 35, 36, 37, 38, 39, 170 40, 41, 42, 43, 44, 45, 46, 47, 171 48, 49, 50, 51, 52, 53, 54, 55, 172 56, 57, 58, 59, 60, 61, 62, 63, 173 64, 65, 66, 67, 68, 69, 70, 71, 174 72, 73, 74, 75, 76, 77, 78, 79, 175 80, 81, 82, 83, 84, 85, 86, 87, 176 88, 89, 90, 91, 92, 93, 94, 95, 177 96, 97, 98, 99, 100, 101, 102, 103, 178 104, 105, 106, 107, 108, 109, 110, 111, 179 112, 113, 114, 115, 116, 117, 118, 119, 180 120, 121, 122, 123, 124, 125, 126, 127, 181 128, 129, 130, 131, 132, 133, 134, 135, 182 136, 137, 138, 139, 140, 141, 142, 143, 183 144, 145, 146, 147, 148, 149, 150, 151, 184 152, 153, 154, 155, 156, 157, 158, 159, 185 160, 161, 162, 163, 164, 165, 166, 167, 186 168, 169, 170, 171, 172, 173, 174, 175, 187 176, 177, 178, 179, 180, 181, 182, 183, 188 184, 185, 186, 187, 188, 189, 190, 191, 189 192, 193, 194, 195, 196, 197, 198, 199, 190 200, 201, 202, 203, 204, 205, 206, 207, 191 208, 209, 210, 211, 212, 213, 214, 215, 192 216, 217, 218, 219, 220, 221, 222, 223, 193 224, 225, 226, 227, 228, 229, 230, 231, 194 232, 233, 234, 235, 236, 237, 238, 239, 195 240, 241, 242, 243, 244, 245, 246, 247, 196 248, 249, 250, 251, 252, 253, 254, 255, 197 256, 257, 258, 259, 260, 261, 262, 263, 198 }, 199 .oobfree = { {2, 6}, {264, 80} }, 200}; 201 202/* 203 * Generic flash bbt descriptors 204 */ 205static u8 bbt_pattern[] = {'B', 'b', 't', '0' }; 206static u8 mirror_pattern[] = {'1', 't', 'b', 'B' }; 207 208static struct nand_bbt_descr bbt_main_descr = { 209 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE | 210 NAND_BBT_2BIT | NAND_BBT_VERSION, 211 .offs = 2, /* 0 on 8-bit small page */ 212 .len = 4, 213 .veroffs = 6, 214 .maxblocks = 4, 215 .pattern = bbt_pattern, 216}; 217 218static struct nand_bbt_descr bbt_mirror_descr = { 219 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE | 220 NAND_BBT_2BIT | NAND_BBT_VERSION, 221 .offs = 2, /* 0 on 8-bit small page */ 222 .len = 4, 223 .veroffs = 6, 224 .maxblocks = 4, 225 .pattern = mirror_pattern, 226}; 227 228/* 229 * Set up the IFC hardware block and page address fields, and the ifc nand 230 * structure addr field to point to the correct IFC buffer in memory 231 */ 232static void set_addr(struct mtd_info *mtd, int column, int page_addr, int oob) 233{ 234 struct nand_chip *chip = mtd->priv; 235 struct fsl_ifc_mtd *priv = chip->priv; 236 struct fsl_ifc_ctrl *ctrl = priv->ctrl; 237 struct fsl_ifc_regs __iomem *ifc = ctrl->regs; 238 int buf_num; 239 240 ifc_nand_ctrl->page = page_addr; 241 /* Program ROW0/COL0 */ 242 iowrite32be(page_addr, &ifc->ifc_nand.row0); 243 iowrite32be((oob ? IFC_NAND_COL_MS : 0) | column, &ifc->ifc_nand.col0); 244 245 buf_num = page_addr & priv->bufnum_mask; 246 247 ifc_nand_ctrl->addr = priv->vbase + buf_num * (mtd->writesize * 2); 248 ifc_nand_ctrl->index = column; 249 250 /* for OOB data point to the second half of the buffer */ 251 if (oob) 252 ifc_nand_ctrl->index += mtd->writesize; 253} 254 255static int is_blank(struct mtd_info *mtd, unsigned int bufnum) 256{ 257 struct nand_chip *chip = mtd->priv; 258 struct fsl_ifc_mtd *priv = chip->priv; 259 u8 __iomem *addr = priv->vbase + bufnum * (mtd->writesize * 2); 260 u32 __iomem *mainarea = (u32 __iomem *)addr; 261 u8 __iomem *oob = addr + mtd->writesize; 262 int i; 263 264 for (i = 0; i < mtd->writesize / 4; i++) { 265 if (__raw_readl(&mainarea[i]) != 0xffffffff) 266 return 0; 267 } 268 269 for (i = 0; i < chip->ecc.layout->eccbytes; i++) { 270 int pos = chip->ecc.layout->eccpos[i]; 271 272 if (__raw_readb(&oob[pos]) != 0xff) 273 return 0; 274 } 275 276 return 1; 277} 278 279/* returns nonzero if entire page is blank */ 280static int check_read_ecc(struct mtd_info *mtd, struct fsl_ifc_ctrl *ctrl, 281 u32 *eccstat, unsigned int bufnum) 282{ 283 u32 reg = eccstat[bufnum / 4]; 284 int errors; 285 286 errors = (reg >> ((3 - bufnum % 4) * 8)) & 15; 287 288 return errors; 289} 290 291/* 292 * execute IFC NAND command and wait for it to complete 293 */ 294static void fsl_ifc_run_command(struct mtd_info *mtd) 295{ 296 struct nand_chip *chip = mtd->priv; 297 struct fsl_ifc_mtd *priv = chip->priv; 298 struct fsl_ifc_ctrl *ctrl = priv->ctrl; 299 struct fsl_ifc_nand_ctrl *nctrl = ifc_nand_ctrl; 300 struct fsl_ifc_regs __iomem *ifc = ctrl->regs; 301 u32 eccstat[4]; 302 int i; 303 304 /* set the chip select for NAND Transaction */ 305 iowrite32be(priv->bank << IFC_NAND_CSEL_SHIFT, 306 &ifc->ifc_nand.nand_csel); 307 308 dev_vdbg(priv->dev, 309 "%s: fir0=%08x fcr0=%08x\n", 310 __func__, 311 ioread32be(&ifc->ifc_nand.nand_fir0), 312 ioread32be(&ifc->ifc_nand.nand_fcr0)); 313 314 ctrl->nand_stat = 0; 315 316 /* start read/write seq */ 317 iowrite32be(IFC_NAND_SEQ_STRT_FIR_STRT, &ifc->ifc_nand.nandseq_strt); 318 319 /* wait for command complete flag or timeout */ 320 wait_event_timeout(ctrl->nand_wait, ctrl->nand_stat, 321 IFC_TIMEOUT_MSECS * HZ/1000); 322 323 /* ctrl->nand_stat will be updated from IRQ context */ 324 if (!ctrl->nand_stat) 325 dev_err(priv->dev, "Controller is not responding\n"); 326 if (ctrl->nand_stat & IFC_NAND_EVTER_STAT_FTOER) 327 dev_err(priv->dev, "NAND Flash Timeout Error\n"); 328 if (ctrl->nand_stat & IFC_NAND_EVTER_STAT_WPER) 329 dev_err(priv->dev, "NAND Flash Write Protect Error\n"); 330 331 nctrl->max_bitflips = 0; 332 333 if (nctrl->eccread) { 334 int errors; 335 int bufnum = nctrl->page & priv->bufnum_mask; 336 int sector = bufnum * chip->ecc.steps; 337 int sector_end = sector + chip->ecc.steps - 1; 338 339 for (i = sector / 4; i <= sector_end / 4; i++) 340 eccstat[i] = ioread32be(&ifc->ifc_nand.nand_eccstat[i]); 341 342 for (i = sector; i <= sector_end; i++) { 343 errors = check_read_ecc(mtd, ctrl, eccstat, i); 344 345 if (errors == 15) { 346 /* 347 * Uncorrectable error. 348 * OK only if the whole page is blank. 349 * 350 * We disable ECCER reporting due to... 351 * erratum IFC-A002770 -- so report it now if we 352 * see an uncorrectable error in ECCSTAT. 353 */ 354 if (!is_blank(mtd, bufnum)) 355 ctrl->nand_stat |= 356 IFC_NAND_EVTER_STAT_ECCER; 357 break; 358 } 359 360 mtd->ecc_stats.corrected += errors; 361 nctrl->max_bitflips = max_t(unsigned int, 362 nctrl->max_bitflips, 363 errors); 364 } 365 366 nctrl->eccread = 0; 367 } 368} 369 370static void fsl_ifc_do_read(struct nand_chip *chip, 371 int oob, 372 struct mtd_info *mtd) 373{ 374 struct fsl_ifc_mtd *priv = chip->priv; 375 struct fsl_ifc_ctrl *ctrl = priv->ctrl; 376 struct fsl_ifc_regs __iomem *ifc = ctrl->regs; 377 378 /* Program FIR/IFC_NAND_FCR0 for Small/Large page */ 379 if (mtd->writesize > 512) { 380 iowrite32be((IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 381 (IFC_FIR_OP_CA0 << IFC_NAND_FIR0_OP1_SHIFT) | 382 (IFC_FIR_OP_RA0 << IFC_NAND_FIR0_OP2_SHIFT) | 383 (IFC_FIR_OP_CMD1 << IFC_NAND_FIR0_OP3_SHIFT) | 384 (IFC_FIR_OP_RBCD << IFC_NAND_FIR0_OP4_SHIFT), 385 &ifc->ifc_nand.nand_fir0); 386 iowrite32be(0x0, &ifc->ifc_nand.nand_fir1); 387 388 iowrite32be((NAND_CMD_READ0 << IFC_NAND_FCR0_CMD0_SHIFT) | 389 (NAND_CMD_READSTART << IFC_NAND_FCR0_CMD1_SHIFT), 390 &ifc->ifc_nand.nand_fcr0); 391 } else { 392 iowrite32be((IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 393 (IFC_FIR_OP_CA0 << IFC_NAND_FIR0_OP1_SHIFT) | 394 (IFC_FIR_OP_RA0 << IFC_NAND_FIR0_OP2_SHIFT) | 395 (IFC_FIR_OP_RBCD << IFC_NAND_FIR0_OP3_SHIFT), 396 &ifc->ifc_nand.nand_fir0); 397 iowrite32be(0x0, &ifc->ifc_nand.nand_fir1); 398 399 if (oob) 400 iowrite32be(NAND_CMD_READOOB << 401 IFC_NAND_FCR0_CMD0_SHIFT, 402 &ifc->ifc_nand.nand_fcr0); 403 else 404 iowrite32be(NAND_CMD_READ0 << 405 IFC_NAND_FCR0_CMD0_SHIFT, 406 &ifc->ifc_nand.nand_fcr0); 407 } 408} 409 410/* cmdfunc send commands to the IFC NAND Machine */ 411static void fsl_ifc_cmdfunc(struct mtd_info *mtd, unsigned int command, 412 int column, int page_addr) { 413 struct nand_chip *chip = mtd->priv; 414 struct fsl_ifc_mtd *priv = chip->priv; 415 struct fsl_ifc_ctrl *ctrl = priv->ctrl; 416 struct fsl_ifc_regs __iomem *ifc = ctrl->regs; 417 418 /* clear the read buffer */ 419 ifc_nand_ctrl->read_bytes = 0; 420 if (command != NAND_CMD_PAGEPROG) 421 ifc_nand_ctrl->index = 0; 422 423 switch (command) { 424 /* READ0 read the entire buffer to use hardware ECC. */ 425 case NAND_CMD_READ0: 426 iowrite32be(0, &ifc->ifc_nand.nand_fbcr); 427 set_addr(mtd, 0, page_addr, 0); 428 429 ifc_nand_ctrl->read_bytes = mtd->writesize + mtd->oobsize; 430 ifc_nand_ctrl->index += column; 431 432 if (chip->ecc.mode == NAND_ECC_HW) 433 ifc_nand_ctrl->eccread = 1; 434 435 fsl_ifc_do_read(chip, 0, mtd); 436 fsl_ifc_run_command(mtd); 437 return; 438 439 /* READOOB reads only the OOB because no ECC is performed. */ 440 case NAND_CMD_READOOB: 441 iowrite32be(mtd->oobsize - column, &ifc->ifc_nand.nand_fbcr); 442 set_addr(mtd, column, page_addr, 1); 443 444 ifc_nand_ctrl->read_bytes = mtd->writesize + mtd->oobsize; 445 446 fsl_ifc_do_read(chip, 1, mtd); 447 fsl_ifc_run_command(mtd); 448 449 return; 450 451 case NAND_CMD_READID: 452 case NAND_CMD_PARAM: { 453 int timing = IFC_FIR_OP_RB; 454 if (command == NAND_CMD_PARAM) 455 timing = IFC_FIR_OP_RBCD; 456 457 iowrite32be((IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 458 (IFC_FIR_OP_UA << IFC_NAND_FIR0_OP1_SHIFT) | 459 (timing << IFC_NAND_FIR0_OP2_SHIFT), 460 &ifc->ifc_nand.nand_fir0); 461 iowrite32be(command << IFC_NAND_FCR0_CMD0_SHIFT, 462 &ifc->ifc_nand.nand_fcr0); 463 iowrite32be(column, &ifc->ifc_nand.row3); 464 465 /* 466 * although currently it's 8 bytes for READID, we always read 467 * the maximum 256 bytes(for PARAM) 468 */ 469 iowrite32be(256, &ifc->ifc_nand.nand_fbcr); 470 ifc_nand_ctrl->read_bytes = 256; 471 472 set_addr(mtd, 0, 0, 0); 473 fsl_ifc_run_command(mtd); 474 return; 475 } 476 477 /* ERASE1 stores the block and page address */ 478 case NAND_CMD_ERASE1: 479 set_addr(mtd, 0, page_addr, 0); 480 return; 481 482 /* ERASE2 uses the block and page address from ERASE1 */ 483 case NAND_CMD_ERASE2: 484 iowrite32be((IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 485 (IFC_FIR_OP_RA0 << IFC_NAND_FIR0_OP1_SHIFT) | 486 (IFC_FIR_OP_CMD1 << IFC_NAND_FIR0_OP2_SHIFT), 487 &ifc->ifc_nand.nand_fir0); 488 489 iowrite32be((NAND_CMD_ERASE1 << IFC_NAND_FCR0_CMD0_SHIFT) | 490 (NAND_CMD_ERASE2 << IFC_NAND_FCR0_CMD1_SHIFT), 491 &ifc->ifc_nand.nand_fcr0); 492 493 iowrite32be(0, &ifc->ifc_nand.nand_fbcr); 494 ifc_nand_ctrl->read_bytes = 0; 495 fsl_ifc_run_command(mtd); 496 return; 497 498 /* SEQIN sets up the addr buffer and all registers except the length */ 499 case NAND_CMD_SEQIN: { 500 u32 nand_fcr0; 501 ifc_nand_ctrl->column = column; 502 ifc_nand_ctrl->oob = 0; 503 504 if (mtd->writesize > 512) { 505 nand_fcr0 = 506 (NAND_CMD_SEQIN << IFC_NAND_FCR0_CMD0_SHIFT) | 507 (NAND_CMD_STATUS << IFC_NAND_FCR0_CMD1_SHIFT) | 508 (NAND_CMD_PAGEPROG << IFC_NAND_FCR0_CMD2_SHIFT); 509 510 iowrite32be( 511 (IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 512 (IFC_FIR_OP_CA0 << IFC_NAND_FIR0_OP1_SHIFT) | 513 (IFC_FIR_OP_RA0 << IFC_NAND_FIR0_OP2_SHIFT) | 514 (IFC_FIR_OP_WBCD << IFC_NAND_FIR0_OP3_SHIFT) | 515 (IFC_FIR_OP_CMD2 << IFC_NAND_FIR0_OP4_SHIFT), 516 &ifc->ifc_nand.nand_fir0); 517 iowrite32be( 518 (IFC_FIR_OP_CW1 << IFC_NAND_FIR1_OP5_SHIFT) | 519 (IFC_FIR_OP_RDSTAT << 520 IFC_NAND_FIR1_OP6_SHIFT) | 521 (IFC_FIR_OP_NOP << IFC_NAND_FIR1_OP7_SHIFT), 522 &ifc->ifc_nand.nand_fir1); 523 } else { 524 nand_fcr0 = ((NAND_CMD_PAGEPROG << 525 IFC_NAND_FCR0_CMD1_SHIFT) | 526 (NAND_CMD_SEQIN << 527 IFC_NAND_FCR0_CMD2_SHIFT) | 528 (NAND_CMD_STATUS << 529 IFC_NAND_FCR0_CMD3_SHIFT)); 530 531 iowrite32be( 532 (IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 533 (IFC_FIR_OP_CMD2 << IFC_NAND_FIR0_OP1_SHIFT) | 534 (IFC_FIR_OP_CA0 << IFC_NAND_FIR0_OP2_SHIFT) | 535 (IFC_FIR_OP_RA0 << IFC_NAND_FIR0_OP3_SHIFT) | 536 (IFC_FIR_OP_WBCD << IFC_NAND_FIR0_OP4_SHIFT), 537 &ifc->ifc_nand.nand_fir0); 538 iowrite32be( 539 (IFC_FIR_OP_CMD1 << IFC_NAND_FIR1_OP5_SHIFT) | 540 (IFC_FIR_OP_CW3 << IFC_NAND_FIR1_OP6_SHIFT) | 541 (IFC_FIR_OP_RDSTAT << 542 IFC_NAND_FIR1_OP7_SHIFT) | 543 (IFC_FIR_OP_NOP << IFC_NAND_FIR1_OP8_SHIFT), 544 &ifc->ifc_nand.nand_fir1); 545 546 if (column >= mtd->writesize) 547 nand_fcr0 |= 548 NAND_CMD_READOOB << IFC_NAND_FCR0_CMD0_SHIFT; 549 else 550 nand_fcr0 |= 551 NAND_CMD_READ0 << IFC_NAND_FCR0_CMD0_SHIFT; 552 } 553 554 if (column >= mtd->writesize) { 555 /* OOB area --> READOOB */ 556 column -= mtd->writesize; 557 ifc_nand_ctrl->oob = 1; 558 } 559 iowrite32be(nand_fcr0, &ifc->ifc_nand.nand_fcr0); 560 set_addr(mtd, column, page_addr, ifc_nand_ctrl->oob); 561 return; 562 } 563 564 /* PAGEPROG reuses all of the setup from SEQIN and adds the length */ 565 case NAND_CMD_PAGEPROG: { 566 if (ifc_nand_ctrl->oob) { 567 iowrite32be(ifc_nand_ctrl->index - 568 ifc_nand_ctrl->column, 569 &ifc->ifc_nand.nand_fbcr); 570 } else { 571 iowrite32be(0, &ifc->ifc_nand.nand_fbcr); 572 } 573 574 fsl_ifc_run_command(mtd); 575 return; 576 } 577 578 case NAND_CMD_STATUS: 579 iowrite32be((IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 580 (IFC_FIR_OP_RB << IFC_NAND_FIR0_OP1_SHIFT), 581 &ifc->ifc_nand.nand_fir0); 582 iowrite32be(NAND_CMD_STATUS << IFC_NAND_FCR0_CMD0_SHIFT, 583 &ifc->ifc_nand.nand_fcr0); 584 iowrite32be(1, &ifc->ifc_nand.nand_fbcr); 585 set_addr(mtd, 0, 0, 0); 586 ifc_nand_ctrl->read_bytes = 1; 587 588 fsl_ifc_run_command(mtd); 589 590 /* 591 * The chip always seems to report that it is 592 * write-protected, even when it is not. 593 */ 594 if (chip->options & NAND_BUSWIDTH_16) 595 setbits16(ifc_nand_ctrl->addr, NAND_STATUS_WP); 596 else 597 setbits8(ifc_nand_ctrl->addr, NAND_STATUS_WP); 598 return; 599 600 case NAND_CMD_RESET: 601 iowrite32be(IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT, 602 &ifc->ifc_nand.nand_fir0); 603 iowrite32be(NAND_CMD_RESET << IFC_NAND_FCR0_CMD0_SHIFT, 604 &ifc->ifc_nand.nand_fcr0); 605 fsl_ifc_run_command(mtd); 606 return; 607 608 default: 609 dev_err(priv->dev, "%s: error, unsupported command 0x%x.\n", 610 __func__, command); 611 } 612} 613 614static void fsl_ifc_select_chip(struct mtd_info *mtd, int chip) 615{ 616 /* The hardware does not seem to support multiple 617 * chips per bank. 618 */ 619} 620 621/* 622 * Write buf to the IFC NAND Controller Data Buffer 623 */ 624static void fsl_ifc_write_buf(struct mtd_info *mtd, const u8 *buf, int len) 625{ 626 struct nand_chip *chip = mtd->priv; 627 struct fsl_ifc_mtd *priv = chip->priv; 628 unsigned int bufsize = mtd->writesize + mtd->oobsize; 629 630 if (len <= 0) { 631 dev_err(priv->dev, "%s: len %d bytes", __func__, len); 632 return; 633 } 634 635 if ((unsigned int)len > bufsize - ifc_nand_ctrl->index) { 636 dev_err(priv->dev, 637 "%s: beyond end of buffer (%d requested, %u available)\n", 638 __func__, len, bufsize - ifc_nand_ctrl->index); 639 len = bufsize - ifc_nand_ctrl->index; 640 } 641 642 memcpy_toio(ifc_nand_ctrl->addr + ifc_nand_ctrl->index, buf, len); 643 ifc_nand_ctrl->index += len; 644} 645 646/* 647 * Read a byte from either the IFC hardware buffer 648 * read function for 8-bit buswidth 649 */ 650static uint8_t fsl_ifc_read_byte(struct mtd_info *mtd) 651{ 652 struct nand_chip *chip = mtd->priv; 653 struct fsl_ifc_mtd *priv = chip->priv; 654 unsigned int offset; 655 656 /* 657 * If there are still bytes in the IFC buffer, then use the 658 * next byte. 659 */ 660 if (ifc_nand_ctrl->index < ifc_nand_ctrl->read_bytes) { 661 offset = ifc_nand_ctrl->index++; 662 return in_8(ifc_nand_ctrl->addr + offset); 663 } 664 665 dev_err(priv->dev, "%s: beyond end of buffer\n", __func__); 666 return ERR_BYTE; 667} 668 669/* 670 * Read two bytes from the IFC hardware buffer 671 * read function for 16-bit buswith 672 */ 673static uint8_t fsl_ifc_read_byte16(struct mtd_info *mtd) 674{ 675 struct nand_chip *chip = mtd->priv; 676 struct fsl_ifc_mtd *priv = chip->priv; 677 uint16_t data; 678 679 /* 680 * If there are still bytes in the IFC buffer, then use the 681 * next byte. 682 */ 683 if (ifc_nand_ctrl->index < ifc_nand_ctrl->read_bytes) { 684 data = in_be16(ifc_nand_ctrl->addr + ifc_nand_ctrl->index); 685 ifc_nand_ctrl->index += 2; 686 return (uint8_t) data; 687 } 688 689 dev_err(priv->dev, "%s: beyond end of buffer\n", __func__); 690 return ERR_BYTE; 691} 692 693/* 694 * Read from the IFC Controller Data Buffer 695 */ 696static void fsl_ifc_read_buf(struct mtd_info *mtd, u8 *buf, int len) 697{ 698 struct nand_chip *chip = mtd->priv; 699 struct fsl_ifc_mtd *priv = chip->priv; 700 int avail; 701 702 if (len < 0) { 703 dev_err(priv->dev, "%s: len %d bytes", __func__, len); 704 return; 705 } 706 707 avail = min((unsigned int)len, 708 ifc_nand_ctrl->read_bytes - ifc_nand_ctrl->index); 709 memcpy_fromio(buf, ifc_nand_ctrl->addr + ifc_nand_ctrl->index, avail); 710 ifc_nand_ctrl->index += avail; 711 712 if (len > avail) 713 dev_err(priv->dev, 714 "%s: beyond end of buffer (%d requested, %d available)\n", 715 __func__, len, avail); 716} 717 718/* 719 * This function is called after Program and Erase Operations to 720 * check for success or failure. 721 */ 722static int fsl_ifc_wait(struct mtd_info *mtd, struct nand_chip *chip) 723{ 724 struct fsl_ifc_mtd *priv = chip->priv; 725 struct fsl_ifc_ctrl *ctrl = priv->ctrl; 726 struct fsl_ifc_regs __iomem *ifc = ctrl->regs; 727 u32 nand_fsr; 728 729 /* Use READ_STATUS command, but wait for the device to be ready */ 730 iowrite32be((IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 731 (IFC_FIR_OP_RDSTAT << IFC_NAND_FIR0_OP1_SHIFT), 732 &ifc->ifc_nand.nand_fir0); 733 iowrite32be(NAND_CMD_STATUS << IFC_NAND_FCR0_CMD0_SHIFT, 734 &ifc->ifc_nand.nand_fcr0); 735 iowrite32be(1, &ifc->ifc_nand.nand_fbcr); 736 set_addr(mtd, 0, 0, 0); 737 ifc_nand_ctrl->read_bytes = 1; 738 739 fsl_ifc_run_command(mtd); 740 741 nand_fsr = ioread32be(&ifc->ifc_nand.nand_fsr); 742 743 /* 744 * The chip always seems to report that it is 745 * write-protected, even when it is not. 746 */ 747 return nand_fsr | NAND_STATUS_WP; 748} 749 750static int fsl_ifc_read_page(struct mtd_info *mtd, struct nand_chip *chip, 751 uint8_t *buf, int oob_required, int page) 752{ 753 struct fsl_ifc_mtd *priv = chip->priv; 754 struct fsl_ifc_ctrl *ctrl = priv->ctrl; 755 struct fsl_ifc_nand_ctrl *nctrl = ifc_nand_ctrl; 756 757 fsl_ifc_read_buf(mtd, buf, mtd->writesize); 758 if (oob_required) 759 fsl_ifc_read_buf(mtd, chip->oob_poi, mtd->oobsize); 760 761 if (ctrl->nand_stat & IFC_NAND_EVTER_STAT_ECCER) 762 dev_err(priv->dev, "NAND Flash ECC Uncorrectable Error\n"); 763 764 if (ctrl->nand_stat != IFC_NAND_EVTER_STAT_OPC) 765 mtd->ecc_stats.failed++; 766 767 return nctrl->max_bitflips; 768} 769 770/* ECC will be calculated automatically, and errors will be detected in 771 * waitfunc. 772 */ 773static int fsl_ifc_write_page(struct mtd_info *mtd, struct nand_chip *chip, 774 const uint8_t *buf, int oob_required) 775{ 776 fsl_ifc_write_buf(mtd, buf, mtd->writesize); 777 fsl_ifc_write_buf(mtd, chip->oob_poi, mtd->oobsize); 778 779 return 0; 780} 781 782static int fsl_ifc_chip_init_tail(struct mtd_info *mtd) 783{ 784 struct nand_chip *chip = mtd->priv; 785 struct fsl_ifc_mtd *priv = chip->priv; 786 787 dev_dbg(priv->dev, "%s: nand->numchips = %d\n", __func__, 788 chip->numchips); 789 dev_dbg(priv->dev, "%s: nand->chipsize = %lld\n", __func__, 790 chip->chipsize); 791 dev_dbg(priv->dev, "%s: nand->pagemask = %8x\n", __func__, 792 chip->pagemask); 793 dev_dbg(priv->dev, "%s: nand->chip_delay = %d\n", __func__, 794 chip->chip_delay); 795 dev_dbg(priv->dev, "%s: nand->badblockpos = %d\n", __func__, 796 chip->badblockpos); 797 dev_dbg(priv->dev, "%s: nand->chip_shift = %d\n", __func__, 798 chip->chip_shift); 799 dev_dbg(priv->dev, "%s: nand->page_shift = %d\n", __func__, 800 chip->page_shift); 801 dev_dbg(priv->dev, "%s: nand->phys_erase_shift = %d\n", __func__, 802 chip->phys_erase_shift); 803 dev_dbg(priv->dev, "%s: nand->ecc.mode = %d\n", __func__, 804 chip->ecc.mode); 805 dev_dbg(priv->dev, "%s: nand->ecc.steps = %d\n", __func__, 806 chip->ecc.steps); 807 dev_dbg(priv->dev, "%s: nand->ecc.bytes = %d\n", __func__, 808 chip->ecc.bytes); 809 dev_dbg(priv->dev, "%s: nand->ecc.total = %d\n", __func__, 810 chip->ecc.total); 811 dev_dbg(priv->dev, "%s: nand->ecc.layout = %p\n", __func__, 812 chip->ecc.layout); 813 dev_dbg(priv->dev, "%s: mtd->flags = %08x\n", __func__, mtd->flags); 814 dev_dbg(priv->dev, "%s: mtd->size = %lld\n", __func__, mtd->size); 815 dev_dbg(priv->dev, "%s: mtd->erasesize = %d\n", __func__, 816 mtd->erasesize); 817 dev_dbg(priv->dev, "%s: mtd->writesize = %d\n", __func__, 818 mtd->writesize); 819 dev_dbg(priv->dev, "%s: mtd->oobsize = %d\n", __func__, 820 mtd->oobsize); 821 822 return 0; 823} 824 825static void fsl_ifc_sram_init(struct fsl_ifc_mtd *priv) 826{ 827 struct fsl_ifc_ctrl *ctrl = priv->ctrl; 828 struct fsl_ifc_regs __iomem *ifc = ctrl->regs; 829 uint32_t csor = 0, csor_8k = 0, csor_ext = 0; 830 uint32_t cs = priv->bank; 831 832 /* Save CSOR and CSOR_ext */ 833 csor = ioread32be(&ifc->csor_cs[cs].csor); 834 csor_ext = ioread32be(&ifc->csor_cs[cs].csor_ext); 835 836 /* chage PageSize 8K and SpareSize 1K*/ 837 csor_8k = (csor & ~(CSOR_NAND_PGS_MASK)) | 0x0018C000; 838 iowrite32be(csor_8k, &ifc->csor_cs[cs].csor); 839 iowrite32be(0x0000400, &ifc->csor_cs[cs].csor_ext); 840 841 /* READID */ 842 iowrite32be((IFC_FIR_OP_CW0 << IFC_NAND_FIR0_OP0_SHIFT) | 843 (IFC_FIR_OP_UA << IFC_NAND_FIR0_OP1_SHIFT) | 844 (IFC_FIR_OP_RB << IFC_NAND_FIR0_OP2_SHIFT), 845 &ifc->ifc_nand.nand_fir0); 846 iowrite32be(NAND_CMD_READID << IFC_NAND_FCR0_CMD0_SHIFT, 847 &ifc->ifc_nand.nand_fcr0); 848 iowrite32be(0x0, &ifc->ifc_nand.row3); 849 850 iowrite32be(0x0, &ifc->ifc_nand.nand_fbcr); 851 852 /* Program ROW0/COL0 */ 853 iowrite32be(0x0, &ifc->ifc_nand.row0); 854 iowrite32be(0x0, &ifc->ifc_nand.col0); 855 856 /* set the chip select for NAND Transaction */ 857 iowrite32be(cs << IFC_NAND_CSEL_SHIFT, &ifc->ifc_nand.nand_csel); 858 859 /* start read seq */ 860 iowrite32be(IFC_NAND_SEQ_STRT_FIR_STRT, &ifc->ifc_nand.nandseq_strt); 861 862 /* wait for command complete flag or timeout */ 863 wait_event_timeout(ctrl->nand_wait, ctrl->nand_stat, 864 IFC_TIMEOUT_MSECS * HZ/1000); 865 866 if (ctrl->nand_stat != IFC_NAND_EVTER_STAT_OPC) 867 printk(KERN_ERR "fsl-ifc: Failed to Initialise SRAM\n"); 868 869 /* Restore CSOR and CSOR_ext */ 870 iowrite32be(csor, &ifc->csor_cs[cs].csor); 871 iowrite32be(csor_ext, &ifc->csor_cs[cs].csor_ext); 872} 873 874static int fsl_ifc_chip_init(struct fsl_ifc_mtd *priv) 875{ 876 struct fsl_ifc_ctrl *ctrl = priv->ctrl; 877 struct fsl_ifc_regs __iomem *ifc = ctrl->regs; 878 struct nand_chip *chip = &priv->chip; 879 struct nand_ecclayout *layout; 880 u32 csor, ver; 881 882 /* Fill in fsl_ifc_mtd structure */ 883 priv->mtd.priv = chip; 884 priv->mtd.owner = THIS_MODULE; 885 886 /* fill in nand_chip structure */ 887 /* set up function call table */ 888 if ((ioread32be(&ifc->cspr_cs[priv->bank].cspr)) & CSPR_PORT_SIZE_16) 889 chip->read_byte = fsl_ifc_read_byte16; 890 else 891 chip->read_byte = fsl_ifc_read_byte; 892 893 chip->write_buf = fsl_ifc_write_buf; 894 chip->read_buf = fsl_ifc_read_buf; 895 chip->select_chip = fsl_ifc_select_chip; 896 chip->cmdfunc = fsl_ifc_cmdfunc; 897 chip->waitfunc = fsl_ifc_wait; 898 899 chip->bbt_td = &bbt_main_descr; 900 chip->bbt_md = &bbt_mirror_descr; 901 902 iowrite32be(0x0, &ifc->ifc_nand.ncfgr); 903 904 /* set up nand options */ 905 chip->bbt_options = NAND_BBT_USE_FLASH; 906 chip->options = NAND_NO_SUBPAGE_WRITE; 907 908 if (ioread32be(&ifc->cspr_cs[priv->bank].cspr) & CSPR_PORT_SIZE_16) { 909 chip->read_byte = fsl_ifc_read_byte16; 910 chip->options |= NAND_BUSWIDTH_16; 911 } else { 912 chip->read_byte = fsl_ifc_read_byte; 913 } 914 915 chip->controller = &ifc_nand_ctrl->controller; 916 chip->priv = priv; 917 918 chip->ecc.read_page = fsl_ifc_read_page; 919 chip->ecc.write_page = fsl_ifc_write_page; 920 921 csor = ioread32be(&ifc->csor_cs[priv->bank].csor); 922 923 /* Hardware generates ECC per 512 Bytes */ 924 chip->ecc.size = 512; 925 chip->ecc.bytes = 8; 926 chip->ecc.strength = 4; 927 928 switch (csor & CSOR_NAND_PGS_MASK) { 929 case CSOR_NAND_PGS_512: 930 if (chip->options & NAND_BUSWIDTH_16) { 931 layout = &oob_512_16bit_ecc4; 932 } else { 933 layout = &oob_512_8bit_ecc4; 934 935 /* Avoid conflict with bad block marker */ 936 bbt_main_descr.offs = 0; 937 bbt_mirror_descr.offs = 0; 938 } 939 940 priv->bufnum_mask = 15; 941 break; 942 943 case CSOR_NAND_PGS_2K: 944 layout = &oob_2048_ecc4; 945 priv->bufnum_mask = 3; 946 break; 947 948 case CSOR_NAND_PGS_4K: 949 if ((csor & CSOR_NAND_ECC_MODE_MASK) == 950 CSOR_NAND_ECC_MODE_4) { 951 layout = &oob_4096_ecc4; 952 } else { 953 layout = &oob_4096_ecc8; 954 chip->ecc.bytes = 16; 955 chip->ecc.strength = 8; 956 } 957 958 priv->bufnum_mask = 1; 959 break; 960 961 case CSOR_NAND_PGS_8K: 962 if ((csor & CSOR_NAND_ECC_MODE_MASK) == 963 CSOR_NAND_ECC_MODE_4) { 964 layout = &oob_8192_ecc4; 965 } else { 966 layout = &oob_8192_ecc8; 967 chip->ecc.bytes = 16; 968 chip->ecc.strength = 8; 969 } 970 971 priv->bufnum_mask = 0; 972 break; 973 974 default: 975 dev_err(priv->dev, "bad csor %#x: bad page size\n", csor); 976 return -ENODEV; 977 } 978 979 /* Must also set CSOR_NAND_ECC_ENC_EN if DEC_EN set */ 980 if (csor & CSOR_NAND_ECC_DEC_EN) { 981 chip->ecc.mode = NAND_ECC_HW; 982 chip->ecc.layout = layout; 983 } else { 984 chip->ecc.mode = NAND_ECC_SOFT; 985 } 986 987 ver = ioread32be(&ifc->ifc_rev); 988 if (ver == FSL_IFC_V1_1_0) 989 fsl_ifc_sram_init(priv); 990 991 return 0; 992} 993 994static int fsl_ifc_chip_remove(struct fsl_ifc_mtd *priv) 995{ 996 nand_release(&priv->mtd); 997 998 kfree(priv->mtd.name); 999 1000 if (priv->vbase) 1001 iounmap(priv->vbase); 1002 1003 ifc_nand_ctrl->chips[priv->bank] = NULL; 1004 1005 return 0; 1006} 1007 1008static int match_bank(struct fsl_ifc_regs __iomem *ifc, int bank, 1009 phys_addr_t addr) 1010{ 1011 u32 cspr = ioread32be(&ifc->cspr_cs[bank].cspr); 1012 1013 if (!(cspr & CSPR_V)) 1014 return 0; 1015 if ((cspr & CSPR_MSEL) != CSPR_MSEL_NAND) 1016 return 0; 1017 1018 return (cspr & CSPR_BA) == convert_ifc_address(addr); 1019} 1020 1021static DEFINE_MUTEX(fsl_ifc_nand_mutex); 1022 1023static int fsl_ifc_nand_probe(struct platform_device *dev) 1024{ 1025 struct fsl_ifc_regs __iomem *ifc; 1026 struct fsl_ifc_mtd *priv; 1027 struct resource res; 1028 static const char *part_probe_types[] 1029 = { "cmdlinepart", "RedBoot", "ofpart", NULL }; 1030 int ret; 1031 int bank; 1032 struct device_node *node = dev->dev.of_node; 1033 struct mtd_part_parser_data ppdata; 1034 1035 ppdata.of_node = dev->dev.of_node; 1036 if (!fsl_ifc_ctrl_dev || !fsl_ifc_ctrl_dev->regs) 1037 return -ENODEV; 1038 ifc = fsl_ifc_ctrl_dev->regs; 1039 1040 /* get, allocate and map the memory resource */ 1041 ret = of_address_to_resource(node, 0, &res); 1042 if (ret) { 1043 dev_err(&dev->dev, "%s: failed to get resource\n", __func__); 1044 return ret; 1045 } 1046 1047 /* find which chip select it is connected to */ 1048 for (bank = 0; bank < FSL_IFC_BANK_COUNT; bank++) { 1049 if (match_bank(ifc, bank, res.start)) 1050 break; 1051 } 1052 1053 if (bank >= FSL_IFC_BANK_COUNT) { 1054 dev_err(&dev->dev, "%s: address did not match any chip selects\n", 1055 __func__); 1056 return -ENODEV; 1057 } 1058 1059 priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL); 1060 if (!priv) 1061 return -ENOMEM; 1062 1063 mutex_lock(&fsl_ifc_nand_mutex); 1064 if (!fsl_ifc_ctrl_dev->nand) { 1065 ifc_nand_ctrl = kzalloc(sizeof(*ifc_nand_ctrl), GFP_KERNEL); 1066 if (!ifc_nand_ctrl) { 1067 mutex_unlock(&fsl_ifc_nand_mutex); 1068 return -ENOMEM; 1069 } 1070 1071 ifc_nand_ctrl->read_bytes = 0; 1072 ifc_nand_ctrl->index = 0; 1073 ifc_nand_ctrl->addr = NULL; 1074 fsl_ifc_ctrl_dev->nand = ifc_nand_ctrl; 1075 1076 spin_lock_init(&ifc_nand_ctrl->controller.lock); 1077 init_waitqueue_head(&ifc_nand_ctrl->controller.wq); 1078 } else { 1079 ifc_nand_ctrl = fsl_ifc_ctrl_dev->nand; 1080 } 1081 mutex_unlock(&fsl_ifc_nand_mutex); 1082 1083 ifc_nand_ctrl->chips[bank] = priv; 1084 priv->bank = bank; 1085 priv->ctrl = fsl_ifc_ctrl_dev; 1086 priv->dev = &dev->dev; 1087 1088 priv->vbase = ioremap(res.start, resource_size(&res)); 1089 if (!priv->vbase) { 1090 dev_err(priv->dev, "%s: failed to map chip region\n", __func__); 1091 ret = -ENOMEM; 1092 goto err; 1093 } 1094 1095 dev_set_drvdata(priv->dev, priv); 1096 1097 iowrite32be(IFC_NAND_EVTER_EN_OPC_EN | 1098 IFC_NAND_EVTER_EN_FTOER_EN | 1099 IFC_NAND_EVTER_EN_WPER_EN, 1100 &ifc->ifc_nand.nand_evter_en); 1101 1102 /* enable NAND Machine Interrupts */ 1103 iowrite32be(IFC_NAND_EVTER_INTR_OPCIR_EN | 1104 IFC_NAND_EVTER_INTR_FTOERIR_EN | 1105 IFC_NAND_EVTER_INTR_WPERIR_EN, 1106 &ifc->ifc_nand.nand_evter_intr_en); 1107 priv->mtd.name = kasprintf(GFP_KERNEL, "%llx.flash", (u64)res.start); 1108 if (!priv->mtd.name) { 1109 ret = -ENOMEM; 1110 goto err; 1111 } 1112 1113 ret = fsl_ifc_chip_init(priv); 1114 if (ret) 1115 goto err; 1116 1117 ret = nand_scan_ident(&priv->mtd, 1, NULL); 1118 if (ret) 1119 goto err; 1120 1121 ret = fsl_ifc_chip_init_tail(&priv->mtd); 1122 if (ret) 1123 goto err; 1124 1125 ret = nand_scan_tail(&priv->mtd); 1126 if (ret) 1127 goto err; 1128 1129 /* First look for RedBoot table or partitions on the command 1130 * line, these take precedence over device tree information */ 1131 mtd_device_parse_register(&priv->mtd, part_probe_types, &ppdata, 1132 NULL, 0); 1133 1134 dev_info(priv->dev, "IFC NAND device at 0x%llx, bank %d\n", 1135 (unsigned long long)res.start, priv->bank); 1136 return 0; 1137 1138err: 1139 fsl_ifc_chip_remove(priv); 1140 return ret; 1141} 1142 1143static int fsl_ifc_nand_remove(struct platform_device *dev) 1144{ 1145 struct fsl_ifc_mtd *priv = dev_get_drvdata(&dev->dev); 1146 1147 fsl_ifc_chip_remove(priv); 1148 1149 mutex_lock(&fsl_ifc_nand_mutex); 1150 ifc_nand_ctrl->counter--; 1151 if (!ifc_nand_ctrl->counter) { 1152 fsl_ifc_ctrl_dev->nand = NULL; 1153 kfree(ifc_nand_ctrl); 1154 } 1155 mutex_unlock(&fsl_ifc_nand_mutex); 1156 1157 return 0; 1158} 1159 1160static const struct of_device_id fsl_ifc_nand_match[] = { 1161 { 1162 .compatible = "fsl,ifc-nand", 1163 }, 1164 {} 1165}; 1166 1167static struct platform_driver fsl_ifc_nand_driver = { 1168 .driver = { 1169 .name = "fsl,ifc-nand", 1170 .owner = THIS_MODULE, 1171 .of_match_table = fsl_ifc_nand_match, 1172 }, 1173 .probe = fsl_ifc_nand_probe, 1174 .remove = fsl_ifc_nand_remove, 1175}; 1176 1177module_platform_driver(fsl_ifc_nand_driver); 1178 1179MODULE_LICENSE("GPL"); 1180MODULE_AUTHOR("Freescale"); 1181MODULE_DESCRIPTION("Freescale Integrated Flash Controller MTD NAND driver"); 1182