1/* 2 * drivers/mtd/nand/fsmc_nand.c 3 * 4 * ST Microelectronics 5 * Flexible Static Memory Controller (FSMC) 6 * Driver for NAND portions 7 * 8 * Copyright �� 2010 ST Microelectronics 9 * Vipin Kumar <vipin.kumar@st.com> 10 * Ashish Priyadarshi 11 * 12 * Based on drivers/mtd/nand/nomadik_nand.c 13 * 14 * This file is licensed under the terms of the GNU General Public 15 * License version 2. This program is licensed "as is" without any 16 * warranty of any kind, whether express or implied. 17 */ 18 19#include <linux/clk.h> 20#include <linux/completion.h> 21#include <linux/dmaengine.h> 22#include <linux/dma-direction.h> 23#include <linux/dma-mapping.h> 24#include <linux/err.h> 25#include <linux/init.h> 26#include <linux/module.h> 27#include <linux/resource.h> 28#include <linux/sched.h> 29#include <linux/types.h> 30#include <linux/mtd/mtd.h> 31#include <linux/mtd/nand.h> 32#include <linux/mtd/nand_ecc.h> 33#include <linux/platform_device.h> 34#include <linux/of.h> 35#include <linux/mtd/partitions.h> 36#include <linux/io.h> 37#include <linux/slab.h> 38#include <linux/mtd/fsmc.h> 39#include <linux/amba/bus.h> 40#include <mtd/mtd-abi.h> 41 42static struct nand_ecclayout fsmc_ecc1_128_layout = { 43 .eccbytes = 24, 44 .eccpos = {2, 3, 4, 18, 19, 20, 34, 35, 36, 50, 51, 52, 45 66, 67, 68, 82, 83, 84, 98, 99, 100, 114, 115, 116}, 46 .oobfree = { 47 {.offset = 8, .length = 8}, 48 {.offset = 24, .length = 8}, 49 {.offset = 40, .length = 8}, 50 {.offset = 56, .length = 8}, 51 {.offset = 72, .length = 8}, 52 {.offset = 88, .length = 8}, 53 {.offset = 104, .length = 8}, 54 {.offset = 120, .length = 8} 55 } 56}; 57 58static struct nand_ecclayout fsmc_ecc1_64_layout = { 59 .eccbytes = 12, 60 .eccpos = {2, 3, 4, 18, 19, 20, 34, 35, 36, 50, 51, 52}, 61 .oobfree = { 62 {.offset = 8, .length = 8}, 63 {.offset = 24, .length = 8}, 64 {.offset = 40, .length = 8}, 65 {.offset = 56, .length = 8}, 66 } 67}; 68 69static struct nand_ecclayout fsmc_ecc1_16_layout = { 70 .eccbytes = 3, 71 .eccpos = {2, 3, 4}, 72 .oobfree = { 73 {.offset = 8, .length = 8}, 74 } 75}; 76 77/* 78 * ECC4 layout for NAND of pagesize 8192 bytes & OOBsize 256 bytes. 13*16 bytes 79 * of OB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block and 46 80 * bytes are free for use. 81 */ 82static struct nand_ecclayout fsmc_ecc4_256_layout = { 83 .eccbytes = 208, 84 .eccpos = { 2, 3, 4, 5, 6, 7, 8, 85 9, 10, 11, 12, 13, 14, 86 18, 19, 20, 21, 22, 23, 24, 87 25, 26, 27, 28, 29, 30, 88 34, 35, 36, 37, 38, 39, 40, 89 41, 42, 43, 44, 45, 46, 90 50, 51, 52, 53, 54, 55, 56, 91 57, 58, 59, 60, 61, 62, 92 66, 67, 68, 69, 70, 71, 72, 93 73, 74, 75, 76, 77, 78, 94 82, 83, 84, 85, 86, 87, 88, 95 89, 90, 91, 92, 93, 94, 96 98, 99, 100, 101, 102, 103, 104, 97 105, 106, 107, 108, 109, 110, 98 114, 115, 116, 117, 118, 119, 120, 99 121, 122, 123, 124, 125, 126, 100 130, 131, 132, 133, 134, 135, 136, 101 137, 138, 139, 140, 141, 142, 102 146, 147, 148, 149, 150, 151, 152, 103 153, 154, 155, 156, 157, 158, 104 162, 163, 164, 165, 166, 167, 168, 105 169, 170, 171, 172, 173, 174, 106 178, 179, 180, 181, 182, 183, 184, 107 185, 186, 187, 188, 189, 190, 108 194, 195, 196, 197, 198, 199, 200, 109 201, 202, 203, 204, 205, 206, 110 210, 211, 212, 213, 214, 215, 216, 111 217, 218, 219, 220, 221, 222, 112 226, 227, 228, 229, 230, 231, 232, 113 233, 234, 235, 236, 237, 238, 114 242, 243, 244, 245, 246, 247, 248, 115 249, 250, 251, 252, 253, 254 116 }, 117 .oobfree = { 118 {.offset = 15, .length = 3}, 119 {.offset = 31, .length = 3}, 120 {.offset = 47, .length = 3}, 121 {.offset = 63, .length = 3}, 122 {.offset = 79, .length = 3}, 123 {.offset = 95, .length = 3}, 124 {.offset = 111, .length = 3}, 125 {.offset = 127, .length = 3}, 126 {.offset = 143, .length = 3}, 127 {.offset = 159, .length = 3}, 128 {.offset = 175, .length = 3}, 129 {.offset = 191, .length = 3}, 130 {.offset = 207, .length = 3}, 131 {.offset = 223, .length = 3}, 132 {.offset = 239, .length = 3}, 133 {.offset = 255, .length = 1} 134 } 135}; 136 137/* 138 * ECC4 layout for NAND of pagesize 4096 bytes & OOBsize 224 bytes. 13*8 bytes 139 * of OOB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block & 118 140 * bytes are free for use. 141 */ 142static struct nand_ecclayout fsmc_ecc4_224_layout = { 143 .eccbytes = 104, 144 .eccpos = { 2, 3, 4, 5, 6, 7, 8, 145 9, 10, 11, 12, 13, 14, 146 18, 19, 20, 21, 22, 23, 24, 147 25, 26, 27, 28, 29, 30, 148 34, 35, 36, 37, 38, 39, 40, 149 41, 42, 43, 44, 45, 46, 150 50, 51, 52, 53, 54, 55, 56, 151 57, 58, 59, 60, 61, 62, 152 66, 67, 68, 69, 70, 71, 72, 153 73, 74, 75, 76, 77, 78, 154 82, 83, 84, 85, 86, 87, 88, 155 89, 90, 91, 92, 93, 94, 156 98, 99, 100, 101, 102, 103, 104, 157 105, 106, 107, 108, 109, 110, 158 114, 115, 116, 117, 118, 119, 120, 159 121, 122, 123, 124, 125, 126 160 }, 161 .oobfree = { 162 {.offset = 15, .length = 3}, 163 {.offset = 31, .length = 3}, 164 {.offset = 47, .length = 3}, 165 {.offset = 63, .length = 3}, 166 {.offset = 79, .length = 3}, 167 {.offset = 95, .length = 3}, 168 {.offset = 111, .length = 3}, 169 {.offset = 127, .length = 97} 170 } 171}; 172 173/* 174 * ECC4 layout for NAND of pagesize 4096 bytes & OOBsize 128 bytes. 13*8 bytes 175 * of OOB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block & 22 176 * bytes are free for use. 177 */ 178static struct nand_ecclayout fsmc_ecc4_128_layout = { 179 .eccbytes = 104, 180 .eccpos = { 2, 3, 4, 5, 6, 7, 8, 181 9, 10, 11, 12, 13, 14, 182 18, 19, 20, 21, 22, 23, 24, 183 25, 26, 27, 28, 29, 30, 184 34, 35, 36, 37, 38, 39, 40, 185 41, 42, 43, 44, 45, 46, 186 50, 51, 52, 53, 54, 55, 56, 187 57, 58, 59, 60, 61, 62, 188 66, 67, 68, 69, 70, 71, 72, 189 73, 74, 75, 76, 77, 78, 190 82, 83, 84, 85, 86, 87, 88, 191 89, 90, 91, 92, 93, 94, 192 98, 99, 100, 101, 102, 103, 104, 193 105, 106, 107, 108, 109, 110, 194 114, 115, 116, 117, 118, 119, 120, 195 121, 122, 123, 124, 125, 126 196 }, 197 .oobfree = { 198 {.offset = 15, .length = 3}, 199 {.offset = 31, .length = 3}, 200 {.offset = 47, .length = 3}, 201 {.offset = 63, .length = 3}, 202 {.offset = 79, .length = 3}, 203 {.offset = 95, .length = 3}, 204 {.offset = 111, .length = 3}, 205 {.offset = 127, .length = 1} 206 } 207}; 208 209/* 210 * ECC4 layout for NAND of pagesize 2048 bytes & OOBsize 64 bytes. 13*4 bytes of 211 * OOB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block and 10 212 * bytes are free for use. 213 */ 214static struct nand_ecclayout fsmc_ecc4_64_layout = { 215 .eccbytes = 52, 216 .eccpos = { 2, 3, 4, 5, 6, 7, 8, 217 9, 10, 11, 12, 13, 14, 218 18, 19, 20, 21, 22, 23, 24, 219 25, 26, 27, 28, 29, 30, 220 34, 35, 36, 37, 38, 39, 40, 221 41, 42, 43, 44, 45, 46, 222 50, 51, 52, 53, 54, 55, 56, 223 57, 58, 59, 60, 61, 62, 224 }, 225 .oobfree = { 226 {.offset = 15, .length = 3}, 227 {.offset = 31, .length = 3}, 228 {.offset = 47, .length = 3}, 229 {.offset = 63, .length = 1}, 230 } 231}; 232 233/* 234 * ECC4 layout for NAND of pagesize 512 bytes & OOBsize 16 bytes. 13 bytes of 235 * OOB size is reserved for ECC, Byte no. 4 & 5 reserved for bad block and One 236 * byte is free for use. 237 */ 238static struct nand_ecclayout fsmc_ecc4_16_layout = { 239 .eccbytes = 13, 240 .eccpos = { 0, 1, 2, 3, 6, 7, 8, 241 9, 10, 11, 12, 13, 14 242 }, 243 .oobfree = { 244 {.offset = 15, .length = 1}, 245 } 246}; 247 248/* 249 * ECC placement definitions in oobfree type format. 250 * There are 13 bytes of ecc for every 512 byte block and it has to be read 251 * consecutively and immediately after the 512 byte data block for hardware to 252 * generate the error bit offsets in 512 byte data. 253 * Managing the ecc bytes in the following way makes it easier for software to 254 * read ecc bytes consecutive to data bytes. This way is similar to 255 * oobfree structure maintained already in generic nand driver 256 */ 257static struct fsmc_eccplace fsmc_ecc4_lp_place = { 258 .eccplace = { 259 {.offset = 2, .length = 13}, 260 {.offset = 18, .length = 13}, 261 {.offset = 34, .length = 13}, 262 {.offset = 50, .length = 13}, 263 {.offset = 66, .length = 13}, 264 {.offset = 82, .length = 13}, 265 {.offset = 98, .length = 13}, 266 {.offset = 114, .length = 13} 267 } 268}; 269 270static struct fsmc_eccplace fsmc_ecc4_sp_place = { 271 .eccplace = { 272 {.offset = 0, .length = 4}, 273 {.offset = 6, .length = 9} 274 } 275}; 276 277/** 278 * struct fsmc_nand_data - structure for FSMC NAND device state 279 * 280 * @pid: Part ID on the AMBA PrimeCell format 281 * @mtd: MTD info for a NAND flash. 282 * @nand: Chip related info for a NAND flash. 283 * @partitions: Partition info for a NAND Flash. 284 * @nr_partitions: Total number of partition of a NAND flash. 285 * 286 * @ecc_place: ECC placing locations in oobfree type format. 287 * @bank: Bank number for probed device. 288 * @clk: Clock structure for FSMC. 289 * 290 * @read_dma_chan: DMA channel for read access 291 * @write_dma_chan: DMA channel for write access to NAND 292 * @dma_access_complete: Completion structure 293 * 294 * @data_pa: NAND Physical port for Data. 295 * @data_va: NAND port for Data. 296 * @cmd_va: NAND port for Command. 297 * @addr_va: NAND port for Address. 298 * @regs_va: FSMC regs base address. 299 */ 300struct fsmc_nand_data { 301 u32 pid; 302 struct mtd_info mtd; 303 struct nand_chip nand; 304 struct mtd_partition *partitions; 305 unsigned int nr_partitions; 306 307 struct fsmc_eccplace *ecc_place; 308 unsigned int bank; 309 struct device *dev; 310 enum access_mode mode; 311 struct clk *clk; 312 313 /* DMA related objects */ 314 struct dma_chan *read_dma_chan; 315 struct dma_chan *write_dma_chan; 316 struct completion dma_access_complete; 317 318 struct fsmc_nand_timings *dev_timings; 319 320 dma_addr_t data_pa; 321 void __iomem *data_va; 322 void __iomem *cmd_va; 323 void __iomem *addr_va; 324 void __iomem *regs_va; 325 326 void (*select_chip)(uint32_t bank, uint32_t busw); 327}; 328 329/* Assert CS signal based on chipnr */ 330static void fsmc_select_chip(struct mtd_info *mtd, int chipnr) 331{ 332 struct nand_chip *chip = mtd->priv; 333 struct fsmc_nand_data *host; 334 335 host = container_of(mtd, struct fsmc_nand_data, mtd); 336 337 switch (chipnr) { 338 case -1: 339 chip->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE); 340 break; 341 case 0: 342 case 1: 343 case 2: 344 case 3: 345 if (host->select_chip) 346 host->select_chip(chipnr, 347 chip->options & NAND_BUSWIDTH_16); 348 break; 349 350 default: 351 dev_err(host->dev, "unsupported chip-select %d\n", chipnr); 352 } 353} 354 355/* 356 * fsmc_cmd_ctrl - For facilitaing Hardware access 357 * This routine allows hardware specific access to control-lines(ALE,CLE) 358 */ 359static void fsmc_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl) 360{ 361 struct nand_chip *this = mtd->priv; 362 struct fsmc_nand_data *host = container_of(mtd, 363 struct fsmc_nand_data, mtd); 364 void __iomem *regs = host->regs_va; 365 unsigned int bank = host->bank; 366 367 if (ctrl & NAND_CTRL_CHANGE) { 368 u32 pc; 369 370 if (ctrl & NAND_CLE) { 371 this->IO_ADDR_R = host->cmd_va; 372 this->IO_ADDR_W = host->cmd_va; 373 } else if (ctrl & NAND_ALE) { 374 this->IO_ADDR_R = host->addr_va; 375 this->IO_ADDR_W = host->addr_va; 376 } else { 377 this->IO_ADDR_R = host->data_va; 378 this->IO_ADDR_W = host->data_va; 379 } 380 381 pc = readl(FSMC_NAND_REG(regs, bank, PC)); 382 if (ctrl & NAND_NCE) 383 pc |= FSMC_ENABLE; 384 else 385 pc &= ~FSMC_ENABLE; 386 writel_relaxed(pc, FSMC_NAND_REG(regs, bank, PC)); 387 } 388 389 mb(); 390 391 if (cmd != NAND_CMD_NONE) 392 writeb_relaxed(cmd, this->IO_ADDR_W); 393} 394 395/* 396 * fsmc_nand_setup - FSMC (Flexible Static Memory Controller) init routine 397 * 398 * This routine initializes timing parameters related to NAND memory access in 399 * FSMC registers 400 */ 401static void fsmc_nand_setup(void __iomem *regs, uint32_t bank, 402 uint32_t busw, struct fsmc_nand_timings *timings) 403{ 404 uint32_t value = FSMC_DEVTYPE_NAND | FSMC_ENABLE | FSMC_WAITON; 405 uint32_t tclr, tar, thiz, thold, twait, tset; 406 struct fsmc_nand_timings *tims; 407 struct fsmc_nand_timings default_timings = { 408 .tclr = FSMC_TCLR_1, 409 .tar = FSMC_TAR_1, 410 .thiz = FSMC_THIZ_1, 411 .thold = FSMC_THOLD_4, 412 .twait = FSMC_TWAIT_6, 413 .tset = FSMC_TSET_0, 414 }; 415 416 if (timings) 417 tims = timings; 418 else 419 tims = &default_timings; 420 421 tclr = (tims->tclr & FSMC_TCLR_MASK) << FSMC_TCLR_SHIFT; 422 tar = (tims->tar & FSMC_TAR_MASK) << FSMC_TAR_SHIFT; 423 thiz = (tims->thiz & FSMC_THIZ_MASK) << FSMC_THIZ_SHIFT; 424 thold = (tims->thold & FSMC_THOLD_MASK) << FSMC_THOLD_SHIFT; 425 twait = (tims->twait & FSMC_TWAIT_MASK) << FSMC_TWAIT_SHIFT; 426 tset = (tims->tset & FSMC_TSET_MASK) << FSMC_TSET_SHIFT; 427 428 if (busw) 429 writel_relaxed(value | FSMC_DEVWID_16, 430 FSMC_NAND_REG(regs, bank, PC)); 431 else 432 writel_relaxed(value | FSMC_DEVWID_8, 433 FSMC_NAND_REG(regs, bank, PC)); 434 435 writel_relaxed(readl(FSMC_NAND_REG(regs, bank, PC)) | tclr | tar, 436 FSMC_NAND_REG(regs, bank, PC)); 437 writel_relaxed(thiz | thold | twait | tset, 438 FSMC_NAND_REG(regs, bank, COMM)); 439 writel_relaxed(thiz | thold | twait | tset, 440 FSMC_NAND_REG(regs, bank, ATTRIB)); 441} 442 443/* 444 * fsmc_enable_hwecc - Enables Hardware ECC through FSMC registers 445 */ 446static void fsmc_enable_hwecc(struct mtd_info *mtd, int mode) 447{ 448 struct fsmc_nand_data *host = container_of(mtd, 449 struct fsmc_nand_data, mtd); 450 void __iomem *regs = host->regs_va; 451 uint32_t bank = host->bank; 452 453 writel_relaxed(readl(FSMC_NAND_REG(regs, bank, PC)) & ~FSMC_ECCPLEN_256, 454 FSMC_NAND_REG(regs, bank, PC)); 455 writel_relaxed(readl(FSMC_NAND_REG(regs, bank, PC)) & ~FSMC_ECCEN, 456 FSMC_NAND_REG(regs, bank, PC)); 457 writel_relaxed(readl(FSMC_NAND_REG(regs, bank, PC)) | FSMC_ECCEN, 458 FSMC_NAND_REG(regs, bank, PC)); 459} 460 461/* 462 * fsmc_read_hwecc_ecc4 - Hardware ECC calculator for ecc4 option supported by 463 * FSMC. ECC is 13 bytes for 512 bytes of data (supports error correction up to 464 * max of 8-bits) 465 */ 466static int fsmc_read_hwecc_ecc4(struct mtd_info *mtd, const uint8_t *data, 467 uint8_t *ecc) 468{ 469 struct fsmc_nand_data *host = container_of(mtd, 470 struct fsmc_nand_data, mtd); 471 void __iomem *regs = host->regs_va; 472 uint32_t bank = host->bank; 473 uint32_t ecc_tmp; 474 unsigned long deadline = jiffies + FSMC_BUSY_WAIT_TIMEOUT; 475 476 do { 477 if (readl_relaxed(FSMC_NAND_REG(regs, bank, STS)) & FSMC_CODE_RDY) 478 break; 479 else 480 cond_resched(); 481 } while (!time_after_eq(jiffies, deadline)); 482 483 if (time_after_eq(jiffies, deadline)) { 484 dev_err(host->dev, "calculate ecc timed out\n"); 485 return -ETIMEDOUT; 486 } 487 488 ecc_tmp = readl_relaxed(FSMC_NAND_REG(regs, bank, ECC1)); 489 ecc[0] = (uint8_t) (ecc_tmp >> 0); 490 ecc[1] = (uint8_t) (ecc_tmp >> 8); 491 ecc[2] = (uint8_t) (ecc_tmp >> 16); 492 ecc[3] = (uint8_t) (ecc_tmp >> 24); 493 494 ecc_tmp = readl_relaxed(FSMC_NAND_REG(regs, bank, ECC2)); 495 ecc[4] = (uint8_t) (ecc_tmp >> 0); 496 ecc[5] = (uint8_t) (ecc_tmp >> 8); 497 ecc[6] = (uint8_t) (ecc_tmp >> 16); 498 ecc[7] = (uint8_t) (ecc_tmp >> 24); 499 500 ecc_tmp = readl_relaxed(FSMC_NAND_REG(regs, bank, ECC3)); 501 ecc[8] = (uint8_t) (ecc_tmp >> 0); 502 ecc[9] = (uint8_t) (ecc_tmp >> 8); 503 ecc[10] = (uint8_t) (ecc_tmp >> 16); 504 ecc[11] = (uint8_t) (ecc_tmp >> 24); 505 506 ecc_tmp = readl_relaxed(FSMC_NAND_REG(regs, bank, STS)); 507 ecc[12] = (uint8_t) (ecc_tmp >> 16); 508 509 return 0; 510} 511 512/* 513 * fsmc_read_hwecc_ecc1 - Hardware ECC calculator for ecc1 option supported by 514 * FSMC. ECC is 3 bytes for 512 bytes of data (supports error correction up to 515 * max of 1-bit) 516 */ 517static int fsmc_read_hwecc_ecc1(struct mtd_info *mtd, const uint8_t *data, 518 uint8_t *ecc) 519{ 520 struct fsmc_nand_data *host = container_of(mtd, 521 struct fsmc_nand_data, mtd); 522 void __iomem *regs = host->regs_va; 523 uint32_t bank = host->bank; 524 uint32_t ecc_tmp; 525 526 ecc_tmp = readl_relaxed(FSMC_NAND_REG(regs, bank, ECC1)); 527 ecc[0] = (uint8_t) (ecc_tmp >> 0); 528 ecc[1] = (uint8_t) (ecc_tmp >> 8); 529 ecc[2] = (uint8_t) (ecc_tmp >> 16); 530 531 return 0; 532} 533 534/* Count the number of 0's in buff upto a max of max_bits */ 535static int count_written_bits(uint8_t *buff, int size, int max_bits) 536{ 537 int k, written_bits = 0; 538 539 for (k = 0; k < size; k++) { 540 written_bits += hweight8(~buff[k]); 541 if (written_bits > max_bits) 542 break; 543 } 544 545 return written_bits; 546} 547 548static void dma_complete(void *param) 549{ 550 struct fsmc_nand_data *host = param; 551 552 complete(&host->dma_access_complete); 553} 554 555static int dma_xfer(struct fsmc_nand_data *host, void *buffer, int len, 556 enum dma_data_direction direction) 557{ 558 struct dma_chan *chan; 559 struct dma_device *dma_dev; 560 struct dma_async_tx_descriptor *tx; 561 dma_addr_t dma_dst, dma_src, dma_addr; 562 dma_cookie_t cookie; 563 unsigned long flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT; 564 int ret; 565 unsigned long time_left; 566 567 if (direction == DMA_TO_DEVICE) 568 chan = host->write_dma_chan; 569 else if (direction == DMA_FROM_DEVICE) 570 chan = host->read_dma_chan; 571 else 572 return -EINVAL; 573 574 dma_dev = chan->device; 575 dma_addr = dma_map_single(dma_dev->dev, buffer, len, direction); 576 577 if (direction == DMA_TO_DEVICE) { 578 dma_src = dma_addr; 579 dma_dst = host->data_pa; 580 } else { 581 dma_src = host->data_pa; 582 dma_dst = dma_addr; 583 } 584 585 tx = dma_dev->device_prep_dma_memcpy(chan, dma_dst, dma_src, 586 len, flags); 587 if (!tx) { 588 dev_err(host->dev, "device_prep_dma_memcpy error\n"); 589 ret = -EIO; 590 goto unmap_dma; 591 } 592 593 tx->callback = dma_complete; 594 tx->callback_param = host; 595 cookie = tx->tx_submit(tx); 596 597 ret = dma_submit_error(cookie); 598 if (ret) { 599 dev_err(host->dev, "dma_submit_error %d\n", cookie); 600 goto unmap_dma; 601 } 602 603 dma_async_issue_pending(chan); 604 605 time_left = 606 wait_for_completion_timeout(&host->dma_access_complete, 607 msecs_to_jiffies(3000)); 608 if (time_left == 0) { 609 dmaengine_terminate_all(chan); 610 dev_err(host->dev, "wait_for_completion_timeout\n"); 611 ret = -ETIMEDOUT; 612 goto unmap_dma; 613 } 614 615 ret = 0; 616 617unmap_dma: 618 dma_unmap_single(dma_dev->dev, dma_addr, len, direction); 619 620 return ret; 621} 622 623/* 624 * fsmc_write_buf - write buffer to chip 625 * @mtd: MTD device structure 626 * @buf: data buffer 627 * @len: number of bytes to write 628 */ 629static void fsmc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len) 630{ 631 int i; 632 struct nand_chip *chip = mtd->priv; 633 634 if (IS_ALIGNED((uint32_t)buf, sizeof(uint32_t)) && 635 IS_ALIGNED(len, sizeof(uint32_t))) { 636 uint32_t *p = (uint32_t *)buf; 637 len = len >> 2; 638 for (i = 0; i < len; i++) 639 writel_relaxed(p[i], chip->IO_ADDR_W); 640 } else { 641 for (i = 0; i < len; i++) 642 writeb_relaxed(buf[i], chip->IO_ADDR_W); 643 } 644} 645 646/* 647 * fsmc_read_buf - read chip data into buffer 648 * @mtd: MTD device structure 649 * @buf: buffer to store date 650 * @len: number of bytes to read 651 */ 652static void fsmc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len) 653{ 654 int i; 655 struct nand_chip *chip = mtd->priv; 656 657 if (IS_ALIGNED((uint32_t)buf, sizeof(uint32_t)) && 658 IS_ALIGNED(len, sizeof(uint32_t))) { 659 uint32_t *p = (uint32_t *)buf; 660 len = len >> 2; 661 for (i = 0; i < len; i++) 662 p[i] = readl_relaxed(chip->IO_ADDR_R); 663 } else { 664 for (i = 0; i < len; i++) 665 buf[i] = readb_relaxed(chip->IO_ADDR_R); 666 } 667} 668 669/* 670 * fsmc_read_buf_dma - read chip data into buffer 671 * @mtd: MTD device structure 672 * @buf: buffer to store date 673 * @len: number of bytes to read 674 */ 675static void fsmc_read_buf_dma(struct mtd_info *mtd, uint8_t *buf, int len) 676{ 677 struct fsmc_nand_data *host; 678 679 host = container_of(mtd, struct fsmc_nand_data, mtd); 680 dma_xfer(host, buf, len, DMA_FROM_DEVICE); 681} 682 683/* 684 * fsmc_write_buf_dma - write buffer to chip 685 * @mtd: MTD device structure 686 * @buf: data buffer 687 * @len: number of bytes to write 688 */ 689static void fsmc_write_buf_dma(struct mtd_info *mtd, const uint8_t *buf, 690 int len) 691{ 692 struct fsmc_nand_data *host; 693 694 host = container_of(mtd, struct fsmc_nand_data, mtd); 695 dma_xfer(host, (void *)buf, len, DMA_TO_DEVICE); 696} 697 698/* 699 * fsmc_read_page_hwecc 700 * @mtd: mtd info structure 701 * @chip: nand chip info structure 702 * @buf: buffer to store read data 703 * @oob_required: caller expects OOB data read to chip->oob_poi 704 * @page: page number to read 705 * 706 * This routine is needed for fsmc version 8 as reading from NAND chip has to be 707 * performed in a strict sequence as follows: 708 * data(512 byte) -> ecc(13 byte) 709 * After this read, fsmc hardware generates and reports error data bits(up to a 710 * max of 8 bits) 711 */ 712static int fsmc_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, 713 uint8_t *buf, int oob_required, int page) 714{ 715 struct fsmc_nand_data *host = container_of(mtd, 716 struct fsmc_nand_data, mtd); 717 struct fsmc_eccplace *ecc_place = host->ecc_place; 718 int i, j, s, stat, eccsize = chip->ecc.size; 719 int eccbytes = chip->ecc.bytes; 720 int eccsteps = chip->ecc.steps; 721 uint8_t *p = buf; 722 uint8_t *ecc_calc = chip->buffers->ecccalc; 723 uint8_t *ecc_code = chip->buffers->ecccode; 724 int off, len, group = 0; 725 /* 726 * ecc_oob is intentionally taken as uint16_t. In 16bit devices, we 727 * end up reading 14 bytes (7 words) from oob. The local array is 728 * to maintain word alignment 729 */ 730 uint16_t ecc_oob[7]; 731 uint8_t *oob = (uint8_t *)&ecc_oob[0]; 732 unsigned int max_bitflips = 0; 733 734 for (i = 0, s = 0; s < eccsteps; s++, i += eccbytes, p += eccsize) { 735 chip->cmdfunc(mtd, NAND_CMD_READ0, s * eccsize, page); 736 chip->ecc.hwctl(mtd, NAND_ECC_READ); 737 chip->read_buf(mtd, p, eccsize); 738 739 for (j = 0; j < eccbytes;) { 740 off = ecc_place->eccplace[group].offset; 741 len = ecc_place->eccplace[group].length; 742 group++; 743 744 /* 745 * length is intentionally kept a higher multiple of 2 746 * to read at least 13 bytes even in case of 16 bit NAND 747 * devices 748 */ 749 if (chip->options & NAND_BUSWIDTH_16) 750 len = roundup(len, 2); 751 752 chip->cmdfunc(mtd, NAND_CMD_READOOB, off, page); 753 chip->read_buf(mtd, oob + j, len); 754 j += len; 755 } 756 757 memcpy(&ecc_code[i], oob, chip->ecc.bytes); 758 chip->ecc.calculate(mtd, p, &ecc_calc[i]); 759 760 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); 761 if (stat < 0) { 762 mtd->ecc_stats.failed++; 763 } else { 764 mtd->ecc_stats.corrected += stat; 765 max_bitflips = max_t(unsigned int, max_bitflips, stat); 766 } 767 } 768 769 return max_bitflips; 770} 771 772/* 773 * fsmc_bch8_correct_data 774 * @mtd: mtd info structure 775 * @dat: buffer of read data 776 * @read_ecc: ecc read from device spare area 777 * @calc_ecc: ecc calculated from read data 778 * 779 * calc_ecc is a 104 bit information containing maximum of 8 error 780 * offset informations of 13 bits each in 512 bytes of read data. 781 */ 782static int fsmc_bch8_correct_data(struct mtd_info *mtd, uint8_t *dat, 783 uint8_t *read_ecc, uint8_t *calc_ecc) 784{ 785 struct fsmc_nand_data *host = container_of(mtd, 786 struct fsmc_nand_data, mtd); 787 struct nand_chip *chip = mtd->priv; 788 void __iomem *regs = host->regs_va; 789 unsigned int bank = host->bank; 790 uint32_t err_idx[8]; 791 uint32_t num_err, i; 792 uint32_t ecc1, ecc2, ecc3, ecc4; 793 794 num_err = (readl_relaxed(FSMC_NAND_REG(regs, bank, STS)) >> 10) & 0xF; 795 796 /* no bit flipping */ 797 if (likely(num_err == 0)) 798 return 0; 799 800 /* too many errors */ 801 if (unlikely(num_err > 8)) { 802 /* 803 * This is a temporary erase check. A newly erased page read 804 * would result in an ecc error because the oob data is also 805 * erased to FF and the calculated ecc for an FF data is not 806 * FF..FF. 807 * This is a workaround to skip performing correction in case 808 * data is FF..FF 809 * 810 * Logic: 811 * For every page, each bit written as 0 is counted until these 812 * number of bits are greater than 8 (the maximum correction 813 * capability of FSMC for each 512 + 13 bytes) 814 */ 815 816 int bits_ecc = count_written_bits(read_ecc, chip->ecc.bytes, 8); 817 int bits_data = count_written_bits(dat, chip->ecc.size, 8); 818 819 if ((bits_ecc + bits_data) <= 8) { 820 if (bits_data) 821 memset(dat, 0xff, chip->ecc.size); 822 return bits_data; 823 } 824 825 return -EBADMSG; 826 } 827 828 /* 829 * ------------------- calc_ecc[] bit wise -----------|--13 bits--| 830 * |---idx[7]--|--.....-----|---idx[2]--||---idx[1]--||---idx[0]--| 831 * 832 * calc_ecc is a 104 bit information containing maximum of 8 error 833 * offset informations of 13 bits each. calc_ecc is copied into a 834 * uint64_t array and error offset indexes are populated in err_idx 835 * array 836 */ 837 ecc1 = readl_relaxed(FSMC_NAND_REG(regs, bank, ECC1)); 838 ecc2 = readl_relaxed(FSMC_NAND_REG(regs, bank, ECC2)); 839 ecc3 = readl_relaxed(FSMC_NAND_REG(regs, bank, ECC3)); 840 ecc4 = readl_relaxed(FSMC_NAND_REG(regs, bank, STS)); 841 842 err_idx[0] = (ecc1 >> 0) & 0x1FFF; 843 err_idx[1] = (ecc1 >> 13) & 0x1FFF; 844 err_idx[2] = (((ecc2 >> 0) & 0x7F) << 6) | ((ecc1 >> 26) & 0x3F); 845 err_idx[3] = (ecc2 >> 7) & 0x1FFF; 846 err_idx[4] = (((ecc3 >> 0) & 0x1) << 12) | ((ecc2 >> 20) & 0xFFF); 847 err_idx[5] = (ecc3 >> 1) & 0x1FFF; 848 err_idx[6] = (ecc3 >> 14) & 0x1FFF; 849 err_idx[7] = (((ecc4 >> 16) & 0xFF) << 5) | ((ecc3 >> 27) & 0x1F); 850 851 i = 0; 852 while (num_err--) { 853 change_bit(0, (unsigned long *)&err_idx[i]); 854 change_bit(1, (unsigned long *)&err_idx[i]); 855 856 if (err_idx[i] < chip->ecc.size * 8) { 857 change_bit(err_idx[i], (unsigned long *)dat); 858 i++; 859 } 860 } 861 return i; 862} 863 864static bool filter(struct dma_chan *chan, void *slave) 865{ 866 chan->private = slave; 867 return true; 868} 869 870#ifdef CONFIG_OF 871static int fsmc_nand_probe_config_dt(struct platform_device *pdev, 872 struct device_node *np) 873{ 874 struct fsmc_nand_platform_data *pdata = dev_get_platdata(&pdev->dev); 875 u32 val; 876 int ret; 877 878 /* Set default NAND width to 8 bits */ 879 pdata->width = 8; 880 if (!of_property_read_u32(np, "bank-width", &val)) { 881 if (val == 2) { 882 pdata->width = 16; 883 } else if (val != 1) { 884 dev_err(&pdev->dev, "invalid bank-width %u\n", val); 885 return -EINVAL; 886 } 887 } 888 if (of_get_property(np, "nand-skip-bbtscan", NULL)) 889 pdata->options = NAND_SKIP_BBTSCAN; 890 891 pdata->nand_timings = devm_kzalloc(&pdev->dev, 892 sizeof(*pdata->nand_timings), GFP_KERNEL); 893 if (!pdata->nand_timings) 894 return -ENOMEM; 895 ret = of_property_read_u8_array(np, "timings", (u8 *)pdata->nand_timings, 896 sizeof(*pdata->nand_timings)); 897 if (ret) { 898 dev_info(&pdev->dev, "No timings in dts specified, using default timings!\n"); 899 pdata->nand_timings = NULL; 900 } 901 902 /* Set default NAND bank to 0 */ 903 pdata->bank = 0; 904 if (!of_property_read_u32(np, "bank", &val)) { 905 if (val > 3) { 906 dev_err(&pdev->dev, "invalid bank %u\n", val); 907 return -EINVAL; 908 } 909 pdata->bank = val; 910 } 911 return 0; 912} 913#else 914static int fsmc_nand_probe_config_dt(struct platform_device *pdev, 915 struct device_node *np) 916{ 917 return -ENOSYS; 918} 919#endif 920 921/* 922 * fsmc_nand_probe - Probe function 923 * @pdev: platform device structure 924 */ 925static int __init fsmc_nand_probe(struct platform_device *pdev) 926{ 927 struct fsmc_nand_platform_data *pdata = dev_get_platdata(&pdev->dev); 928 struct device_node __maybe_unused *np = pdev->dev.of_node; 929 struct mtd_part_parser_data ppdata = {}; 930 struct fsmc_nand_data *host; 931 struct mtd_info *mtd; 932 struct nand_chip *nand; 933 struct resource *res; 934 dma_cap_mask_t mask; 935 int ret = 0; 936 u32 pid; 937 int i; 938 939 if (np) { 940 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 941 pdev->dev.platform_data = pdata; 942 ret = fsmc_nand_probe_config_dt(pdev, np); 943 if (ret) { 944 dev_err(&pdev->dev, "no platform data\n"); 945 return -ENODEV; 946 } 947 } 948 949 if (!pdata) { 950 dev_err(&pdev->dev, "platform data is NULL\n"); 951 return -EINVAL; 952 } 953 954 /* Allocate memory for the device structure (and zero it) */ 955 host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL); 956 if (!host) 957 return -ENOMEM; 958 959 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_data"); 960 host->data_va = devm_ioremap_resource(&pdev->dev, res); 961 if (IS_ERR(host->data_va)) 962 return PTR_ERR(host->data_va); 963 964 host->data_pa = (dma_addr_t)res->start; 965 966 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_addr"); 967 host->addr_va = devm_ioremap_resource(&pdev->dev, res); 968 if (IS_ERR(host->addr_va)) 969 return PTR_ERR(host->addr_va); 970 971 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_cmd"); 972 host->cmd_va = devm_ioremap_resource(&pdev->dev, res); 973 if (IS_ERR(host->cmd_va)) 974 return PTR_ERR(host->cmd_va); 975 976 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fsmc_regs"); 977 host->regs_va = devm_ioremap_resource(&pdev->dev, res); 978 if (IS_ERR(host->regs_va)) 979 return PTR_ERR(host->regs_va); 980 981 host->clk = clk_get(&pdev->dev, NULL); 982 if (IS_ERR(host->clk)) { 983 dev_err(&pdev->dev, "failed to fetch block clock\n"); 984 return PTR_ERR(host->clk); 985 } 986 987 ret = clk_prepare_enable(host->clk); 988 if (ret) 989 goto err_clk_prepare_enable; 990 991 /* 992 * This device ID is actually a common AMBA ID as used on the 993 * AMBA PrimeCell bus. However it is not a PrimeCell. 994 */ 995 for (pid = 0, i = 0; i < 4; i++) 996 pid |= (readl(host->regs_va + resource_size(res) - 0x20 + 4 * i) & 255) << (i * 8); 997 host->pid = pid; 998 dev_info(&pdev->dev, "FSMC device partno %03x, manufacturer %02x, " 999 "revision %02x, config %02x\n", 1000 AMBA_PART_BITS(pid), AMBA_MANF_BITS(pid), 1001 AMBA_REV_BITS(pid), AMBA_CONFIG_BITS(pid)); 1002 1003 host->bank = pdata->bank; 1004 host->select_chip = pdata->select_bank; 1005 host->partitions = pdata->partitions; 1006 host->nr_partitions = pdata->nr_partitions; 1007 host->dev = &pdev->dev; 1008 host->dev_timings = pdata->nand_timings; 1009 host->mode = pdata->mode; 1010 1011 if (host->mode == USE_DMA_ACCESS) 1012 init_completion(&host->dma_access_complete); 1013 1014 /* Link all private pointers */ 1015 mtd = &host->mtd; 1016 nand = &host->nand; 1017 mtd->priv = nand; 1018 nand->priv = host; 1019 1020 host->mtd.dev.parent = &pdev->dev; 1021 nand->IO_ADDR_R = host->data_va; 1022 nand->IO_ADDR_W = host->data_va; 1023 nand->cmd_ctrl = fsmc_cmd_ctrl; 1024 nand->chip_delay = 30; 1025 1026 /* 1027 * Setup default ECC mode. nand_dt_init() called from nand_scan_ident() 1028 * can overwrite this value if the DT provides a different value. 1029 */ 1030 nand->ecc.mode = NAND_ECC_HW; 1031 nand->ecc.hwctl = fsmc_enable_hwecc; 1032 nand->ecc.size = 512; 1033 nand->options = pdata->options; 1034 nand->select_chip = fsmc_select_chip; 1035 nand->badblockbits = 7; 1036 nand->flash_node = np; 1037 1038 if (pdata->width == FSMC_NAND_BW16) 1039 nand->options |= NAND_BUSWIDTH_16; 1040 1041 switch (host->mode) { 1042 case USE_DMA_ACCESS: 1043 dma_cap_zero(mask); 1044 dma_cap_set(DMA_MEMCPY, mask); 1045 host->read_dma_chan = dma_request_channel(mask, filter, 1046 pdata->read_dma_priv); 1047 if (!host->read_dma_chan) { 1048 dev_err(&pdev->dev, "Unable to get read dma channel\n"); 1049 goto err_req_read_chnl; 1050 } 1051 host->write_dma_chan = dma_request_channel(mask, filter, 1052 pdata->write_dma_priv); 1053 if (!host->write_dma_chan) { 1054 dev_err(&pdev->dev, "Unable to get write dma channel\n"); 1055 goto err_req_write_chnl; 1056 } 1057 nand->read_buf = fsmc_read_buf_dma; 1058 nand->write_buf = fsmc_write_buf_dma; 1059 break; 1060 1061 default: 1062 case USE_WORD_ACCESS: 1063 nand->read_buf = fsmc_read_buf; 1064 nand->write_buf = fsmc_write_buf; 1065 break; 1066 } 1067 1068 fsmc_nand_setup(host->regs_va, host->bank, 1069 nand->options & NAND_BUSWIDTH_16, 1070 host->dev_timings); 1071 1072 if (AMBA_REV_BITS(host->pid) >= 8) { 1073 nand->ecc.read_page = fsmc_read_page_hwecc; 1074 nand->ecc.calculate = fsmc_read_hwecc_ecc4; 1075 nand->ecc.correct = fsmc_bch8_correct_data; 1076 nand->ecc.bytes = 13; 1077 nand->ecc.strength = 8; 1078 } 1079 1080 /* 1081 * Scan to find existence of the device 1082 */ 1083 if (nand_scan_ident(&host->mtd, 1, NULL)) { 1084 ret = -ENXIO; 1085 dev_err(&pdev->dev, "No NAND Device found!\n"); 1086 goto err_scan_ident; 1087 } 1088 1089 if (AMBA_REV_BITS(host->pid) >= 8) { 1090 switch (host->mtd.oobsize) { 1091 case 16: 1092 nand->ecc.layout = &fsmc_ecc4_16_layout; 1093 host->ecc_place = &fsmc_ecc4_sp_place; 1094 break; 1095 case 64: 1096 nand->ecc.layout = &fsmc_ecc4_64_layout; 1097 host->ecc_place = &fsmc_ecc4_lp_place; 1098 break; 1099 case 128: 1100 nand->ecc.layout = &fsmc_ecc4_128_layout; 1101 host->ecc_place = &fsmc_ecc4_lp_place; 1102 break; 1103 case 224: 1104 nand->ecc.layout = &fsmc_ecc4_224_layout; 1105 host->ecc_place = &fsmc_ecc4_lp_place; 1106 break; 1107 case 256: 1108 nand->ecc.layout = &fsmc_ecc4_256_layout; 1109 host->ecc_place = &fsmc_ecc4_lp_place; 1110 break; 1111 default: 1112 dev_warn(&pdev->dev, "No oob scheme defined for oobsize %d\n", 1113 mtd->oobsize); 1114 ret = -EINVAL; 1115 goto err_probe; 1116 } 1117 } else { 1118 switch (nand->ecc.mode) { 1119 case NAND_ECC_HW: 1120 dev_info(&pdev->dev, "Using 1-bit HW ECC scheme\n"); 1121 nand->ecc.calculate = fsmc_read_hwecc_ecc1; 1122 nand->ecc.correct = nand_correct_data; 1123 nand->ecc.bytes = 3; 1124 nand->ecc.strength = 1; 1125 break; 1126 1127 case NAND_ECC_SOFT_BCH: 1128 dev_info(&pdev->dev, "Using 4-bit SW BCH ECC scheme\n"); 1129 break; 1130 1131 default: 1132 dev_err(&pdev->dev, "Unsupported ECC mode!\n"); 1133 goto err_probe; 1134 } 1135 1136 /* 1137 * Don't set layout for BCH4 SW ECC. This will be 1138 * generated later in nand_bch_init() later. 1139 */ 1140 if (nand->ecc.mode != NAND_ECC_SOFT_BCH) { 1141 switch (host->mtd.oobsize) { 1142 case 16: 1143 nand->ecc.layout = &fsmc_ecc1_16_layout; 1144 break; 1145 case 64: 1146 nand->ecc.layout = &fsmc_ecc1_64_layout; 1147 break; 1148 case 128: 1149 nand->ecc.layout = &fsmc_ecc1_128_layout; 1150 break; 1151 default: 1152 dev_warn(&pdev->dev, 1153 "No oob scheme defined for oobsize %d\n", 1154 mtd->oobsize); 1155 ret = -EINVAL; 1156 goto err_probe; 1157 } 1158 } 1159 } 1160 1161 /* Second stage of scan to fill MTD data-structures */ 1162 if (nand_scan_tail(&host->mtd)) { 1163 ret = -ENXIO; 1164 goto err_probe; 1165 } 1166 1167 /* 1168 * The partition information can is accessed by (in the same precedence) 1169 * 1170 * command line through Bootloader, 1171 * platform data, 1172 * default partition information present in driver. 1173 */ 1174 /* 1175 * Check for partition info passed 1176 */ 1177 host->mtd.name = "nand"; 1178 ppdata.of_node = np; 1179 ret = mtd_device_parse_register(&host->mtd, NULL, &ppdata, 1180 host->partitions, host->nr_partitions); 1181 if (ret) 1182 goto err_probe; 1183 1184 platform_set_drvdata(pdev, host); 1185 dev_info(&pdev->dev, "FSMC NAND driver registration successful\n"); 1186 return 0; 1187 1188err_probe: 1189err_scan_ident: 1190 if (host->mode == USE_DMA_ACCESS) 1191 dma_release_channel(host->write_dma_chan); 1192err_req_write_chnl: 1193 if (host->mode == USE_DMA_ACCESS) 1194 dma_release_channel(host->read_dma_chan); 1195err_req_read_chnl: 1196 clk_disable_unprepare(host->clk); 1197err_clk_prepare_enable: 1198 clk_put(host->clk); 1199 return ret; 1200} 1201 1202/* 1203 * Clean up routine 1204 */ 1205static int fsmc_nand_remove(struct platform_device *pdev) 1206{ 1207 struct fsmc_nand_data *host = platform_get_drvdata(pdev); 1208 1209 if (host) { 1210 nand_release(&host->mtd); 1211 1212 if (host->mode == USE_DMA_ACCESS) { 1213 dma_release_channel(host->write_dma_chan); 1214 dma_release_channel(host->read_dma_chan); 1215 } 1216 clk_disable_unprepare(host->clk); 1217 clk_put(host->clk); 1218 } 1219 1220 return 0; 1221} 1222 1223#ifdef CONFIG_PM_SLEEP 1224static int fsmc_nand_suspend(struct device *dev) 1225{ 1226 struct fsmc_nand_data *host = dev_get_drvdata(dev); 1227 if (host) 1228 clk_disable_unprepare(host->clk); 1229 return 0; 1230} 1231 1232static int fsmc_nand_resume(struct device *dev) 1233{ 1234 struct fsmc_nand_data *host = dev_get_drvdata(dev); 1235 if (host) { 1236 clk_prepare_enable(host->clk); 1237 fsmc_nand_setup(host->regs_va, host->bank, 1238 host->nand.options & NAND_BUSWIDTH_16, 1239 host->dev_timings); 1240 } 1241 return 0; 1242} 1243#endif 1244 1245static SIMPLE_DEV_PM_OPS(fsmc_nand_pm_ops, fsmc_nand_suspend, fsmc_nand_resume); 1246 1247#ifdef CONFIG_OF 1248static const struct of_device_id fsmc_nand_id_table[] = { 1249 { .compatible = "st,spear600-fsmc-nand" }, 1250 { .compatible = "stericsson,fsmc-nand" }, 1251 {} 1252}; 1253MODULE_DEVICE_TABLE(of, fsmc_nand_id_table); 1254#endif 1255 1256static struct platform_driver fsmc_nand_driver = { 1257 .remove = fsmc_nand_remove, 1258 .driver = { 1259 .name = "fsmc-nand", 1260 .of_match_table = of_match_ptr(fsmc_nand_id_table), 1261 .pm = &fsmc_nand_pm_ops, 1262 }, 1263}; 1264 1265module_platform_driver_probe(fsmc_nand_driver, fsmc_nand_probe); 1266 1267MODULE_LICENSE("GPL"); 1268MODULE_AUTHOR("Vipin Kumar <vipin.kumar@st.com>, Ashish Priyadarshi"); 1269MODULE_DESCRIPTION("NAND driver for SPEAr Platforms"); 1270