2019-05-27 14:55:06 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2016-06-08 16:30:18 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2017 Free Electrons
|
|
|
|
* Copyright (C) 2017 NextThing Co
|
|
|
|
*
|
|
|
|
* Author: Boris Brezillon <boris.brezillon@free-electrons.com>
|
|
|
|
*/
|
|
|
|
|
2016-05-27 20:36:36 +08:00
|
|
|
#include <linux/sizes.h>
|
2016-05-27 16:15:03 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
|
2018-09-07 06:38:48 +08:00
|
|
|
#include "internals.h"
|
|
|
|
|
2016-05-27 16:15:03 +08:00
|
|
|
#define NAND_HYNIX_CMD_SET_PARAMS 0x36
|
|
|
|
#define NAND_HYNIX_CMD_APPLY_PARAMS 0x16
|
|
|
|
|
|
|
|
#define NAND_HYNIX_1XNM_RR_REPEAT 8
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct hynix_read_retry - read-retry data
|
|
|
|
* @nregs: number of register to set when applying a new read-retry mode
|
|
|
|
* @regs: register offsets (NAND chip dependent)
|
|
|
|
* @values: array of values to set in registers. The array size is equal to
|
|
|
|
* (nregs * nmodes)
|
|
|
|
*/
|
|
|
|
struct hynix_read_retry {
|
|
|
|
int nregs;
|
|
|
|
const u8 *regs;
|
2020-02-27 06:27:22 +08:00
|
|
|
u8 values[];
|
2016-05-27 16:15:03 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct hynix_nand - private Hynix NAND struct
|
|
|
|
* @nand_technology: manufacturing process expressed in picometer
|
|
|
|
* @read_retry: read-retry information
|
|
|
|
*/
|
|
|
|
struct hynix_nand {
|
|
|
|
const struct hynix_read_retry *read_retry;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct hynix_read_retry_otp - structure describing how the read-retry OTP
|
|
|
|
* area
|
|
|
|
* @nregs: number of hynix private registers to set before reading the reading
|
|
|
|
* the OTP area
|
|
|
|
* @regs: registers that should be configured
|
|
|
|
* @values: values that should be set in regs
|
|
|
|
* @page: the address to pass to the READ_PAGE command. Depends on the NAND
|
|
|
|
* chip
|
|
|
|
* @size: size of the read-retry OTP section
|
|
|
|
*/
|
|
|
|
struct hynix_read_retry_otp {
|
|
|
|
int nregs;
|
|
|
|
const u8 *regs;
|
|
|
|
const u8 *values;
|
|
|
|
int page;
|
|
|
|
int size;
|
|
|
|
};
|
2016-06-08 16:30:18 +08:00
|
|
|
|
2016-05-27 20:36:36 +08:00
|
|
|
static bool hynix_nand_has_valid_jedecid(struct nand_chip *chip)
|
2017-12-01 01:01:29 +08:00
|
|
|
{
|
|
|
|
u8 jedecid[5] = { };
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = nand_readid_op(chip, 0x40, jedecid, sizeof(jedecid));
|
|
|
|
if (ret)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return !strncmp("JEDEC", jedecid, sizeof(jedecid));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hynix_nand_cmd_op(struct nand_chip *chip, u8 cmd)
|
|
|
|
{
|
2018-11-11 15:55:23 +08:00
|
|
|
if (nand_has_exec_op(chip)) {
|
2017-11-09 21:16:45 +08:00
|
|
|
struct nand_op_instr instrs[] = {
|
|
|
|
NAND_OP_CMD(cmd, 0),
|
|
|
|
};
|
2018-11-11 15:55:15 +08:00
|
|
|
struct nand_operation op = NAND_OPERATION(chip->cur_cs, instrs);
|
2017-11-09 21:16:45 +08:00
|
|
|
|
|
|
|
return nand_exec_op(chip, &op);
|
|
|
|
}
|
|
|
|
|
2018-09-07 06:38:36 +08:00
|
|
|
chip->legacy.cmdfunc(chip, cmd, -1, -1);
|
2017-12-01 01:01:29 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hynix_nand_reg_write_op(struct nand_chip *chip, u8 addr, u8 val)
|
2016-06-08 16:30:18 +08:00
|
|
|
{
|
2017-12-01 01:01:29 +08:00
|
|
|
u16 column = ((u16)addr << 8) | addr;
|
2016-05-27 20:36:36 +08:00
|
|
|
|
2018-11-11 15:55:23 +08:00
|
|
|
if (nand_has_exec_op(chip)) {
|
2018-07-04 22:08:58 +08:00
|
|
|
struct nand_op_instr instrs[] = {
|
|
|
|
NAND_OP_ADDR(1, &addr, 0),
|
|
|
|
NAND_OP_8BIT_DATA_OUT(1, &val, 0),
|
|
|
|
};
|
2018-11-11 15:55:15 +08:00
|
|
|
struct nand_operation op = NAND_OPERATION(chip->cur_cs, instrs);
|
2018-07-04 22:08:58 +08:00
|
|
|
|
|
|
|
return nand_exec_op(chip, &op);
|
|
|
|
}
|
|
|
|
|
2018-09-07 06:38:36 +08:00
|
|
|
chip->legacy.cmdfunc(chip, NAND_CMD_NONE, column, -1);
|
2018-09-07 06:38:35 +08:00
|
|
|
chip->legacy.write_byte(chip, val);
|
2016-06-08 16:30:18 +08:00
|
|
|
|
2017-12-01 01:01:29 +08:00
|
|
|
return 0;
|
2016-05-27 20:36:36 +08:00
|
|
|
}
|
2016-06-08 16:30:18 +08:00
|
|
|
|
2018-09-06 20:05:32 +08:00
|
|
|
static int hynix_nand_setup_read_retry(struct nand_chip *chip, int retry_mode)
|
2016-05-27 16:15:03 +08:00
|
|
|
{
|
|
|
|
struct hynix_nand *hynix = nand_get_manufacturer_data(chip);
|
|
|
|
const u8 *values;
|
2017-12-01 01:01:29 +08:00
|
|
|
int i, ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
|
|
|
values = hynix->read_retry->values +
|
|
|
|
(retry_mode * hynix->read_retry->nregs);
|
|
|
|
|
|
|
|
/* Enter 'Set Hynix Parameters' mode */
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_SET_PARAMS);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Configure the NAND in the requested read-retry mode.
|
|
|
|
* This is done by setting pre-defined values in internal NAND
|
|
|
|
* registers.
|
|
|
|
*
|
|
|
|
* The set of registers is NAND specific, and the values are either
|
|
|
|
* predefined or extracted from an OTP area on the NAND (values are
|
|
|
|
* probably tweaked at production in this case).
|
|
|
|
*/
|
|
|
|
for (i = 0; i < hynix->read_retry->nregs; i++) {
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = hynix_nand_reg_write_op(chip, hynix->read_retry->regs[i],
|
|
|
|
values[i]);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Apply the new settings. */
|
2017-12-01 01:01:29 +08:00
|
|
|
return hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_APPLY_PARAMS);
|
2016-05-27 16:15:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* hynix_get_majority - get the value that is occurring the most in a given
|
|
|
|
* set of values
|
|
|
|
* @in: the array of values to test
|
|
|
|
* @repeat: the size of the in array
|
|
|
|
* @out: pointer used to store the output value
|
|
|
|
*
|
|
|
|
* This function implements the 'majority check' logic that is supposed to
|
|
|
|
* overcome the unreliability of MLC NANDs when reading the OTP area storing
|
|
|
|
* the read-retry parameters.
|
|
|
|
*
|
|
|
|
* It's based on a pretty simple assumption: if we repeat the same value
|
|
|
|
* several times and then take the one that is occurring the most, we should
|
|
|
|
* find the correct value.
|
|
|
|
* Let's hope this dummy algorithm prevents us from losing the read-retry
|
|
|
|
* parameters.
|
|
|
|
*/
|
|
|
|
static int hynix_get_majority(const u8 *in, int repeat, u8 *out)
|
|
|
|
{
|
|
|
|
int i, j, half = repeat / 2;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only test the first half of the in array because we must ensure
|
|
|
|
* that the value is at least occurring repeat / 2 times.
|
|
|
|
*
|
|
|
|
* This loop is suboptimal since we may count the occurrences of the
|
|
|
|
* same value several time, but we are doing that on small sets, which
|
|
|
|
* makes it acceptable.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < half; i++) {
|
|
|
|
int cnt = 0;
|
|
|
|
u8 val = in[i];
|
|
|
|
|
|
|
|
/* Count all values that are matching the one at index i. */
|
|
|
|
for (j = i + 1; j < repeat; j++) {
|
|
|
|
if (in[j] == val)
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We found a value occurring more than repeat / 2. */
|
|
|
|
if (cnt > half) {
|
|
|
|
*out = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hynix_read_rr_otp(struct nand_chip *chip,
|
|
|
|
const struct hynix_read_retry_otp *info,
|
|
|
|
void *buf)
|
|
|
|
{
|
2017-12-01 01:01:29 +08:00
|
|
|
int i, ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = nand_reset_op(chip);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_SET_PARAMS);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
|
|
|
for (i = 0; i < info->nregs; i++) {
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = hynix_nand_reg_write_op(chip, info->regs[i],
|
|
|
|
info->values[i]);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
}
|
|
|
|
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_APPLY_PARAMS);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
|
|
|
/* Sequence to enter OTP mode? */
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = hynix_nand_cmd_op(chip, 0x17);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = hynix_nand_cmd_op(chip, 0x4);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = hynix_nand_cmd_op(chip, 0x19);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
|
|
|
/* Now read the page */
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = nand_read_page_op(chip, info->page, 0, buf, info->size);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
|
|
|
/* Put everything back to normal */
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = nand_reset_op(chip);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-05-27 16:15:03 +08:00
|
|
|
|
2017-12-01 01:01:29 +08:00
|
|
|
ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_SET_PARAMS);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = hynix_nand_reg_write_op(chip, 0x38, 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_APPLY_PARAMS);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return nand_read_page_op(chip, 0, 0, NULL, 0);
|
2016-05-27 16:15:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define NAND_HYNIX_1XNM_RR_COUNT_OFFS 0
|
|
|
|
#define NAND_HYNIX_1XNM_RR_REG_COUNT_OFFS 8
|
|
|
|
#define NAND_HYNIX_1XNM_RR_SET_OFFS(x, setsize, inv) \
|
|
|
|
(16 + ((((x) * 2) + ((inv) ? 1 : 0)) * (setsize)))
|
|
|
|
|
|
|
|
static int hynix_mlc_1xnm_rr_value(const u8 *buf, int nmodes, int nregs,
|
|
|
|
int mode, int reg, bool inv, u8 *val)
|
|
|
|
{
|
|
|
|
u8 tmp[NAND_HYNIX_1XNM_RR_REPEAT];
|
|
|
|
int val_offs = (mode * nregs) + reg;
|
|
|
|
int set_size = nmodes * nregs;
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
for (i = 0; i < NAND_HYNIX_1XNM_RR_REPEAT; i++) {
|
|
|
|
int set_offs = NAND_HYNIX_1XNM_RR_SET_OFFS(i, set_size, inv);
|
|
|
|
|
|
|
|
tmp[i] = buf[val_offs + set_offs];
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = hynix_get_majority(tmp, NAND_HYNIX_1XNM_RR_REPEAT, val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (inv)
|
|
|
|
*val = ~*val;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u8 hynix_1xnm_mlc_read_retry_regs[] = {
|
|
|
|
0xcc, 0xbf, 0xaa, 0xab, 0xcd, 0xad, 0xae, 0xaf
|
|
|
|
};
|
|
|
|
|
|
|
|
static int hynix_mlc_1xnm_rr_init(struct nand_chip *chip,
|
|
|
|
const struct hynix_read_retry_otp *info)
|
|
|
|
{
|
|
|
|
struct hynix_nand *hynix = nand_get_manufacturer_data(chip);
|
|
|
|
struct hynix_read_retry *rr = NULL;
|
|
|
|
int ret, i, j;
|
|
|
|
u8 nregs, nmodes;
|
|
|
|
u8 *buf;
|
|
|
|
|
|
|
|
buf = kmalloc(info->size, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = hynix_read_rr_otp(chip, info, buf);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = hynix_get_majority(buf, NAND_HYNIX_1XNM_RR_REPEAT,
|
|
|
|
&nmodes);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = hynix_get_majority(buf + NAND_HYNIX_1XNM_RR_REPEAT,
|
|
|
|
NAND_HYNIX_1XNM_RR_REPEAT,
|
|
|
|
&nregs);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
rr = kzalloc(sizeof(*rr) + (nregs * nmodes), GFP_KERNEL);
|
2017-03-22 17:01:45 +08:00
|
|
|
if (!rr) {
|
|
|
|
ret = -ENOMEM;
|
2016-05-27 16:15:03 +08:00
|
|
|
goto out;
|
2017-03-22 17:01:45 +08:00
|
|
|
}
|
2016-05-27 16:15:03 +08:00
|
|
|
|
|
|
|
for (i = 0; i < nmodes; i++) {
|
|
|
|
for (j = 0; j < nregs; j++) {
|
|
|
|
u8 *val = rr->values + (i * nregs);
|
|
|
|
|
|
|
|
ret = hynix_mlc_1xnm_rr_value(buf, nmodes, nregs, i, j,
|
|
|
|
false, val);
|
|
|
|
if (!ret)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = hynix_mlc_1xnm_rr_value(buf, nmodes, nregs, i, j,
|
|
|
|
true, val);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rr->nregs = nregs;
|
|
|
|
rr->regs = hynix_1xnm_mlc_read_retry_regs;
|
|
|
|
hynix->read_retry = rr;
|
2020-05-29 19:12:57 +08:00
|
|
|
chip->ops.setup_read_retry = hynix_nand_setup_read_retry;
|
2016-05-27 16:15:03 +08:00
|
|
|
chip->read_retries = nmodes;
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
kfree(rr);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const u8 hynix_mlc_1xnm_rr_otp_regs[] = { 0x38 };
|
|
|
|
static const u8 hynix_mlc_1xnm_rr_otp_values[] = { 0x52 };
|
|
|
|
|
|
|
|
static const struct hynix_read_retry_otp hynix_mlc_1xnm_rr_otps[] = {
|
|
|
|
{
|
|
|
|
.nregs = ARRAY_SIZE(hynix_mlc_1xnm_rr_otp_regs),
|
|
|
|
.regs = hynix_mlc_1xnm_rr_otp_regs,
|
|
|
|
.values = hynix_mlc_1xnm_rr_otp_values,
|
|
|
|
.page = 0x21f,
|
|
|
|
.size = 784
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.nregs = ARRAY_SIZE(hynix_mlc_1xnm_rr_otp_regs),
|
|
|
|
.regs = hynix_mlc_1xnm_rr_otp_regs,
|
|
|
|
.values = hynix_mlc_1xnm_rr_otp_values,
|
|
|
|
.page = 0x200,
|
|
|
|
.size = 528,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int hynix_nand_rr_init(struct nand_chip *chip)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
bool valid_jedecid;
|
|
|
|
|
|
|
|
valid_jedecid = hynix_nand_has_valid_jedecid(chip);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only support read-retry for 1xnm NANDs, and those NANDs all
|
|
|
|
* expose a valid JEDEC ID.
|
|
|
|
*/
|
|
|
|
if (valid_jedecid) {
|
|
|
|
u8 nand_tech = chip->id.data[5] >> 4;
|
|
|
|
|
|
|
|
/* 1xnm technology */
|
|
|
|
if (nand_tech == 4) {
|
|
|
|
for (i = 0; i < ARRAY_SIZE(hynix_mlc_1xnm_rr_otps);
|
|
|
|
i++) {
|
|
|
|
/*
|
|
|
|
* FIXME: Hynix recommend to copy the
|
|
|
|
* read-retry OTP area into a normal page.
|
|
|
|
*/
|
|
|
|
ret = hynix_mlc_1xnm_rr_init(chip,
|
|
|
|
hynix_mlc_1xnm_rr_otps);
|
|
|
|
if (!ret)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
pr_warn("failed to initialize read-retry infrastructure");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-05-27 20:36:36 +08:00
|
|
|
static void hynix_nand_extract_oobsize(struct nand_chip *chip,
|
|
|
|
bool valid_jedecid)
|
|
|
|
{
|
|
|
|
struct mtd_info *mtd = nand_to_mtd(chip);
|
2018-10-25 23:10:37 +08:00
|
|
|
struct nand_memory_organization *memorg;
|
2016-05-27 20:36:36 +08:00
|
|
|
u8 oobsize;
|
2016-06-08 16:30:18 +08:00
|
|
|
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg = nanddev_get_memorg(&chip->base);
|
|
|
|
|
2016-05-27 20:36:36 +08:00
|
|
|
oobsize = ((chip->id.data[3] >> 2) & 0x3) |
|
|
|
|
((chip->id.data[3] >> 4) & 0x4);
|
|
|
|
|
|
|
|
if (valid_jedecid) {
|
|
|
|
switch (oobsize) {
|
|
|
|
case 0:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 2048;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 1:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 1664;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 2:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 1024;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 3:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 640;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* We should never reach this case, but if that
|
|
|
|
* happens, this probably means Hynix decided to use
|
|
|
|
* a different extended ID format, and we should find
|
|
|
|
* a way to support it.
|
|
|
|
*/
|
|
|
|
WARN(1, "Invalid OOB size");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
switch (oobsize) {
|
2016-06-08 16:30:18 +08:00
|
|
|
case 0:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 128;
|
2016-06-08 16:30:18 +08:00
|
|
|
break;
|
|
|
|
case 1:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 224;
|
2016-06-08 16:30:18 +08:00
|
|
|
break;
|
|
|
|
case 2:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 448;
|
2016-06-08 16:30:18 +08:00
|
|
|
break;
|
|
|
|
case 3:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 64;
|
2016-06-08 16:30:18 +08:00
|
|
|
break;
|
|
|
|
case 4:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 32;
|
2016-06-08 16:30:18 +08:00
|
|
|
break;
|
|
|
|
case 5:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 16;
|
2016-06-08 16:30:18 +08:00
|
|
|
break;
|
2016-05-27 20:36:36 +08:00
|
|
|
case 6:
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize = 640;
|
2016-06-08 16:30:18 +08:00
|
|
|
break;
|
2016-05-27 20:36:36 +08:00
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* We should never reach this case, but if that
|
|
|
|
* happens, this probably means Hynix decided to use
|
|
|
|
* a different extended ID format, and we should find
|
|
|
|
* a way to support it.
|
|
|
|
*/
|
|
|
|
WARN(1, "Invalid OOB size");
|
|
|
|
break;
|
2016-06-08 16:30:18 +08:00
|
|
|
}
|
mtd: rawnand: hynix: fix decoding the OOB size on H27UCG8T2BTR
The datasheet of the H27UCG8T2BTR states that this chip has a page size
of "16,384 + 1,280(Spare) bytes". The description of the "4th Byte of
Device Identifier Description" indicates that bits 6, 3 and 2 are
encoding the "Redundant Area Size / 8KB", where 640 bytes is a value of
0x6 (110 in binary notation).
hynix_nand_extract_oobsize decodes an OOB size of 640 bytes for this
chip. Kernel boot log extract before this patch:
nand: Could not find valid ONFI parameter page; aborting
nand: device found, Manufacturer ID: 0xad, Chip ID: 0xde
nand: Hynix NAND 8GiB 3,3V 8-bit
nand: 8192 MiB, MLC, erase size: 4096 KiB, page size: 16384,
OOB size: 640
However, based on the description in the datasheet we need to multiply
the OOB size with 2, because it's "640 spare bytes per 8192 bytes page
size" and this NAND chip has a page size of 16384 (= 2 * 8192). After
this patch the kernel boot log reports:
nand: Could not find valid ONFI parameter page; aborting
nand: device found, Manufacturer ID: 0xad, Chip ID: 0xde
nand: Hynix NAND 8GiB 3,3V 8-bit
nand: 8192 MiB, MLC, erase size: 4096 KiB, page size: 16384,
OOB size: 1280
Signed-off-by: Martin Blumenstingl <martin.blumenstingl@googlemail.com>
Reviewed-by: Boris Brezillon <boris.brezillon@bootlin.com>
Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com>
2018-06-25 04:53:55 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The datasheet of H27UCG8T2BTR mentions that the "Redundant
|
|
|
|
* Area Size" is encoded "per 8KB" (page size). This chip uses
|
|
|
|
* a page size of 16KiB. The datasheet mentions an OOB size of
|
|
|
|
* 1.280 bytes, but the OOB size encoded in the ID bytes (using
|
|
|
|
* the existing logic above) is 640 bytes.
|
|
|
|
* Update the OOB size for this chip by taking the value
|
|
|
|
* determined above and scaling it to the actual page size (so
|
|
|
|
* the actual OOB size for this chip is: 640 * 16k / 8k).
|
|
|
|
*/
|
|
|
|
if (chip->id.data[1] == 0xde)
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->oobsize *= memorg->pagesize / SZ_8K;
|
2016-05-27 20:36:36 +08:00
|
|
|
}
|
2018-10-25 23:10:37 +08:00
|
|
|
|
|
|
|
mtd->oobsize = memorg->oobsize;
|
2016-05-27 20:36:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hynix_nand_extract_ecc_requirements(struct nand_chip *chip,
|
|
|
|
bool valid_jedecid)
|
|
|
|
{
|
2020-08-27 16:52:02 +08:00
|
|
|
struct nand_device *base = &chip->base;
|
|
|
|
struct nand_ecc_props requirements = {};
|
2016-05-27 20:36:36 +08:00
|
|
|
u8 ecc_level = (chip->id.data[4] >> 4) & 0x7;
|
|
|
|
|
|
|
|
if (valid_jedecid) {
|
|
|
|
/* Reference: H27UCG8T2E datasheet */
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.step_size = 1024;
|
2016-06-08 16:30:18 +08:00
|
|
|
|
2016-05-27 20:36:36 +08:00
|
|
|
switch (ecc_level) {
|
|
|
|
case 0:
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.step_size = 0;
|
|
|
|
requirements.strength = 0;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 1:
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.strength = 4;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 2:
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.strength = 24;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 3:
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.strength = 32;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 4:
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.strength = 40;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 5:
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.strength = 50;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
case 6:
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.strength = 60;
|
2016-05-27 20:36:36 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* We should never reach this case, but if that
|
|
|
|
* happens, this probably means Hynix decided to use
|
|
|
|
* a different extended ID format, and we should find
|
|
|
|
* a way to support it.
|
|
|
|
*/
|
|
|
|
WARN(1, "Invalid ECC requirements");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The ECC requirements field meaning depends on the
|
|
|
|
* NAND technology.
|
|
|
|
*/
|
2017-08-05 20:16:24 +08:00
|
|
|
u8 nand_tech = chip->id.data[5] & 0x7;
|
2016-05-27 20:36:36 +08:00
|
|
|
|
|
|
|
if (nand_tech < 3) {
|
|
|
|
/* > 26nm, reference: H27UBG8T2A datasheet */
|
|
|
|
if (ecc_level < 5) {
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.step_size = 512;
|
|
|
|
requirements.strength = 1 << ecc_level;
|
2016-05-27 20:36:36 +08:00
|
|
|
} else if (ecc_level < 7) {
|
|
|
|
if (ecc_level == 5)
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.step_size = 2048;
|
2016-05-27 20:36:36 +08:00
|
|
|
else
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.step_size = 1024;
|
|
|
|
requirements.strength = 24;
|
2016-05-27 20:36:36 +08:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We should never reach this case, but if that
|
|
|
|
* happens, this probably means Hynix decided
|
|
|
|
* to use a different extended ID format, and
|
|
|
|
* we should find a way to support it.
|
|
|
|
*/
|
|
|
|
WARN(1, "Invalid ECC requirements");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* <= 26nm, reference: H27UBG8T2B datasheet */
|
|
|
|
if (!ecc_level) {
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.step_size = 0;
|
|
|
|
requirements.strength = 0;
|
2016-05-27 20:36:36 +08:00
|
|
|
} else if (ecc_level < 5) {
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.step_size = 512;
|
|
|
|
requirements.strength = 1 << (ecc_level - 1);
|
2016-05-27 20:36:36 +08:00
|
|
|
} else {
|
2020-08-27 16:52:02 +08:00
|
|
|
requirements.step_size = 1024;
|
|
|
|
requirements.strength = 24 +
|
2016-05-27 20:36:36 +08:00
|
|
|
(8 * (ecc_level - 5));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-08-27 16:52:02 +08:00
|
|
|
|
|
|
|
nanddev_set_ecc_requirements(base, &requirements);
|
2016-05-27 20:36:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hynix_nand_extract_scrambling_requirements(struct nand_chip *chip,
|
|
|
|
bool valid_jedecid)
|
|
|
|
{
|
|
|
|
u8 nand_tech;
|
|
|
|
|
|
|
|
/* We need scrambling on all TLC NANDs*/
|
2018-10-25 23:16:47 +08:00
|
|
|
if (nanddev_bits_per_cell(&chip->base) > 2)
|
2016-05-27 20:36:36 +08:00
|
|
|
chip->options |= NAND_NEED_SCRAMBLING;
|
|
|
|
|
|
|
|
/* And on MLC NANDs with sub-3xnm process */
|
|
|
|
if (valid_jedecid) {
|
|
|
|
nand_tech = chip->id.data[5] >> 4;
|
|
|
|
|
|
|
|
/* < 3xnm */
|
|
|
|
if (nand_tech > 0)
|
|
|
|
chip->options |= NAND_NEED_SCRAMBLING;
|
2016-06-08 16:30:18 +08:00
|
|
|
} else {
|
2017-08-05 20:16:24 +08:00
|
|
|
nand_tech = chip->id.data[5] & 0x7;
|
2016-05-27 20:36:36 +08:00
|
|
|
|
|
|
|
/* < 32nm */
|
|
|
|
if (nand_tech > 2)
|
|
|
|
chip->options |= NAND_NEED_SCRAMBLING;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hynix_nand_decode_id(struct nand_chip *chip)
|
|
|
|
{
|
|
|
|
struct mtd_info *mtd = nand_to_mtd(chip);
|
2018-10-25 23:10:37 +08:00
|
|
|
struct nand_memory_organization *memorg;
|
2016-05-27 20:36:36 +08:00
|
|
|
bool valid_jedecid;
|
|
|
|
u8 tmp;
|
|
|
|
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg = nanddev_get_memorg(&chip->base);
|
|
|
|
|
2016-05-27 20:36:36 +08:00
|
|
|
/*
|
|
|
|
* Exclude all SLC NANDs from this advanced detection scheme.
|
|
|
|
* According to the ranges defined in several datasheets, it might
|
|
|
|
* appear that even SLC NANDs could fall in this extended ID scheme.
|
|
|
|
* If that the case rework the test to let SLC NANDs go through the
|
|
|
|
* detection process.
|
|
|
|
*/
|
|
|
|
if (chip->id.len < 6 || nand_is_slc(chip)) {
|
2016-06-08 16:30:18 +08:00
|
|
|
nand_decode_ext_id(chip);
|
2016-05-27 20:36:36 +08:00
|
|
|
return;
|
2016-06-08 16:30:18 +08:00
|
|
|
}
|
2016-05-27 20:36:36 +08:00
|
|
|
|
|
|
|
/* Extract pagesize */
|
2018-10-25 23:10:37 +08:00
|
|
|
memorg->pagesize = 2048 << (chip->id.data[3] & 0x03);
|
|
|
|
mtd->writesize = memorg->pagesize;
|
2016-05-27 20:36:36 +08:00
|
|
|
|
|
|
|
tmp = (chip->id.data[3] >> 4) & 0x3;
|
|
|
|
/*
|
|
|
|
* When bit7 is set that means we start counting at 1MiB, otherwise
|
|
|
|
* we start counting at 128KiB and shift this value the content of
|
|
|
|
* ID[3][4:5].
|
|
|
|
* The only exception is when ID[3][4:5] == 3 and ID[3][7] == 0, in
|
|
|
|
* this case the erasesize is set to 768KiB.
|
|
|
|
*/
|
2018-10-25 23:10:37 +08:00
|
|
|
if (chip->id.data[3] & 0x80) {
|
|
|
|
memorg->pages_per_eraseblock = (SZ_1M << tmp) /
|
|
|
|
memorg->pagesize;
|
2016-05-27 20:36:36 +08:00
|
|
|
mtd->erasesize = SZ_1M << tmp;
|
2018-10-25 23:10:37 +08:00
|
|
|
} else if (tmp == 3) {
|
|
|
|
memorg->pages_per_eraseblock = (SZ_512K + SZ_256K) /
|
|
|
|
memorg->pagesize;
|
2016-05-27 20:36:36 +08:00
|
|
|
mtd->erasesize = SZ_512K + SZ_256K;
|
2018-10-25 23:10:37 +08:00
|
|
|
} else {
|
|
|
|
memorg->pages_per_eraseblock = (SZ_128K << tmp) /
|
|
|
|
memorg->pagesize;
|
2016-05-27 20:36:36 +08:00
|
|
|
mtd->erasesize = SZ_128K << tmp;
|
2018-10-25 23:10:37 +08:00
|
|
|
}
|
2016-05-27 20:36:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Modern Toggle DDR NANDs have a valid JEDECID even though they are
|
|
|
|
* not exposing a valid JEDEC parameter table.
|
|
|
|
* These NANDs use a different NAND ID scheme.
|
|
|
|
*/
|
|
|
|
valid_jedecid = hynix_nand_has_valid_jedecid(chip);
|
|
|
|
|
|
|
|
hynix_nand_extract_oobsize(chip, valid_jedecid);
|
|
|
|
hynix_nand_extract_ecc_requirements(chip, valid_jedecid);
|
|
|
|
hynix_nand_extract_scrambling_requirements(chip, valid_jedecid);
|
2016-06-08 16:30:18 +08:00
|
|
|
}
|
|
|
|
|
2016-05-27 16:15:03 +08:00
|
|
|
static void hynix_nand_cleanup(struct nand_chip *chip)
|
|
|
|
{
|
|
|
|
struct hynix_nand *hynix = nand_get_manufacturer_data(chip);
|
|
|
|
|
|
|
|
if (!hynix)
|
|
|
|
return;
|
|
|
|
|
|
|
|
kfree(hynix->read_retry);
|
|
|
|
kfree(hynix);
|
|
|
|
nand_set_manufacturer_data(chip, NULL);
|
|
|
|
}
|
|
|
|
|
2020-05-29 19:13:19 +08:00
|
|
|
static int
|
|
|
|
h27ucg8t2atrbc_choose_interface_config(struct nand_chip *chip,
|
|
|
|
struct nand_interface_config *iface)
|
|
|
|
{
|
|
|
|
onfi_fill_interface_config(chip, iface, NAND_SDR_IFACE, 4);
|
|
|
|
|
|
|
|
return nand_choose_best_sdr_timings(chip, iface, NULL);
|
|
|
|
}
|
|
|
|
|
2021-10-01 00:24:02 +08:00
|
|
|
static int h27ucg8t2etrbc_init(struct nand_chip *chip)
|
|
|
|
{
|
|
|
|
struct mtd_info *mtd = nand_to_mtd(chip);
|
|
|
|
|
|
|
|
chip->options |= NAND_NEED_SCRAMBLING;
|
|
|
|
mtd_set_pairing_scheme(mtd, &dist3_pairing_scheme);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-08 16:30:18 +08:00
|
|
|
static int hynix_nand_init(struct nand_chip *chip)
|
|
|
|
{
|
2016-05-27 16:15:03 +08:00
|
|
|
struct hynix_nand *hynix;
|
|
|
|
int ret;
|
|
|
|
|
2016-06-08 16:30:18 +08:00
|
|
|
if (!nand_is_slc(chip))
|
2019-04-17 20:36:34 +08:00
|
|
|
chip->options |= NAND_BBM_LASTPAGE;
|
2016-06-08 16:30:18 +08:00
|
|
|
else
|
2019-04-17 20:36:36 +08:00
|
|
|
chip->options |= NAND_BBM_FIRSTPAGE | NAND_BBM_SECONDPAGE;
|
2016-06-08 16:30:18 +08:00
|
|
|
|
2016-05-27 16:15:03 +08:00
|
|
|
hynix = kzalloc(sizeof(*hynix), GFP_KERNEL);
|
|
|
|
if (!hynix)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
nand_set_manufacturer_data(chip, hynix);
|
|
|
|
|
2020-05-29 19:13:19 +08:00
|
|
|
if (!strncmp("H27UCG8T2ATR-BC", chip->parameters.model,
|
|
|
|
sizeof("H27UCG8T2ATR-BC") - 1))
|
|
|
|
chip->ops.choose_interface_config =
|
|
|
|
h27ucg8t2atrbc_choose_interface_config;
|
|
|
|
|
2021-10-01 00:24:02 +08:00
|
|
|
if (!strncmp("H27UCG8T2ETR-BC", chip->parameters.model,
|
|
|
|
sizeof("H27UCG8T2ETR-BC") - 1))
|
|
|
|
h27ucg8t2etrbc_init(chip);
|
|
|
|
|
2016-05-27 16:15:03 +08:00
|
|
|
ret = hynix_nand_rr_init(chip);
|
|
|
|
if (ret)
|
|
|
|
hynix_nand_cleanup(chip);
|
|
|
|
|
|
|
|
return ret;
|
2016-06-08 16:30:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const struct nand_manufacturer_ops hynix_nand_manuf_ops = {
|
|
|
|
.detect = hynix_nand_decode_id,
|
|
|
|
.init = hynix_nand_init,
|
2016-05-27 16:15:03 +08:00
|
|
|
.cleanup = hynix_nand_cleanup,
|
2016-06-08 16:30:18 +08:00
|
|
|
};
|