drivers/mtd/nand/spi/micron.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  */
   8
   9 #ifndef __UBOOT__
  10 #include <malloc.h>
  11 #include <linux/device.h>
  12 #include <linux/kernel.h>
  13 #endif
  14 #include <linux/bitops.h>
  15 #include <linux/mtd/spinand.h>
  16
  17 #define SPINAND_MFR_MICRON              0x2c
  18
  19 #define MICRON_STATUS_ECC_MASK          GENMASK(7, 4)
  20 #define MICRON_STATUS_ECC_NO_BITFLIPS   (0 << 4)
  21 #define MICRON_STATUS_ECC_1TO3_BITFLIPS (1 << 4)
  22 #define MICRON_STATUS_ECC_4TO6_BITFLIPS (3 << 4)
  23 #define MICRON_STATUS_ECC_7TO8_BITFLIPS (5 << 4)
  24
  25 static SPINAND_OP_VARIANTS(read_cache_variants,
  26                 SPINAND_PAGE_READ_FROM_CACHE_QUADIO_OP(0, 2, NULL, 0),
  27                 SPINAND_PAGE_READ_FROM_CACHE_X4_OP(0, 1, NULL, 0),
  28                 SPINAND_PAGE_READ_FROM_CACHE_DUALIO_OP(0, 1, NULL, 0),
  29                 SPINAND_PAGE_READ_FROM_CACHE_X2_OP(0, 1, NULL, 0),
  30                 SPINAND_PAGE_READ_FROM_CACHE_OP(true, 0, 1, NULL, 0),
  31                 SPINAND_PAGE_READ_FROM_CACHE_OP(false, 0, 1, NULL, 0));
  32
  33 static SPINAND_OP_VARIANTS(write_cache_variants,
  34                 SPINAND_PROG_LOAD_X4(true, 0, NULL, 0),
  35                 SPINAND_PROG_LOAD(true, 0, NULL, 0));
  36
  37 static SPINAND_OP_VARIANTS(update_cache_variants,
  38                 SPINAND_PROG_LOAD_X4(false, 0, NULL, 0),
  39                 SPINAND_PROG_LOAD(false, 0, NULL, 0));
  40
  41 static int mt29f2g01abagd_ooblayout_ecc(struct mtd_info *mtd, int section,
  42                                         struct mtd_oob_region *region)
  43 {
  44         if (section)
  45                 return -ERANGE;
  46
  47         region->offset = 64;
  48         region->length = 64;
  49
  50         return 0;
  51 }
  52
  53 static int mt29f2g01abagd_ooblayout_free(struct mtd_info *mtd, int section,
  54                                          struct mtd_oob_region *region)
  55 {
  56         if (section)
  57                 return -ERANGE;
  58
  59         /* Reserve 2 bytes for the BBM. */
  60         region->offset = 2;
  61         region->length = 62;
  62
  63         return 0;
  64 }
  65
  66 static const struct mtd_ooblayout_ops mt29f2g01abagd_ooblayout = {
  67         .ecc = mt29f2g01abagd_ooblayout_ecc,
  68         .rfree = mt29f2g01abagd_ooblayout_free,
  69 };
  70
  71 static int mt29f2g01abagd_ecc_get_status(struct spinand_device *spinand,
  72                                          u8 status)
  73 {
  74         switch (status & MICRON_STATUS_ECC_MASK) {
  75         case STATUS_ECC_NO_BITFLIPS:
  76                 return 0;
  77
  78         case STATUS_ECC_UNCOR_ERROR:
  79                 return -EBADMSG;
  80
  81         case MICRON_STATUS_ECC_1TO3_BITFLIPS:
  82                 return 3;
  83
  84         case MICRON_STATUS_ECC_4TO6_BITFLIPS:
  85                 return 6;
  86
  87         case MICRON_STATUS_ECC_7TO8_BITFLIPS:
  88                 return 8;
  89
  90         default:
  91                 break;
  92         }
  93
  94         return -EINVAL;
  95 }
  96
  97 static const struct spinand_info micron_spinand_table[] = {
  98         SPINAND_INFO("MT29F2G01ABAGD", 0x24,
  99                      NAND_MEMORG(1, 2048, 128, 64, 2048, 2, 1, 1),
 100                      NAND_ECCREQ(8, 512),
 101                      SPINAND_INFO_OP_VARIANTS(&read_cache_variants,
 102                                               &write_cache_variants,
 103                                               &update_cache_variants),
 104                      0,
 105                      SPINAND_ECCINFO(&mt29f2g01abagd_ooblayout,
 106                                      mt29f2g01abagd_ecc_get_status)),
 107 };
 108
 109 static int micron_spinand_detect(struct spinand_device *spinand)
 110 {
 111         u8 *id = spinand->id.data;
 112         int ret;
 113
 114         /*
 115          * Micron SPI NAND read ID need a dummy byte,
 116          * so the first byte in raw_id is dummy.
 117          */
 118         if (id[1] != SPINAND_MFR_MICRON)
 119                 return 0;
 120
 121         ret = spinand_match_and_init(spinand, micron_spinand_table,
 122                                      ARRAY_SIZE(micron_spinand_table), id[2]);
 123         if (ret)
 124                 return ret;
 125
 126         return 1;
 127 }
 128
 129 static const struct spinand_manufacturer_ops micron_spinand_manuf_ops = {
 130         .detect = micron_spinand_detect,
 131 };
 132
 133 const struct spinand_manufacturer micron_spinand_manufacturer = {
 134         .id = SPINAND_MFR_MICRON,
 135         .name = "Micron",
 136         .ops = &micron_spinand_manuf_ops,
 137 };