400 строки
11 KiB
C
400 строки
11 KiB
C
/*
|
|
* sharpslpart.c - MTD partition parser for NAND flash using the SHARP FTL
|
|
* for logical addressing, as used on the PXA models of the SHARP SL Series.
|
|
*
|
|
* Copyright (C) 2017 Andrea Adami <andrea.adami@gmail.com>
|
|
*
|
|
* Based on SHARP GPL 2.4 sources:
|
|
* http://support.ezaurus.com/developer/source/source_dl.asp
|
|
* drivers/mtd/nand/sharp_sl_logical.c
|
|
* linux/include/asm-arm/sharp_nand_logical.h
|
|
*
|
|
* Copyright (C) 2002 SHARP
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/sizes.h>
|
|
#include <linux/mtd/mtd.h>
|
|
#include <linux/mtd/partitions.h>
|
|
|
|
/* oob structure */
|
|
#define NAND_NOOB_LOGADDR_00 8
|
|
#define NAND_NOOB_LOGADDR_01 9
|
|
#define NAND_NOOB_LOGADDR_10 10
|
|
#define NAND_NOOB_LOGADDR_11 11
|
|
#define NAND_NOOB_LOGADDR_20 12
|
|
#define NAND_NOOB_LOGADDR_21 13
|
|
|
|
#define BLOCK_IS_RESERVED 0xffff
|
|
#define BLOCK_UNMASK_COMPLEMENT 1
|
|
|
|
/* factory defaults */
|
|
#define SHARPSL_NAND_PARTS 3
|
|
#define SHARPSL_FTL_PART_SIZE (7 * SZ_1M)
|
|
#define SHARPSL_PARTINFO1_LADDR 0x00060000
|
|
#define SHARPSL_PARTINFO2_LADDR 0x00064000
|
|
|
|
#define BOOT_MAGIC 0x424f4f54
|
|
#define FSRO_MAGIC 0x4653524f
|
|
#define FSRW_MAGIC 0x46535257
|
|
|
|
/**
|
|
* struct sharpsl_ftl - Sharp FTL Logical Table
|
|
* @logmax: number of logical blocks
|
|
* @log2phy: the logical-to-physical table
|
|
*
|
|
* Structure containing the logical-to-physical translation table
|
|
* used by the SHARP SL FTL.
|
|
*/
|
|
struct sharpsl_ftl {
|
|
unsigned int logmax;
|
|
unsigned int *log2phy;
|
|
};
|
|
|
|
/* verify that the OOB bytes 8 to 15 are free and available for the FTL */
|
|
static int sharpsl_nand_check_ooblayout(struct mtd_info *mtd)
|
|
{
|
|
u8 freebytes = 0;
|
|
int section = 0;
|
|
|
|
while (true) {
|
|
struct mtd_oob_region oobfree = { };
|
|
int ret, i;
|
|
|
|
ret = mtd_ooblayout_free(mtd, section++, &oobfree);
|
|
if (ret)
|
|
break;
|
|
|
|
if (!oobfree.length || oobfree.offset > 15 ||
|
|
(oobfree.offset + oobfree.length) < 8)
|
|
continue;
|
|
|
|
i = oobfree.offset >= 8 ? oobfree.offset : 8;
|
|
for (; i < oobfree.offset + oobfree.length && i < 16; i++)
|
|
freebytes |= BIT(i - 8);
|
|
|
|
if (freebytes == 0xff)
|
|
return 0;
|
|
}
|
|
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
static int sharpsl_nand_read_oob(struct mtd_info *mtd, loff_t offs, u8 *buf)
|
|
{
|
|
struct mtd_oob_ops ops = { };
|
|
int ret;
|
|
|
|
ops.mode = MTD_OPS_PLACE_OOB;
|
|
ops.ooblen = mtd->oobsize;
|
|
ops.oobbuf = buf;
|
|
|
|
ret = mtd_read_oob(mtd, offs, &ops);
|
|
if (ret != 0 || mtd->oobsize != ops.oobretlen)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* The logical block number assigned to a physical block is stored in the OOB
|
|
* of the first page, in 3 16-bit copies with the following layout:
|
|
*
|
|
* 01234567 89abcdef
|
|
* -------- --------
|
|
* ECC BB xyxyxy
|
|
*
|
|
* When reading we check that the first two copies agree.
|
|
* In case of error, matching is tried using the following pairs.
|
|
* Reserved values 0xffff mean the block is kept for wear leveling.
|
|
*
|
|
* 01234567 89abcdef
|
|
* -------- --------
|
|
* ECC BB xyxy oob[8]==oob[10] && oob[9]==oob[11] -> byte0=8 byte1=9
|
|
* ECC BB xyxy oob[10]==oob[12] && oob[11]==oob[13] -> byte0=10 byte1=11
|
|
* ECC BB xy xy oob[12]==oob[8] && oob[13]==oob[9] -> byte0=12 byte1=13
|
|
*/
|
|
static int sharpsl_nand_get_logical_num(u8 *oob)
|
|
{
|
|
u16 us;
|
|
int good0, good1;
|
|
|
|
if (oob[NAND_NOOB_LOGADDR_00] == oob[NAND_NOOB_LOGADDR_10] &&
|
|
oob[NAND_NOOB_LOGADDR_01] == oob[NAND_NOOB_LOGADDR_11]) {
|
|
good0 = NAND_NOOB_LOGADDR_00;
|
|
good1 = NAND_NOOB_LOGADDR_01;
|
|
} else if (oob[NAND_NOOB_LOGADDR_10] == oob[NAND_NOOB_LOGADDR_20] &&
|
|
oob[NAND_NOOB_LOGADDR_11] == oob[NAND_NOOB_LOGADDR_21]) {
|
|
good0 = NAND_NOOB_LOGADDR_10;
|
|
good1 = NAND_NOOB_LOGADDR_11;
|
|
} else if (oob[NAND_NOOB_LOGADDR_20] == oob[NAND_NOOB_LOGADDR_00] &&
|
|
oob[NAND_NOOB_LOGADDR_21] == oob[NAND_NOOB_LOGADDR_01]) {
|
|
good0 = NAND_NOOB_LOGADDR_20;
|
|
good1 = NAND_NOOB_LOGADDR_21;
|
|
} else {
|
|
return -EINVAL;
|
|
}
|
|
|
|
us = oob[good0] | oob[good1] << 8;
|
|
|
|
/* parity check */
|
|
if (hweight16(us) & BLOCK_UNMASK_COMPLEMENT)
|
|
return -EINVAL;
|
|
|
|
/* reserved */
|
|
if (us == BLOCK_IS_RESERVED)
|
|
return BLOCK_IS_RESERVED;
|
|
|
|
return (us >> 1) & GENMASK(9, 0);
|
|
}
|
|
|
|
static int sharpsl_nand_init_ftl(struct mtd_info *mtd, struct sharpsl_ftl *ftl)
|
|
{
|
|
unsigned int block_num, phymax;
|
|
int i, ret, log_num;
|
|
loff_t block_adr;
|
|
u8 *oob;
|
|
|
|
oob = kzalloc(mtd->oobsize, GFP_KERNEL);
|
|
if (!oob)
|
|
return -ENOMEM;
|
|
|
|
phymax = mtd_div_by_eb(SHARPSL_FTL_PART_SIZE, mtd);
|
|
|
|
/* FTL reserves 5% of the blocks + 1 spare */
|
|
ftl->logmax = ((phymax * 95) / 100) - 1;
|
|
|
|
ftl->log2phy = kmalloc_array(ftl->logmax, sizeof(*ftl->log2phy),
|
|
GFP_KERNEL);
|
|
if (!ftl->log2phy) {
|
|
ret = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
|
|
/* initialize ftl->log2phy */
|
|
for (i = 0; i < ftl->logmax; i++)
|
|
ftl->log2phy[i] = UINT_MAX;
|
|
|
|
/* create physical-logical table */
|
|
for (block_num = 0; block_num < phymax; block_num++) {
|
|
block_adr = (loff_t)block_num * mtd->erasesize;
|
|
|
|
if (mtd_block_isbad(mtd, block_adr))
|
|
continue;
|
|
|
|
if (sharpsl_nand_read_oob(mtd, block_adr, oob))
|
|
continue;
|
|
|
|
/* get logical block */
|
|
log_num = sharpsl_nand_get_logical_num(oob);
|
|
|
|
/* cut-off errors and skip the out-of-range values */
|
|
if (log_num > 0 && log_num < ftl->logmax) {
|
|
if (ftl->log2phy[log_num] == UINT_MAX)
|
|
ftl->log2phy[log_num] = block_num;
|
|
}
|
|
}
|
|
|
|
pr_info("Sharp SL FTL: %d blocks used (%d logical, %d reserved)\n",
|
|
phymax, ftl->logmax, phymax - ftl->logmax);
|
|
|
|
ret = 0;
|
|
exit:
|
|
kfree(oob);
|
|
return ret;
|
|
}
|
|
|
|
static void sharpsl_nand_cleanup_ftl(struct sharpsl_ftl *ftl)
|
|
{
|
|
kfree(ftl->log2phy);
|
|
}
|
|
|
|
static int sharpsl_nand_read_laddr(struct mtd_info *mtd,
|
|
loff_t from,
|
|
size_t len,
|
|
void *buf,
|
|
struct sharpsl_ftl *ftl)
|
|
{
|
|
unsigned int log_num, final_log_num;
|
|
unsigned int block_num;
|
|
loff_t block_adr;
|
|
loff_t block_ofs;
|
|
size_t retlen;
|
|
int err;
|
|
|
|
log_num = mtd_div_by_eb((u32)from, mtd);
|
|
final_log_num = mtd_div_by_eb(((u32)from + len - 1), mtd);
|
|
|
|
if (len <= 0 || log_num >= ftl->logmax || final_log_num > log_num)
|
|
return -EINVAL;
|
|
|
|
block_num = ftl->log2phy[log_num];
|
|
block_adr = (loff_t)block_num * mtd->erasesize;
|
|
block_ofs = mtd_mod_by_eb((u32)from, mtd);
|
|
|
|
err = mtd_read(mtd, block_adr + block_ofs, len, &retlen, buf);
|
|
/* Ignore corrected ECC errors */
|
|
if (mtd_is_bitflip(err))
|
|
err = 0;
|
|
|
|
if (!err && retlen != len)
|
|
err = -EIO;
|
|
|
|
if (err)
|
|
pr_err("sharpslpart: error, read failed at %#llx\n",
|
|
block_adr + block_ofs);
|
|
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* MTD Partition Parser
|
|
*
|
|
* Sample values read from SL-C860
|
|
*
|
|
* # cat /proc/mtd
|
|
* dev: size erasesize name
|
|
* mtd0: 006d0000 00020000 "Filesystem"
|
|
* mtd1: 00700000 00004000 "smf"
|
|
* mtd2: 03500000 00004000 "root"
|
|
* mtd3: 04400000 00004000 "home"
|
|
*
|
|
* PARTITIONINFO1
|
|
* 0x00060000: 00 00 00 00 00 00 70 00 42 4f 4f 54 00 00 00 00 ......p.BOOT....
|
|
* 0x00060010: 00 00 70 00 00 00 c0 03 46 53 52 4f 00 00 00 00 ..p.....FSRO....
|
|
* 0x00060020: 00 00 c0 03 00 00 00 04 46 53 52 57 00 00 00 00 ........FSRW....
|
|
*/
|
|
struct sharpsl_nand_partinfo {
|
|
__le32 start;
|
|
__le32 end;
|
|
__be32 magic;
|
|
u32 reserved;
|
|
};
|
|
|
|
static int sharpsl_nand_read_partinfo(struct mtd_info *master,
|
|
loff_t from,
|
|
size_t len,
|
|
struct sharpsl_nand_partinfo *buf,
|
|
struct sharpsl_ftl *ftl)
|
|
{
|
|
int ret;
|
|
|
|
ret = sharpsl_nand_read_laddr(master, from, len, buf, ftl);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* check for magics */
|
|
if (be32_to_cpu(buf[0].magic) != BOOT_MAGIC ||
|
|
be32_to_cpu(buf[1].magic) != FSRO_MAGIC ||
|
|
be32_to_cpu(buf[2].magic) != FSRW_MAGIC) {
|
|
pr_err("sharpslpart: magic values mismatch\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* fixup for hardcoded value 64 MiB (for older models) */
|
|
buf[2].end = cpu_to_le32(master->size);
|
|
|
|
/* extra sanity check */
|
|
if (le32_to_cpu(buf[0].end) <= le32_to_cpu(buf[0].start) ||
|
|
le32_to_cpu(buf[1].start) < le32_to_cpu(buf[0].end) ||
|
|
le32_to_cpu(buf[1].end) <= le32_to_cpu(buf[1].start) ||
|
|
le32_to_cpu(buf[2].start) < le32_to_cpu(buf[1].end) ||
|
|
le32_to_cpu(buf[2].end) <= le32_to_cpu(buf[2].start)) {
|
|
pr_err("sharpslpart: partition sizes mismatch\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sharpsl_parse_mtd_partitions(struct mtd_info *master,
|
|
const struct mtd_partition **pparts,
|
|
struct mtd_part_parser_data *data)
|
|
{
|
|
struct sharpsl_ftl ftl;
|
|
struct sharpsl_nand_partinfo buf[SHARPSL_NAND_PARTS];
|
|
struct mtd_partition *sharpsl_nand_parts;
|
|
int err;
|
|
|
|
/* check that OOB bytes 8 to 15 used by the FTL are actually free */
|
|
err = sharpsl_nand_check_ooblayout(master);
|
|
if (err)
|
|
return err;
|
|
|
|
/* init logical mgmt (FTL) */
|
|
err = sharpsl_nand_init_ftl(master, &ftl);
|
|
if (err)
|
|
return err;
|
|
|
|
/* read and validate first partition table */
|
|
pr_info("sharpslpart: try reading first partition table\n");
|
|
err = sharpsl_nand_read_partinfo(master,
|
|
SHARPSL_PARTINFO1_LADDR,
|
|
sizeof(buf), buf, &ftl);
|
|
if (err) {
|
|
/* fallback: read second partition table */
|
|
pr_warn("sharpslpart: first partition table is invalid, retry using the second\n");
|
|
err = sharpsl_nand_read_partinfo(master,
|
|
SHARPSL_PARTINFO2_LADDR,
|
|
sizeof(buf), buf, &ftl);
|
|
}
|
|
|
|
/* cleanup logical mgmt (FTL) */
|
|
sharpsl_nand_cleanup_ftl(&ftl);
|
|
|
|
if (err) {
|
|
pr_err("sharpslpart: both partition tables are invalid\n");
|
|
return err;
|
|
}
|
|
|
|
sharpsl_nand_parts = kcalloc(SHARPSL_NAND_PARTS,
|
|
sizeof(*sharpsl_nand_parts),
|
|
GFP_KERNEL);
|
|
if (!sharpsl_nand_parts)
|
|
return -ENOMEM;
|
|
|
|
/* original names */
|
|
sharpsl_nand_parts[0].name = "smf";
|
|
sharpsl_nand_parts[0].offset = le32_to_cpu(buf[0].start);
|
|
sharpsl_nand_parts[0].size = le32_to_cpu(buf[0].end) -
|
|
le32_to_cpu(buf[0].start);
|
|
|
|
sharpsl_nand_parts[1].name = "root";
|
|
sharpsl_nand_parts[1].offset = le32_to_cpu(buf[1].start);
|
|
sharpsl_nand_parts[1].size = le32_to_cpu(buf[1].end) -
|
|
le32_to_cpu(buf[1].start);
|
|
|
|
sharpsl_nand_parts[2].name = "home";
|
|
sharpsl_nand_parts[2].offset = le32_to_cpu(buf[2].start);
|
|
sharpsl_nand_parts[2].size = le32_to_cpu(buf[2].end) -
|
|
le32_to_cpu(buf[2].start);
|
|
|
|
*pparts = sharpsl_nand_parts;
|
|
return SHARPSL_NAND_PARTS;
|
|
}
|
|
|
|
static struct mtd_part_parser sharpsl_mtd_parser = {
|
|
.parse_fn = sharpsl_parse_mtd_partitions,
|
|
.name = "sharpslpart",
|
|
};
|
|
module_mtd_part_parser(sharpsl_mtd_parser);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Andrea Adami <andrea.adami@gmail.com>");
|
|
MODULE_DESCRIPTION("MTD partitioning for NAND flash on Sharp SL Series");
|