drivers/mtd/nand/spi/core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2016-2017 Micron Technology, Inc.
   4  *
   5  * Authors:
   6  *      Peter Pan <peterpandong@micron.com>
   7  *      Boris Brezillon <boris.brezillon@bootlin.com>
   8  */
   9
  10 #define pr_fmt(fmt)     "spi-nand: " fmt
  11
  12 #include <linux/device.h>
  13 #include <linux/jiffies.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/mtd/spinand.h>
  17 #include <linux/of.h>
  18 #include <linux/slab.h>
  19 #include <linux/string.h>
  20 #include <linux/spi/spi.h>
  21 #include <linux/spi/spi-mem.h>
  22
  23 static int spinand_read_reg_op(struct spinand_device *spinand, u8 reg, u8 *val)
  24 {
  25         struct spi_mem_op op = SPINAND_GET_FEATURE_OP(reg,
  26                                                       spinand->scratchbuf);
  27         int ret;
  28
  29         ret = spi_mem_exec_op(spinand->spimem, &op);
  30         if (ret)
  31                 return ret;
  32
  33         *val = *spinand->scratchbuf;
  34         return 0;
  35 }
  36
  37 static int spinand_write_reg_op(struct spinand_device *spinand, u8 reg, u8 val)
  38 {
  39         struct spi_mem_op op = SPINAND_SET_FEATURE_OP(reg,
  40                                                       spinand->scratchbuf);
  41
  42         *spinand->scratchbuf = val;
  43         return spi_mem_exec_op(spinand->spimem, &op);
  44 }
  45
  46 static int spinand_read_status(struct spinand_device *spinand, u8 *status)
  47 {
  48         return spinand_read_reg_op(spinand, REG_STATUS, status);
  49 }
  50
  51 static int spinand_get_cfg(struct spinand_device *spinand, u8 *cfg)
  52 {
  53         struct nand_device *nand = spinand_to_nand(spinand);
  54
  55         if (WARN_ON(spinand->cur_target < 0 ||
  56                     spinand->cur_target >= nand->memorg.ntargets))
  57                 return -EINVAL;
  58
  59         *cfg = spinand->cfg_cache[spinand->cur_target];
  60         return 0;
  61 }
  62
  63 static int spinand_set_cfg(struct spinand_device *spinand, u8 cfg)
  64 {
  65         struct nand_device *nand = spinand_to_nand(spinand);
  66         int ret;
  67
  68         if (WARN_ON(spinand->cur_target < 0 ||
  69                     spinand->cur_target >= nand->memorg.ntargets))
  70                 return -EINVAL;
  71
  72         if (spinand->cfg_cache[spinand->cur_target] == cfg)
  73                 return 0;
  74
  75         ret = spinand_write_reg_op(spinand, REG_CFG, cfg);
  76         if (ret)
  77                 return ret;
  78
  79         spinand->cfg_cache[spinand->cur_target] = cfg;
  80         return 0;
  81 }
  82
  83 /**
  84  * spinand_upd_cfg() - Update the configuration register
  85  * @spinand: the spinand device
  86  * @mask: the mask encoding the bits to update in the config reg
  87  * @val: the new value to apply
  88  *
  89  * Update the configuration register.
  90  *
  91  * Return: 0 on success, a negative error code otherwise.
  92  */
  93 int spinand_upd_cfg(struct spinand_device *spinand, u8 mask, u8 val)
  94 {
  95         int ret;
  96         u8 cfg;
  97
  98         ret = spinand_get_cfg(spinand, &cfg);
  99         if (ret)
 100                 return ret;
 101
 102         cfg &= ~mask;
 103         cfg |= val;
 104
 105         return spinand_set_cfg(spinand, cfg);
 106 }
 107
 108 /**
 109  * spinand_select_target() - Select a specific NAND target/die
 110  * @spinand: the spinand device
 111  * @target: the target/die to select
 112  *
 113  * Select a new target/die. If chip only has one die, this function is a NOOP.
 114  *
 115  * Return: 0 on success, a negative error code otherwise.
 116  */
 117 int spinand_select_target(struct spinand_device *spinand, unsigned int target)
 118 {
 119         struct nand_device *nand = spinand_to_nand(spinand);
 120         int ret;
 121
 122         if (WARN_ON(target >= nand->memorg.ntargets))
 123                 return -EINVAL;
 124
 125         if (spinand->cur_target == target)
 126                 return 0;
 127
 128         if (nand->memorg.ntargets == 1) {
 129                 spinand->cur_target = target;
 130                 return 0;
 131         }
 132
 133         ret = spinand->select_target(spinand, target);
 134         if (ret)
 135                 return ret;
 136
 137         spinand->cur_target = target;
 138         return 0;
 139 }
 140
 141 static int spinand_init_cfg_cache(struct spinand_device *spinand)
 142 {
 143         struct nand_device *nand = spinand_to_nand(spinand);
 144         struct device *dev = &spinand->spimem->spi->dev;
 145         unsigned int target;
 146         int ret;
 147
 148         spinand->cfg_cache = devm_kcalloc(dev,
 149                                           nand->memorg.ntargets,
 150                                           sizeof(*spinand->cfg_cache),
 151                                           GFP_KERNEL);
 152         if (!spinand->cfg_cache)
 153                 return -ENOMEM;
 154
 155         for (target = 0; target < nand->memorg.ntargets; target++) {
 156                 ret = spinand_select_target(spinand, target);
 157                 if (ret)
 158                         return ret;
 159
 160                 /*
 161                  * We use spinand_read_reg_op() instead of spinand_get_cfg()
 162                  * here to bypass the config cache.
 163                  */
 164                 ret = spinand_read_reg_op(spinand, REG_CFG,
 165                                           &spinand->cfg_cache[target]);
 166                 if (ret)
 167                         return ret;
 168         }
 169
 170         return 0;
 171 }
 172
 173 static int spinand_init_quad_enable(struct spinand_device *spinand)
 174 {
 175         bool enable = false;
 176
 177         if (!(spinand->flags & SPINAND_HAS_QE_BIT))
 178                 return 0;
 179
 180         if (spinand->op_templates.read_cache->data.buswidth == 4 ||
 181             spinand->op_templates.write_cache->data.buswidth == 4 ||
 182             spinand->op_templates.update_cache->data.buswidth == 4)
 183                 enable = true;
 184
 185         return spinand_upd_cfg(spinand, CFG_QUAD_ENABLE,
 186                                enable ? CFG_QUAD_ENABLE : 0);
 187 }
 188
 189 static int spinand_ecc_enable(struct spinand_device *spinand,
 190                               bool enable)
 191 {
 192         return spinand_upd_cfg(spinand, CFG_ECC_ENABLE,
 193                                enable ? CFG_ECC_ENABLE : 0);
 194 }
 195
 196 static int spinand_write_enable_op(struct spinand_device *spinand)
 197 {
 198         struct spi_mem_op op = SPINAND_WR_EN_DIS_OP(true);
 199
 200         return spi_mem_exec_op(spinand->spimem, &op);
 201 }
 202
 203 static int spinand_load_page_op(struct spinand_device *spinand,
 204                                 const struct nand_page_io_req *req)
 205 {
 206         struct nand_device *nand = spinand_to_nand(spinand);
 207         unsigned int row = nanddev_pos_to_row(nand, &req->pos);
 208         struct spi_mem_op op = SPINAND_PAGE_READ_OP(row);
 209
 210         return spi_mem_exec_op(spinand->spimem, &op);
 211 }
 212
 213 static int spinand_read_from_cache_op(struct spinand_device *spinand,
 214                                       const struct nand_page_io_req *req)
 215 {
 216         struct nand_device *nand = spinand_to_nand(spinand);
 217         struct mtd_info *mtd = nanddev_to_mtd(nand);
 218         struct spi_mem_dirmap_desc *rdesc;
 219         unsigned int nbytes = 0;
 220         void *buf = NULL;
 221         u16 column = 0;
 222         ssize_t ret;
 223
 224         if (req->datalen) {
 225                 buf = spinand->databuf;
 226                 nbytes = nanddev_page_size(nand);
 227                 column = 0;
 228         }
 229
 230         if (req->ooblen) {
 231                 nbytes += nanddev_per_page_oobsize(nand);
 232                 if (!buf) {
 233                         buf = spinand->oobbuf;
 234                         column = nanddev_page_size(nand);
 235                 }
 236         }
 237
 238         rdesc = spinand->dirmaps[req->pos.plane].rdesc;
 239
 240         while (nbytes) {
 241                 ret = spi_mem_dirmap_read(rdesc, column, nbytes, buf);
 242                 if (ret < 0)
 243                         return ret;
 244
 245                 if (!ret || ret > nbytes)
 246                         return -EIO;
 247
 248                 nbytes -= ret;
 249                 column += ret;
 250                 buf += ret;
 251         }
 252
 253         if (req->datalen)
 254                 memcpy(req->databuf.in, spinand->databuf + req->dataoffs,
 255                        req->datalen);
 256
 257         if (req->ooblen) {
 258                 if (req->mode == MTD_OPS_AUTO_OOB)
 259                         mtd_ooblayout_get_databytes(mtd, req->oobbuf.in,
 260                                                     spinand->oobbuf,
 261                                                     req->ooboffs,
 262                                                     req->ooblen);
 263                 else
 264                         memcpy(req->oobbuf.in, spinand->oobbuf + req->ooboffs,
 265                                req->ooblen);
 266         }
 267
 268         return 0;
 269 }
 270
 271 static int spinand_write_to_cache_op(struct spinand_device *spinand,
 272                                      const struct nand_page_io_req *req)
 273 {
 274         struct nand_device *nand = spinand_to_nand(spinand);
 275         struct mtd_info *mtd = nanddev_to_mtd(nand);
 276         struct spi_mem_dirmap_desc *wdesc;
 277         unsigned int nbytes, column = 0;
 278         void *buf = spinand->databuf;
 279         ssize_t ret;
 280
 281         /*
 282          * Looks like PROGRAM LOAD (AKA write cache) does not necessarily reset
 283          * the cache content to 0xFF (depends on vendor implementation), so we
 284          * must fill the page cache entirely even if we only want to program
 285          * the data portion of the page, otherwise we might corrupt the BBM or
 286          * user data previously programmed in OOB area.
 287          */
 288         nbytes = nanddev_page_size(nand) + nanddev_per_page_oobsize(nand);
 289         memset(spinand->databuf, 0xff, nbytes);
 290
 291         if (req->datalen)
 292                 memcpy(spinand->databuf + req->dataoffs, req->databuf.out,
 293                        req->datalen);
 294
 295         if (req->ooblen) {
 296                 if (req->mode == MTD_OPS_AUTO_OOB)
 297                         mtd_ooblayout_set_databytes(mtd, req->oobbuf.out,
 298                                                     spinand->oobbuf,
 299                                                     req->ooboffs,
 300                                                     req->ooblen);
 301                 else
 302                         memcpy(spinand->oobbuf + req->ooboffs, req->oobbuf.out,
 303                                req->ooblen);
 304         }
 305
 306         wdesc = spinand->dirmaps[req->pos.plane].wdesc;
 307
 308         while (nbytes) {
 309                 ret = spi_mem_dirmap_write(wdesc, column, nbytes, buf);
 310                 if (ret < 0)
 311                         return ret;
 312
 313                 if (!ret || ret > nbytes)
 314                         return -EIO;
 315
 316                 nbytes -= ret;
 317                 column += ret;
 318                 buf += ret;
 319         }
 320
 321         return 0;
 322 }
 323
 324 static int spinand_program_op(struct spinand_device *spinand,
 325                               const struct nand_page_io_req *req)
 326 {
 327         struct nand_device *nand = spinand_to_nand(spinand);
 328         unsigned int row = nanddev_pos_to_row(nand, &req->pos);
 329         struct spi_mem_op op = SPINAND_PROG_EXEC_OP(row);
 330
 331         return spi_mem_exec_op(spinand->spimem, &op);
 332 }
 333
 334 static int spinand_erase_op(struct spinand_device *spinand,
 335                             const struct nand_pos *pos)
 336 {
 337         struct nand_device *nand = spinand_to_nand(spinand);
 338         unsigned int row = nanddev_pos_to_row(nand, pos);
 339         struct spi_mem_op op = SPINAND_BLK_ERASE_OP(row);
 340
 341         return spi_mem_exec_op(spinand->spimem, &op);
 342 }
 343
 344 static int spinand_wait(struct spinand_device *spinand, u8 *s)
 345 {
 346         unsigned long timeo =  jiffies + msecs_to_jiffies(400);
 347         u8 status;
 348         int ret;
 349
 350         do {
 351                 ret = spinand_read_status(spinand, &status);
 352                 if (ret)
 353                         return ret;
 354
 355                 if (!(status & STATUS_BUSY))
 356                         goto out;
 357         } while (time_before(jiffies, timeo));
 358
 359         /*
 360          * Extra read, just in case the STATUS_READY bit has changed
 361          * since our last check
 362          */
 363         ret = spinand_read_status(spinand, &status);
 364         if (ret)
 365                 return ret;
 366
 367 out:
 368         if (s)
 369                 *s = status;
 370
 371         return status & STATUS_BUSY ? -ETIMEDOUT : 0;
 372 }
 373
 374 static int spinand_read_id_op(struct spinand_device *spinand, u8 naddr,
 375                               u8 ndummy, u8 *buf)
 376 {
 377         struct spi_mem_op op = SPINAND_READID_OP(
 378                 naddr, ndummy, spinand->scratchbuf, SPINAND_MAX_ID_LEN);
 379         int ret;
 380
 381         ret = spi_mem_exec_op(spinand->spimem, &op);
 382         if (!ret)
 383                 memcpy(buf, spinand->scratchbuf, SPINAND_MAX_ID_LEN);
 384
 385         return ret;
 386 }
 387
 388 static int spinand_reset_op(struct spinand_device *spinand)
 389 {
 390         struct spi_mem_op op = SPINAND_RESET_OP;
 391         int ret;
 392
 393         ret = spi_mem_exec_op(spinand->spimem, &op);
 394         if (ret)
 395                 return ret;
 396
 397         return spinand_wait(spinand, NULL);
 398 }
 399
 400 static int spinand_lock_block(struct spinand_device *spinand, u8 lock)
 401 {
 402         return spinand_write_reg_op(spinand, REG_BLOCK_LOCK, lock);
 403 }
 404
 405 static int spinand_check_ecc_status(struct spinand_device *spinand, u8 status)
 406 {
 407         struct nand_device *nand = spinand_to_nand(spinand);
 408
 409         if (spinand->eccinfo.get_status)
 410                 return spinand->eccinfo.get_status(spinand, status);
 411
 412         switch (status & STATUS_ECC_MASK) {
 413         case STATUS_ECC_NO_BITFLIPS:
 414                 return 0;
 415
 416         case STATUS_ECC_HAS_BITFLIPS:
 417                 /*
 418                  * We have no way to know exactly how many bitflips have been
 419                  * fixed, so let's return the maximum possible value so that
 420                  * wear-leveling layers move the data immediately.
 421                  */
 422                 return nand->eccreq.strength;
 423
 424         case STATUS_ECC_UNCOR_ERROR:
 425                 return -EBADMSG;
 426
 427         default:
 428                 break;
 429         }
 430
 431         return -EINVAL;
 432 }
 433
 434 static int spinand_read_page(struct spinand_device *spinand,
 435                              const struct nand_page_io_req *req,
 436                              bool ecc_enabled)
 437 {
 438         u8 status;
 439         int ret;
 440
 441         ret = spinand_load_page_op(spinand, req);
 442         if (ret)
 443                 return ret;
 444
 445         ret = spinand_wait(spinand, &status);
 446         if (ret < 0)
 447                 return ret;
 448
 449         ret = spinand_read_from_cache_op(spinand, req);
 450         if (ret)
 451                 return ret;
 452
 453         if (!ecc_enabled)
 454                 return 0;
 455
 456         return spinand_check_ecc_status(spinand, status);
 457 }
 458
 459 static int spinand_write_page(struct spinand_device *spinand,
 460                               const struct nand_page_io_req *req)
 461 {
 462         u8 status;
 463         int ret;
 464
 465         ret = spinand_write_enable_op(spinand);
 466         if (ret)
 467                 return ret;
 468
 469         ret = spinand_write_to_cache_op(spinand, req);
 470         if (ret)
 471                 return ret;
 472
 473         ret = spinand_program_op(spinand, req);
 474         if (ret)
 475                 return ret;
 476
 477         ret = spinand_wait(spinand, &status);
 478         if (!ret && (status & STATUS_PROG_FAILED))
 479                 ret = -EIO;
 480
 481         return ret;
 482 }
 483
 484 static int spinand_mtd_read(struct mtd_info *mtd, loff_t from,
 485                             struct mtd_oob_ops *ops)
 486 {
 487         struct spinand_device *spinand = mtd_to_spinand(mtd);
 488         struct nand_device *nand = mtd_to_nanddev(mtd);
 489         unsigned int max_bitflips = 0;
 490         struct nand_io_iter iter;
 491         bool enable_ecc = false;
 492         bool ecc_failed = false;
 493         int ret = 0;
 494
 495         if (ops->mode != MTD_OPS_RAW && spinand->eccinfo.ooblayout)
 496                 enable_ecc = true;
 497
 498         mutex_lock(&spinand->lock);
 499
 500         nanddev_io_for_each_page(nand, from, ops, &iter) {
 501                 ret = spinand_select_target(spinand, iter.req.pos.target);
 502                 if (ret)
 503                         break;
 504
 505                 ret = spinand_ecc_enable(spinand, enable_ecc);
 506                 if (ret)
 507                         break;
 508
 509                 ret = spinand_read_page(spinand, &iter.req, enable_ecc);
 510                 if (ret < 0 && ret != -EBADMSG)
 511                         break;
 512
 513                 if (ret == -EBADMSG) {
 514                         ecc_failed = true;
 515                         mtd->ecc_stats.failed++;
 516                 } else {
 517                         mtd->ecc_stats.corrected += ret;
 518                         max_bitflips = max_t(unsigned int, max_bitflips, ret);
 519                 }
 520
 521                 ret = 0;
 522                 ops->retlen += iter.req.datalen;
 523                 ops->oobretlen += iter.req.ooblen;
 524         }
 525
 526         mutex_unlock(&spinand->lock);
 527
 528         if (ecc_failed && !ret)
 529                 ret = -EBADMSG;
 530
 531         return ret ? ret : max_bitflips;
 532 }
 533
 534 static int spinand_mtd_write(struct mtd_info *mtd, loff_t to,
 535                              struct mtd_oob_ops *ops)
 536 {
 537         struct spinand_device *spinand = mtd_to_spinand(mtd);
 538         struct nand_device *nand = mtd_to_nanddev(mtd);
 539         struct nand_io_iter iter;
 540         bool enable_ecc = false;
 541         int ret = 0;
 542
 543         if (ops->mode != MTD_OPS_RAW && mtd->ooblayout)
 544                 enable_ecc = true;
 545
 546         mutex_lock(&spinand->lock);
 547
 548         nanddev_io_for_each_page(nand, to, ops, &iter) {
 549                 ret = spinand_select_target(spinand, iter.req.pos.target);
 550                 if (ret)
 551                         break;
 552
 553                 ret = spinand_ecc_enable(spinand, enable_ecc);
 554                 if (ret)
 555                         break;
 556
 557                 ret = spinand_write_page(spinand, &iter.req);
 558                 if (ret)
 559                         break;
 560
 561                 ops->retlen += iter.req.datalen;
 562                 ops->oobretlen += iter.req.ooblen;
 563         }
 564
 565         mutex_unlock(&spinand->lock);
 566
 567         return ret;
 568 }
 569
 570 static bool spinand_isbad(struct nand_device *nand, const struct nand_pos *pos)
 571 {
 572         struct spinand_device *spinand = nand_to_spinand(nand);
 573         u8 marker[2] = { };
 574         struct nand_page_io_req req = {
 575                 .pos = *pos,
 576                 .ooblen = sizeof(marker),
 577                 .ooboffs = 0,
 578                 .oobbuf.in = marker,
 579                 .mode = MTD_OPS_RAW,
 580         };
 581
 582         spinand_select_target(spinand, pos->target);
 583         spinand_read_page(spinand, &req, false);
 584         if (marker[0] != 0xff || marker[1] != 0xff)
 585                 return true;
 586
 587         return false;
 588 }
 589
 590 static int spinand_mtd_block_isbad(struct mtd_info *mtd, loff_t offs)
 591 {
 592         struct nand_device *nand = mtd_to_nanddev(mtd);
 593         struct spinand_device *spinand = nand_to_spinand(nand);
 594         struct nand_pos pos;
 595         int ret;
 596
 597         nanddev_offs_to_pos(nand, offs, &pos);
 598         mutex_lock(&spinand->lock);
 599         ret = nanddev_isbad(nand, &pos);
 600         mutex_unlock(&spinand->lock);
 601
 602         return ret;
 603 }
 604
 605 static int spinand_markbad(struct nand_device *nand, const struct nand_pos *pos)
 606 {
 607         struct spinand_device *spinand = nand_to_spinand(nand);
 608         u8 marker[2] = { };
 609         struct nand_page_io_req req = {
 610                 .pos = *pos,
 611                 .ooboffs = 0,
 612                 .ooblen = sizeof(marker),
 613                 .oobbuf.out = marker,
 614                 .mode = MTD_OPS_RAW,
 615         };
 616         int ret;
 617
 618         ret = spinand_select_target(spinand, pos->target);
 619         if (ret)
 620                 return ret;
 621
 622         ret = spinand_write_enable_op(spinand);
 623         if (ret)
 624                 return ret;
 625
 626         return spinand_write_page(spinand, &req);
 627 }
 628
 629 static int spinand_mtd_block_markbad(struct mtd_info *mtd, loff_t offs)
 630 {
 631         struct nand_device *nand = mtd_to_nanddev(mtd);
 632         struct spinand_device *spinand = nand_to_spinand(nand);
 633         struct nand_pos pos;
 634         int ret;
 635
 636         nanddev_offs_to_pos(nand, offs, &pos);
 637         mutex_lock(&spinand->lock);
 638         ret = nanddev_markbad(nand, &pos);
 639         mutex_unlock(&spinand->lock);
 640
 641         return ret;
 642 }
 643
 644 static int spinand_erase(struct nand_device *nand, const struct nand_pos *pos)
 645 {
 646         struct spinand_device *spinand = nand_to_spinand(nand);
 647         u8 status;
 648         int ret;
 649
 650         ret = spinand_select_target(spinand, pos->target);
 651         if (ret)
 652                 return ret;
 653
 654         ret = spinand_write_enable_op(spinand);
 655         if (ret)
 656                 return ret;
 657
 658         ret = spinand_erase_op(spinand, pos);
 659         if (ret)
 660                 return ret;
 661
 662         ret = spinand_wait(spinand, &status);
 663         if (!ret && (status & STATUS_ERASE_FAILED))
 664                 ret = -EIO;
 665
 666         return ret;
 667 }
 668
 669 static int spinand_mtd_erase(struct mtd_info *mtd,
 670                              struct erase_info *einfo)
 671 {
 672         struct spinand_device *spinand = mtd_to_spinand(mtd);
 673         int ret;
 674
 675         mutex_lock(&spinand->lock);
 676         ret = nanddev_mtd_erase(mtd, einfo);
 677         mutex_unlock(&spinand->lock);
 678
 679         return ret;
 680 }
 681
 682 static int spinand_mtd_block_isreserved(struct mtd_info *mtd, loff_t offs)
 683 {
 684         struct spinand_device *spinand = mtd_to_spinand(mtd);
 685         struct nand_device *nand = mtd_to_nanddev(mtd);
 686         struct nand_pos pos;
 687         int ret;
 688
 689         nanddev_offs_to_pos(nand, offs, &pos);
 690         mutex_lock(&spinand->lock);
 691         ret = nanddev_isreserved(nand, &pos);
 692         mutex_unlock(&spinand->lock);
 693
 694         return ret;
 695 }
 696
 697 static int spinand_create_dirmap(struct spinand_device *spinand,
 698                                  unsigned int plane)
 699 {
 700         struct nand_device *nand = spinand_to_nand(spinand);
 701         struct spi_mem_dirmap_info info = {
 702                 .length = nanddev_page_size(nand) +
 703                           nanddev_per_page_oobsize(nand),
 704         };
 705         struct spi_mem_dirmap_desc *desc;
 706
 707         /* The plane number is passed in MSB just above the column address */
 708         info.offset = plane << fls(nand->memorg.pagesize);
 709
 710         info.op_tmpl = *spinand->op_templates.update_cache;
 711         desc = devm_spi_mem_dirmap_create(&spinand->spimem->spi->dev,
 712                                           spinand->spimem, &info);
 713         if (IS_ERR(desc))
 714                 return PTR_ERR(desc);
 715
 716         spinand->dirmaps[plane].wdesc = desc;
 717
 718         info.op_tmpl = *spinand->op_templates.read_cache;
 719         desc = devm_spi_mem_dirmap_create(&spinand->spimem->spi->dev,
 720                                           spinand->spimem, &info);
 721         if (IS_ERR(desc))
 722                 return PTR_ERR(desc);
 723
 724         spinand->dirmaps[plane].rdesc = desc;
 725
 726         return 0;
 727 }
 728
 729 static int spinand_create_dirmaps(struct spinand_device *spinand)
 730 {
 731         struct nand_device *nand = spinand_to_nand(spinand);
 732         int i, ret;
 733
 734         spinand->dirmaps = devm_kzalloc(&spinand->spimem->spi->dev,
 735                                         sizeof(*spinand->dirmaps) *
 736                                         nand->memorg.planes_per_lun,
 737                                         GFP_KERNEL);
 738         if (!spinand->dirmaps)
 739                 return -ENOMEM;
 740
 741         for (i = 0; i < nand->memorg.planes_per_lun; i++) {
 742                 ret = spinand_create_dirmap(spinand, i);
 743                 if (ret)
 744                         return ret;
 745         }
 746
 747         return 0;
 748 }
 749
 750 static const struct nand_ops spinand_ops = {
 751         .erase = spinand_erase,
 752         .markbad = spinand_markbad,
 753         .isbad = spinand_isbad,
 754 };
 755
 756 static const struct spinand_manufacturer *spinand_manufacturers[] = {
 757         &gigadevice_spinand_manufacturer,
 758         &macronix_spinand_manufacturer,
 759         &micron_spinand_manufacturer,
 760         &paragon_spinand_manufacturer,
 761         &toshiba_spinand_manufacturer,
 762         &winbond_spinand_manufacturer,
 763 };
 764
 765 static int spinand_manufacturer_match(struct spinand_device *spinand,
 766                                       enum spinand_readid_method rdid_method)
 767 {
 768         u8 *id = spinand->id.data;
 769         unsigned int i;
 770         int ret;
 771
 772         for (i = 0; i < ARRAY_SIZE(spinand_manufacturers); i++) {
 773                 const struct spinand_manufacturer *manufacturer =
 774                         spinand_manufacturers[i];
 775
 776                 if (id[0] != manufacturer->id)
 777                         continue;
 778
 779                 ret = spinand_match_and_init(spinand,
 780                                              manufacturer->chips,
 781                                              manufacturer->nchips,
 782                                              rdid_method);
 783                 if (ret < 0)
 784                         continue;
 785
 786                 spinand->manufacturer = manufacturer;
 787                 return 0;
 788         }
 789         return -ENOTSUPP;
 790 }
 791
 792 static int spinand_id_detect(struct spinand_device *spinand)
 793 {
 794         u8 *id = spinand->id.data;
 795         int ret;
 796
 797         ret = spinand_read_id_op(spinand, 0, 0, id);
 798         if (ret)
 799                 return ret;
 800         ret = spinand_manufacturer_match(spinand, SPINAND_READID_METHOD_OPCODE);
 801         if (!ret)
 802                 return 0;
 803
 804         ret = spinand_read_id_op(spinand, 1, 0, id);
 805         if (ret)
 806                 return ret;
 807         ret = spinand_manufacturer_match(spinand,
 808                                          SPINAND_READID_METHOD_OPCODE_ADDR);
 809         if (!ret)
 810                 return 0;
 811
 812         ret = spinand_read_id_op(spinand, 0, 1, id);
 813         if (ret)
 814                 return ret;
 815         ret = spinand_manufacturer_match(spinand,
 816                                          SPINAND_READID_METHOD_OPCODE_DUMMY);
 817
 818         return ret;
 819 }
 820
 821 static int spinand_manufacturer_init(struct spinand_device *spinand)
 822 {
 823         if (spinand->manufacturer->ops->init)
 824                 return spinand->manufacturer->ops->init(spinand);
 825
 826         return 0;
 827 }
 828
 829 static void spinand_manufacturer_cleanup(struct spinand_device *spinand)
 830 {
 831         /* Release manufacturer private data */
 832         if (spinand->manufacturer->ops->cleanup)
 833                 return spinand->manufacturer->ops->cleanup(spinand);
 834 }
 835
 836 static const struct spi_mem_op *
 837 spinand_select_op_variant(struct spinand_device *spinand,
 838                           const struct spinand_op_variants *variants)
 839 {
 840         struct nand_device *nand = spinand_to_nand(spinand);
 841         unsigned int i;
 842
 843         for (i = 0; i < variants->nops; i++) {
 844                 struct spi_mem_op op = variants->ops[i];
 845                 unsigned int nbytes;
 846                 int ret;
 847
 848                 nbytes = nanddev_per_page_oobsize(nand) +
 849                          nanddev_page_size(nand);
 850
 851                 while (nbytes) {
 852                         op.data.nbytes = nbytes;
 853                         ret = spi_mem_adjust_op_size(spinand->spimem, &op);
 854                         if (ret)
 855                                 break;
 856
 857                         if (!spi_mem_supports_op(spinand->spimem, &op))
 858                                 break;
 859
 860                         nbytes -= op.data.nbytes;
 861                 }
 862
 863                 if (!nbytes)
 864                         return &variants->ops[i];
 865         }
 866
 867         return NULL;
 868 }
 869
 870 /**
 871  * spinand_match_and_init() - Try to find a match between a device ID and an
 872  *                            entry in a spinand_info table
 873  * @spinand: SPI NAND object
 874  * @table: SPI NAND device description table
 875  * @table_size: size of the device description table
 876  * @rdid_method: read id method to match
 877  *
 878  * Match between a device ID retrieved through the READ_ID command and an
 879  * entry in the SPI NAND description table. If a match is found, the spinand
 880  * object will be initialized with information provided by the matching
 881  * spinand_info entry.
 882  *
 883  * Return: 0 on success, a negative error code otherwise.
 884  */
 885 int spinand_match_and_init(struct spinand_device *spinand,
 886                            const struct spinand_info *table,
 887                            unsigned int table_size,
 888                            enum spinand_readid_method rdid_method)
 889 {
 890         u8 *id = spinand->id.data;
 891         struct nand_device *nand = spinand_to_nand(spinand);
 892         unsigned int i;
 893
 894         for (i = 0; i < table_size; i++) {
 895                 const struct spinand_info *info = &table[i];
 896                 const struct spi_mem_op *op;
 897
 898                 if (rdid_method != info->devid.method)
 899                         continue;
 900
 901                 if (memcmp(id + 1, info->devid.id, info->devid.len))
 902                         continue;
 903
 904                 nand->memorg = table[i].memorg;
 905                 nand->eccreq = table[i].eccreq;
 906                 spinand->eccinfo = table[i].eccinfo;
 907                 spinand->flags = table[i].flags;
 908                 spinand->id.len = 1 + table[i].devid.len;
 909                 spinand->select_target = table[i].select_target;
 910
 911                 op = spinand_select_op_variant(spinand,
 912                                                info->op_variants.read_cache);
 913                 if (!op)
 914                         return -ENOTSUPP;
 915
 916                 spinand->op_templates.read_cache = op;
 917
 918                 op = spinand_select_op_variant(spinand,
 919                                                info->op_variants.write_cache);
 920                 if (!op)
 921                         return -ENOTSUPP;
 922
 923                 spinand->op_templates.write_cache = op;
 924
 925                 op = spinand_select_op_variant(spinand,
 926                                                info->op_variants.update_cache);
 927                 spinand->op_templates.update_cache = op;
 928
 929                 return 0;
 930         }
 931
 932         return -ENOTSUPP;
 933 }
 934
 935 static int spinand_detect(struct spinand_device *spinand)
 936 {
 937         struct device *dev = &spinand->spimem->spi->dev;
 938         struct nand_device *nand = spinand_to_nand(spinand);
 939         int ret;
 940
 941         ret = spinand_reset_op(spinand);
 942         if (ret)
 943                 return ret;
 944
 945         ret = spinand_id_detect(spinand);
 946         if (ret) {
 947                 dev_err(dev, "unknown raw ID %*phN\n", SPINAND_MAX_ID_LEN,
 948                         spinand->id.data);
 949                 return ret;
 950         }
 951
 952         if (nand->memorg.ntargets > 1 && !spinand->select_target) {
 953                 dev_err(dev,
 954                         "SPI NANDs with more than one die must implement ->select_target()\n");
 955                 return -EINVAL;
 956         }
 957
 958         dev_info(&spinand->spimem->spi->dev,
 959                  "%s SPI NAND was found.\n", spinand->manufacturer->name);
 960         dev_info(&spinand->spimem->spi->dev,
 961                  "%llu MiB, block size: %zu KiB, page size: %zu, OOB size: %u\n",
 962                  nanddev_size(nand) >> 20, nanddev_eraseblock_size(nand) >> 10,
 963                  nanddev_page_size(nand), nanddev_per_page_oobsize(nand));
 964
 965         return 0;
 966 }
 967
 968 static int spinand_noecc_ooblayout_ecc(struct mtd_info *mtd, int section,
 969                                        struct mtd_oob_region *region)
 970 {
 971         return -ERANGE;
 972 }
 973
 974 static int spinand_noecc_ooblayout_free(struct mtd_info *mtd, int section,
 975                                         struct mtd_oob_region *region)
 976 {
 977         if (section)
 978                 return -ERANGE;
 979
 980         /* Reserve 2 bytes for the BBM. */
 981         region->offset = 2;
 982         region->length = 62;
 983
 984         return 0;
 985 }
 986
 987 static const struct mtd_ooblayout_ops spinand_noecc_ooblayout = {
 988         .ecc = spinand_noecc_ooblayout_ecc,
 989         .free = spinand_noecc_ooblayout_free,
 990 };
 991
 992 static int spinand_init(struct spinand_device *spinand)
 993 {
 994         struct device *dev = &spinand->spimem->spi->dev;
 995         struct mtd_info *mtd = spinand_to_mtd(spinand);
 996         struct nand_device *nand = mtd_to_nanddev(mtd);
 997         int ret, i;
 998
 999         /*
1000          * We need a scratch buffer because the spi_mem interface requires that
1001          * buf passed in spi_mem_op->data.buf be DMA-able.
1002          */
1003         spinand->scratchbuf = kzalloc(SPINAND_MAX_ID_LEN, GFP_KERNEL);
1004         if (!spinand->scratchbuf)
1005                 return -ENOMEM;
1006
1007         ret = spinand_detect(spinand);
1008         if (ret)
1009                 goto err_free_bufs;
1010
1011         /*
1012          * Use kzalloc() instead of devm_kzalloc() here, because some drivers
1013          * may use this buffer for DMA access.
1014          * Memory allocated by devm_ does not guarantee DMA-safe alignment.
1015          */
1016         spinand->databuf = kzalloc(nanddev_page_size(nand) +
1017                                nanddev_per_page_oobsize(nand),
1018                                GFP_KERNEL);
1019         if (!spinand->databuf) {
1020                 ret = -ENOMEM;
1021                 goto err_free_bufs;
1022         }
1023
1024         spinand->oobbuf = spinand->databuf + nanddev_page_size(nand);
1025
1026         ret = spinand_init_cfg_cache(spinand);
1027         if (ret)
1028                 goto err_free_bufs;
1029
1030         ret = spinand_init_quad_enable(spinand);
1031         if (ret)
1032                 goto err_free_bufs;
1033
1034         ret = spinand_upd_cfg(spinand, CFG_OTP_ENABLE, 0);
1035         if (ret)
1036                 goto err_free_bufs;
1037
1038         ret = spinand_manufacturer_init(spinand);
1039         if (ret) {
1040                 dev_err(dev,
1041                         "Failed to initialize the SPI NAND chip (err = %d)\n",
1042                         ret);
1043                 goto err_free_bufs;
1044         }
1045
1046         ret = spinand_create_dirmaps(spinand);
1047         if (ret) {
1048                 dev_err(dev,
1049                         "Failed to create direct mappings for read/write operations (err = %d)\n",
1050                         ret);
1051                 goto err_manuf_cleanup;
1052         }
1053
1054         /* After power up, all blocks are locked, so unlock them here. */
1055         for (i = 0; i < nand->memorg.ntargets; i++) {
1056                 ret = spinand_select_target(spinand, i);
1057                 if (ret)
1058                         goto err_manuf_cleanup;
1059
1060                 ret = spinand_lock_block(spinand, BL_ALL_UNLOCKED);
1061                 if (ret)
1062                         goto err_manuf_cleanup;
1063         }
1064
1065         ret = nanddev_init(nand, &spinand_ops, THIS_MODULE);
1066         if (ret)
1067                 goto err_manuf_cleanup;
1068
1069         /*
1070          * Right now, we don't support ECC, so let the whole oob
1071          * area is available for user.
1072          */
1073         mtd->_read_oob = spinand_mtd_read;
1074         mtd->_write_oob = spinand_mtd_write;
1075         mtd->_block_isbad = spinand_mtd_block_isbad;
1076         mtd->_block_markbad = spinand_mtd_block_markbad;
1077         mtd->_block_isreserved = spinand_mtd_block_isreserved;
1078         mtd->_erase = spinand_mtd_erase;
1079         mtd->_max_bad_blocks = nanddev_mtd_max_bad_blocks;
1080
1081         if (spinand->eccinfo.ooblayout)
1082                 mtd_set_ooblayout(mtd, spinand->eccinfo.ooblayout);
1083         else
1084                 mtd_set_ooblayout(mtd, &spinand_noecc_ooblayout);
1085
1086         ret = mtd_ooblayout_count_freebytes(mtd);
1087         if (ret < 0)
1088                 goto err_cleanup_nanddev;
1089
1090         mtd->oobavail = ret;
1091
1092         return 0;
1093
1094 err_cleanup_nanddev:
1095         nanddev_cleanup(nand);
1096
1097 err_manuf_cleanup:
1098         spinand_manufacturer_cleanup(spinand);
1099
1100 err_free_bufs:
1101         kfree(spinand->databuf);
1102         kfree(spinand->scratchbuf);
1103         return ret;
1104 }
1105
1106 static void spinand_cleanup(struct spinand_device *spinand)
1107 {
1108         struct nand_device *nand = spinand_to_nand(spinand);
1109
1110         nanddev_cleanup(nand);
1111         spinand_manufacturer_cleanup(spinand);
1112         kfree(spinand->databuf);
1113         kfree(spinand->scratchbuf);
1114 }
1115
1116 static int spinand_probe(struct spi_mem *mem)
1117 {
1118         struct spinand_device *spinand;
1119         struct mtd_info *mtd;
1120         int ret;
1121
1122         spinand = devm_kzalloc(&mem->spi->dev, sizeof(*spinand),
1123                                GFP_KERNEL);
1124         if (!spinand)
1125                 return -ENOMEM;
1126
1127         spinand->spimem = mem;
1128         spi_mem_set_drvdata(mem, spinand);
1129         spinand_set_of_node(spinand, mem->spi->dev.of_node);
1130         mutex_init(&spinand->lock);
1131         mtd = spinand_to_mtd(spinand);
1132         mtd->dev.parent = &mem->spi->dev;
1133
1134         ret = spinand_init(spinand);
1135         if (ret)
1136                 return ret;
1137
1138         ret = mtd_device_register(mtd, NULL, 0);
1139         if (ret)
1140                 goto err_spinand_cleanup;
1141
1142         return 0;
1143
1144 err_spinand_cleanup:
1145         spinand_cleanup(spinand);
1146
1147         return ret;
1148 }
1149
1150 static int spinand_remove(struct spi_mem *mem)
1151 {
1152         struct spinand_device *spinand;
1153         struct mtd_info *mtd;
1154         int ret;
1155
1156         spinand = spi_mem_get_drvdata(mem);
1157         mtd = spinand_to_mtd(spinand);
1158
1159         ret = mtd_device_unregister(mtd);
1160         if (ret)
1161                 return ret;
1162
1163         spinand_cleanup(spinand);
1164
1165         return 0;
1166 }
1167
1168 static const struct spi_device_id spinand_ids[] = {
1169         { .name = "spi-nand" },
1170         { /* sentinel */ },
1171 };
1172
1173 #ifdef CONFIG_OF
1174 static const struct of_device_id spinand_of_ids[] = {
1175         { .compatible = "spi-nand" },
1176         { /* sentinel */ },
1177 };
1178 #endif
1179
1180 static struct spi_mem_driver spinand_drv = {
1181         .spidrv = {
1182                 .id_table = spinand_ids,
1183                 .driver = {
1184                         .name = "spi-nand",
1185                         .of_match_table = of_match_ptr(spinand_of_ids),
1186                 },
1187         },
1188         .probe = spinand_probe,
1189         .remove = spinand_remove,
1190 };
1191 module_spi_mem_driver(spinand_drv);
1192
1193 MODULE_DESCRIPTION("SPI NAND framework");
1194 MODULE_AUTHOR("Peter Pan<peterpandong@micron.com>");
1195 MODULE_LICENSE("GPL v2");