1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com) 4 * 2002-2006 Thomas Gleixner (tglx@linutronix.de) 5 * 6 * Credits: 7 * David Woodhouse for adding multichip support 8 * 9 * Aleph One Ltd. and Toby Churchill Ltd. for supporting the 10 * rework for 2K page size chips 11 * 12 * This file contains all ONFI helpers. 13 */ 14 15 #include <linux/slab.h> 16 17 #include "internals.h" 18 19 #define ONFI_PARAM_PAGES 3 20 21 u16 onfi_crc16(u16 crc, u8 const *p, size_t len) 22 { 23 int i; 24 while (len--) { 25 crc ^= *p++ << 8; 26 for (i = 0; i < 8; i++) 27 crc = (crc << 1) ^ ((crc & 0x8000) ? 0x8005 : 0); 28 } 29 30 return crc; 31 } 32 33 /* Parse the Extended Parameter Page. */ 34 static int nand_flash_detect_ext_param_page(struct nand_chip *chip, 35 struct nand_onfi_params *p) 36 { 37 struct nand_device *base = &chip->base; 38 struct nand_ecc_props requirements; 39 struct onfi_ext_param_page *ep; 40 struct onfi_ext_section *s; 41 struct onfi_ext_ecc_info *ecc; 42 uint8_t *cursor; 43 int ret; 44 int len; 45 int i; 46 47 len = le16_to_cpu(p->ext_param_page_length) * 16; 48 ep = kmalloc(len, GFP_KERNEL); 49 if (!ep) 50 return -ENOMEM; 51 52 /* 53 * Use the Change Read Column command to skip the ONFI param pages and 54 * ensure we read at the right location. 55 */ 56 ret = nand_change_read_column_op(chip, 57 sizeof(*p) * p->num_of_param_pages, 58 ep, len, true); 59 if (ret) 60 goto ext_out; 61 62 ret = -EINVAL; 63 if ((onfi_crc16(ONFI_CRC_BASE, ((uint8_t *)ep) + 2, len - 2) 64 != le16_to_cpu(ep->crc))) { 65 pr_debug("fail in the CRC.\n"); 66 goto ext_out; 67 } 68 69 /* 70 * Check the signature. 71 * Do not strictly follow the ONFI spec, maybe changed in future. 72 */ 73 if (strncmp(ep->sig, "EPPS", 4)) { 74 pr_debug("The signature is invalid.\n"); 75 goto ext_out; 76 } 77 78 /* find the ECC section. */ 79 cursor = (uint8_t *)(ep + 1); 80 for (i = 0; i < ONFI_EXT_SECTION_MAX; i++) { 81 s = ep->sections + i; 82 if (s->type == ONFI_SECTION_TYPE_2) 83 break; 84 cursor += s->length * 16; 85 } 86 if (i == ONFI_EXT_SECTION_MAX) { 87 pr_debug("We can not find the ECC section.\n"); 88 goto ext_out; 89 } 90 91 /* get the info we want. */ 92 ecc = (struct onfi_ext_ecc_info *)cursor; 93 94 if (!ecc->codeword_size) { 95 pr_debug("Invalid codeword size\n"); 96 goto ext_out; 97 } 98 99 requirements.strength = ecc->ecc_bits; 100 requirements.step_size = 1 << ecc->codeword_size; 101 nanddev_set_ecc_requirements(base, &requirements); 102 103 ret = 0; 104 105 ext_out: 106 kfree(ep); 107 return ret; 108 } 109 110 /* 111 * Recover data with bit-wise majority 112 */ 113 static void nand_bit_wise_majority(const void **srcbufs, 114 unsigned int nsrcbufs, 115 void *dstbuf, 116 unsigned int bufsize) 117 { 118 int i, j, k; 119 120 for (i = 0; i < bufsize; i++) { 121 u8 val = 0; 122 123 for (j = 0; j < 8; j++) { 124 unsigned int cnt = 0; 125 126 for (k = 0; k < nsrcbufs; k++) { 127 const u8 *srcbuf = srcbufs[k]; 128 129 if (srcbuf[i] & BIT(j)) 130 cnt++; 131 } 132 133 if (cnt > nsrcbufs / 2) 134 val |= BIT(j); 135 } 136 137 ((u8 *)dstbuf)[i] = val; 138 } 139 } 140 141 /* 142 * Check if the NAND chip is ONFI compliant, returns 1 if it is, 0 otherwise. 143 */ 144 int nand_onfi_detect(struct nand_chip *chip) 145 { 146 struct nand_device *base = &chip->base; 147 struct mtd_info *mtd = nand_to_mtd(chip); 148 struct nand_memory_organization *memorg; 149 struct nand_onfi_params *p = NULL, *pbuf; 150 struct onfi_params *onfi; 151 bool use_datain = false; 152 int onfi_version = 0; 153 char id[4]; 154 int i, ret, val; 155 u16 crc; 156 157 memorg = nanddev_get_memorg(&chip->base); 158 159 /* Try ONFI for unknown chip or LP */ 160 ret = nand_readid_op(chip, 0x20, id, sizeof(id)); 161 if (ret || strncmp(id, "ONFI", 4)) 162 return 0; 163 164 /* ONFI chip: allocate a buffer to hold its parameter page */ 165 pbuf = kzalloc((sizeof(*pbuf) * ONFI_PARAM_PAGES), GFP_KERNEL); 166 if (!pbuf) 167 return -ENOMEM; 168 169 if (!nand_has_exec_op(chip) || 170 !nand_read_data_op(chip, &pbuf[0], sizeof(*pbuf), true, true)) 171 use_datain = true; 172 173 for (i = 0; i < ONFI_PARAM_PAGES; i++) { 174 if (!i) 175 ret = nand_read_param_page_op(chip, 0, &pbuf[i], 176 sizeof(*pbuf)); 177 else if (use_datain) 178 ret = nand_read_data_op(chip, &pbuf[i], sizeof(*pbuf), 179 true, false); 180 else 181 ret = nand_change_read_column_op(chip, sizeof(*pbuf) * i, 182 &pbuf[i], sizeof(*pbuf), 183 true); 184 if (ret) { 185 ret = 0; 186 goto free_onfi_param_page; 187 } 188 189 crc = onfi_crc16(ONFI_CRC_BASE, (u8 *)&pbuf[i], 254); 190 if (crc == le16_to_cpu(pbuf[i].crc)) { 191 p = &pbuf[i]; 192 break; 193 } 194 } 195 196 if (i == ONFI_PARAM_PAGES) { 197 const void *srcbufs[ONFI_PARAM_PAGES]; 198 unsigned int j; 199 200 for (j = 0; j < ONFI_PARAM_PAGES; j++) 201 srcbufs[j] = pbuf + j; 202 203 pr_warn("Could not find a valid ONFI parameter page, trying bit-wise majority to recover it\n"); 204 nand_bit_wise_majority(srcbufs, ONFI_PARAM_PAGES, pbuf, 205 sizeof(*pbuf)); 206 207 crc = onfi_crc16(ONFI_CRC_BASE, (u8 *)pbuf, 254); 208 if (crc != le16_to_cpu(pbuf->crc)) { 209 pr_err("ONFI parameter recovery failed, aborting\n"); 210 goto free_onfi_param_page; 211 } 212 p = pbuf; 213 } 214 215 if (chip->manufacturer.desc && chip->manufacturer.desc->ops && 216 chip->manufacturer.desc->ops->fixup_onfi_param_page) 217 chip->manufacturer.desc->ops->fixup_onfi_param_page(chip, p); 218 219 /* Check version */ 220 val = le16_to_cpu(p->revision); 221 if (val & ONFI_VERSION_2_3) 222 onfi_version = 23; 223 else if (val & ONFI_VERSION_2_2) 224 onfi_version = 22; 225 else if (val & ONFI_VERSION_2_1) 226 onfi_version = 21; 227 else if (val & ONFI_VERSION_2_0) 228 onfi_version = 20; 229 else if (val & ONFI_VERSION_1_0) 230 onfi_version = 10; 231 232 if (!onfi_version) { 233 pr_info("unsupported ONFI version: %d\n", val); 234 goto free_onfi_param_page; 235 } 236 237 sanitize_string(p->manufacturer, sizeof(p->manufacturer)); 238 sanitize_string(p->model, sizeof(p->model)); 239 chip->parameters.model = kstrdup(p->model, GFP_KERNEL); 240 if (!chip->parameters.model) { 241 ret = -ENOMEM; 242 goto free_onfi_param_page; 243 } 244 245 memorg->pagesize = le32_to_cpu(p->byte_per_page); 246 mtd->writesize = memorg->pagesize; 247 248 /* 249 * pages_per_block and blocks_per_lun may not be a power-of-2 size 250 * (don't ask me who thought of this...). MTD assumes that these 251 * dimensions will be power-of-2, so just truncate the remaining area. 252 */ 253 memorg->pages_per_eraseblock = 254 1 << (fls(le32_to_cpu(p->pages_per_block)) - 1); 255 mtd->erasesize = memorg->pages_per_eraseblock * memorg->pagesize; 256 257 memorg->oobsize = le16_to_cpu(p->spare_bytes_per_page); 258 mtd->oobsize = memorg->oobsize; 259 260 memorg->luns_per_target = p->lun_count; 261 memorg->planes_per_lun = 1 << p->interleaved_bits; 262 263 /* See erasesize comment */ 264 memorg->eraseblocks_per_lun = 265 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1); 266 memorg->max_bad_eraseblocks_per_lun = le32_to_cpu(p->blocks_per_lun); 267 memorg->bits_per_cell = p->bits_per_cell; 268 269 if (le16_to_cpu(p->features) & ONFI_FEATURE_16_BIT_BUS) 270 chip->options |= NAND_BUSWIDTH_16; 271 272 if (p->ecc_bits != 0xff) { 273 struct nand_ecc_props requirements = { 274 .strength = p->ecc_bits, 275 .step_size = 512, 276 }; 277 278 nanddev_set_ecc_requirements(base, &requirements); 279 } else if (onfi_version >= 21 && 280 (le16_to_cpu(p->features) & ONFI_FEATURE_EXT_PARAM_PAGE)) { 281 282 /* 283 * The nand_flash_detect_ext_param_page() uses the 284 * Change Read Column command which maybe not supported 285 * by the chip->legacy.cmdfunc. So try to update the 286 * chip->legacy.cmdfunc now. We do not replace user supplied 287 * command function. 288 */ 289 nand_legacy_adjust_cmdfunc(chip); 290 291 /* The Extended Parameter Page is supported since ONFI 2.1. */ 292 if (nand_flash_detect_ext_param_page(chip, p)) 293 pr_warn("Failed to detect ONFI extended param page\n"); 294 } else { 295 pr_warn("Could not retrieve ONFI ECC requirements\n"); 296 } 297 298 /* Save some parameters from the parameter page for future use */ 299 if (le16_to_cpu(p->opt_cmd) & ONFI_OPT_CMD_SET_GET_FEATURES) { 300 chip->parameters.supports_set_get_features = true; 301 bitmap_set(chip->parameters.get_feature_list, 302 ONFI_FEATURE_ADDR_TIMING_MODE, 1); 303 bitmap_set(chip->parameters.set_feature_list, 304 ONFI_FEATURE_ADDR_TIMING_MODE, 1); 305 } 306 307 onfi = kzalloc(sizeof(*onfi), GFP_KERNEL); 308 if (!onfi) { 309 ret = -ENOMEM; 310 goto free_model; 311 } 312 313 onfi->version = onfi_version; 314 onfi->tPROG = le16_to_cpu(p->t_prog); 315 onfi->tBERS = le16_to_cpu(p->t_bers); 316 onfi->tR = le16_to_cpu(p->t_r); 317 onfi->tCCS = le16_to_cpu(p->t_ccs); 318 onfi->async_timing_mode = le16_to_cpu(p->async_timing_mode); 319 onfi->vendor_revision = le16_to_cpu(p->vendor_revision); 320 memcpy(onfi->vendor, p->vendor, sizeof(p->vendor)); 321 chip->parameters.onfi = onfi; 322 323 /* Identification done, free the full ONFI parameter page and exit */ 324 kfree(pbuf); 325 326 return 1; 327 328 free_model: 329 kfree(chip->parameters.model); 330 free_onfi_param_page: 331 kfree(pbuf); 332 333 return ret; 334 } 335