root/drivers/mtd/nand/spi/micron.c

DEFINITIONS

1. mt29f2g01abagd_ooblayout_ecc
2. mt29f2g01abagd_ooblayout_free
3. mt29f2g01abagd_ecc_get_status
4. micron_spinand_detect

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