diff options
Diffstat (limited to 'recipes-kernel/linux/linux-handheld-4.14/sharpslpart')
5 files changed, 785 insertions, 0 deletions
diff --git a/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0001-mtd-sharpslpart-Add-sharpslpart-partition-parser.patch b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0001-mtd-sharpslpart-Add-sharpslpart-partition-parser.patch new file mode 100644 index 0000000..069bc4b --- /dev/null +++ b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0001-mtd-sharpslpart-Add-sharpslpart-partition-parser.patch @@ -0,0 +1,494 @@ +From 0a186618be42cbc35bfe83c039512761d4a8f12f Mon Sep 17 00:00:00 2001 +From: Andrea Adami <andrea.adami@gmail.com> +Date: Thu, 31 Aug 2017 22:44:04 +0200 +Subject: [PATCH] mtd: sharpslpart: Add sharpslpart partition parser + +The Sharp SL Series (Zaurus) PXA handhelds have 16/64/128M of NAND flash +and share the same layout of the first 7M partition, managed by Sharp FTL. + +GPL 2.4 sources: http://support.ezaurus.com/developer/source/source_dl.asp + +The purpose of this self-contained patch is to add a common parser and +remove the hardcoded sizes in the board files (these devices are not yet +converted to devicetree). +Users will have benefits because the mtdparts= tag will not be necessary +anymore and they will be free to repartition the little sized flash. + +The obsolete bootloader can not pass the partitioning info to modern +kernels anymore so it has to be read from flash at known logical addresses. +(see http://www.h5.dion.ne.jp/~rimemoon/zaurus/memo_006.htm ) + +In kernel, under arch/arm/mach-pxa we have already 8 machines: +MACH_POODLE, MACH_CORGI, MACH_SHEPERD, MACH_HUSKY, MACH_AKITA, MACH_SPITZ, +MACH_BORZOI, MACH_TOSA. +Lost after the 2.4 vendor kernel are MACH_BOXER and MACH_TERRIER. + +Almost every model has different factory partitioning: add to this the +units can be repartitioned by users with userspace tools (nandlogical) +and installers for popular (back then) linux distributions. + +The Parameter Area in the first (boot) partition extends from 0x00040000 to +0x0007bfff (176k) and contains two copies of the partition table: +... +0x00060000: Partition Info1 16k +0x00064000: Partition Info2 16k +0x00668000: Model 16k +... + +The first 7M partition is managed by the Sharp FTL reserving 5% + 1 blocks +for wear-leveling: some blocks are remapped and one layer of translation +(logical to physical) is necessary. + +There isn't much documentation about this FTL in the 2.4 sources, just the +MTD methods for reading and writing using logical addresses and the block +management (wear-leveling, use counter). +It seems this FTL was tailored with 16KiB eraesize in mind so to fit one +param block exactly, to have two copies of the partition table on two +blocks. +Later pxa27x devices have same size but 128KiB erasesize and less blocks +(56 vs. 448) but the same schema was adopted, even if the two tables are +now in the same eraseblock. + +For the purpose of the MTD parser only the read part of the code was taken. + +The NAND drivers that can use this parser are sharpsl.c and tmio_nand.c. + +Signed-off-by: Andrea Adami <andrea.adami@gmail.com> +Reviewed-by: Boris Brezillon <boris.brezillon@free-electrons.com> +--- + drivers/mtd/parsers/Kconfig | 8 + + drivers/mtd/parsers/Makefile | 1 + + drivers/mtd/parsers/sharpslpart.c | 398 ++++++++++++++++++++++++++++++++++++++ + 3 files changed, 407 insertions(+) + create mode 100644 drivers/mtd/parsers/sharpslpart.c + +diff --git a/drivers/mtd/parsers/Kconfig b/drivers/mtd/parsers/Kconfig +index d206b3c..ee5ab99 100644 +--- a/drivers/mtd/parsers/Kconfig ++++ b/drivers/mtd/parsers/Kconfig +@@ -6,3 +6,11 @@ config MTD_PARSER_TRX + may contain up to 3/4 partitions (depending on the version). + This driver will parse TRX header and report at least two partitions: + kernel and rootfs. ++ ++config MTD_SHARPSL_PARTS ++ tristate "Sharp SL Series NAND flash partition parser" ++ depends on MTD_NAND_SHARPSL || MTD_NAND_TMIO || COMPILE_TEST ++ help ++ This provides the read-only FTL logic necessary to read the partition ++ table from the NAND flash of Sharp SL Series (Zaurus) and the MTD ++ partition parser using this code. +diff --git a/drivers/mtd/parsers/Makefile b/drivers/mtd/parsers/Makefile +index 4d9024e..5b1bcc3 100644 +--- a/drivers/mtd/parsers/Makefile ++++ b/drivers/mtd/parsers/Makefile +@@ -1 +1,2 @@ + obj-$(CONFIG_MTD_PARSER_TRX) += parser_trx.o ++obj-$(CONFIG_MTD_SHARPSL_PARTS) += sharpslpart.o +diff --git a/drivers/mtd/parsers/sharpslpart.c b/drivers/mtd/parsers/sharpslpart.c +new file mode 100644 +index 0000000..5fe0079 +--- /dev/null ++++ b/drivers/mtd/parsers/sharpslpart.c +@@ -0,0 +1,398 @@ ++/* ++ * 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, log_num, phymax; ++ loff_t block_adr; ++ u8 *oob; ++ int i, ret; ++ ++ 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"); +-- +2.7.4 + diff --git a/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0006-ARM-pxa-corgi-Remove-hardcoded-partitioning-use-shar.patch b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0006-ARM-pxa-corgi-Remove-hardcoded-partitioning-use-shar.patch new file mode 100644 index 0000000..cee6355 --- /dev/null +++ b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0006-ARM-pxa-corgi-Remove-hardcoded-partitioning-use-shar.patch @@ -0,0 +1,77 @@ +From a5cac163d4821abe5b5cb7e9453e34084f1bc9ab Mon Sep 17 00:00:00 2001 +From: Andrea Adami <andrea.adami@gmail.com> +Date: Mon, 14 Aug 2017 16:43:46 +0200 +Subject: [PATCH v5 6/9] ARM: pxa/corgi: Remove hardcoded partitioning, use + sharpslpart parser + +With the introduction of sharpslpart partition parser we can now read the +offsets from NAND: we specify the list of the parsers as platform data, with +cmdlinepart and ofpart parsers first allowing to override the part. table +written in NAND. This is done here in the board file. + +Signed-off-by: Andrea Adami <andrea.adami@gmail.com> +--- + arch/arm/mach-pxa/corgi.c | 31 ++++++++----------------------- + 1 file changed, 8 insertions(+), 23 deletions(-) + +diff --git a/arch/arm/mach-pxa/corgi.c b/arch/arm/mach-pxa/corgi.c +index 7270f0d..9546452 100644 +--- a/arch/arm/mach-pxa/corgi.c ++++ b/arch/arm/mach-pxa/corgi.c +@@ -606,24 +606,6 @@ static void __init corgi_init_spi(void) + static inline void corgi_init_spi(void) {} + #endif + +-static struct mtd_partition sharpsl_nand_partitions[] = { +- { +- .name = "System Area", +- .offset = 0, +- .size = 7 * 1024 * 1024, +- }, +- { +- .name = "Root Filesystem", +- .offset = 7 * 1024 * 1024, +- .size = 25 * 1024 * 1024, +- }, +- { +- .name = "Home Filesystem", +- .offset = MTDPART_OFS_APPEND, +- .size = MTDPART_SIZ_FULL, +- }, +-}; +- + static uint8_t scan_ff_pattern[] = { 0xff, 0xff }; + + static struct nand_bbt_descr sharpsl_bbt = { +@@ -633,10 +615,16 @@ static struct nand_bbt_descr sharpsl_bbt = { + .pattern = scan_ff_pattern + }; + ++static const char * const probes[] = { ++ "cmdlinepart", ++ "ofpart", ++ "sharpslpart", ++ NULL, ++}; ++ + static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = { + .badblock_pattern = &sharpsl_bbt, +- .partitions = sharpsl_nand_partitions, +- .nr_partitions = ARRAY_SIZE(sharpsl_nand_partitions), ++ .part_parsers = probes, + }; + + static struct resource sharpsl_nand_resources[] = { +@@ -750,9 +738,6 @@ static void __init corgi_init(void) + + platform_scoop_config = &corgi_pcmcia_config; + +- if (machine_is_husky()) +- sharpsl_nand_partitions[1].size = 53 * 1024 * 1024; +- + platform_add_devices(devices, ARRAY_SIZE(devices)); + + regulator_has_full_constraints(); +-- +2.7.4 + diff --git a/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0007-ARM-pxa-tosa-Remove-hardcoded-partitioning-use-sharp.patch b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0007-ARM-pxa-tosa-Remove-hardcoded-partitioning-use-sharp.patch new file mode 100644 index 0000000..99eaddc --- /dev/null +++ b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0007-ARM-pxa-tosa-Remove-hardcoded-partitioning-use-sharp.patch @@ -0,0 +1,67 @@ +From b602bc99fe20719124cbea076c62bc1365886973 Mon Sep 17 00:00:00 2001 +From: Andrea Adami <andrea.adami@gmail.com> +Date: Mon, 14 Aug 2017 16:48:06 +0200 +Subject: [PATCH v5 7/9] ARM: pxa/tosa: Remove hardcoded partitioning, use + sharpslpart parser + +With the introduction of sharpslpart partition parser we can now read the +offsets from NAND: we specify the list of the parsers as platform data, with +cmdlinepart and ofpart parsers first allowing to override the part. table +written in NAND. This is done here in the board file. + +Signed-off-by: Andrea Adami <andrea.adami@gmail.com> +--- + arch/arm/mach-pxa/tosa.c | 28 ++++++++-------------------- + 1 file changed, 8 insertions(+), 20 deletions(-) + +diff --git a/arch/arm/mach-pxa/tosa.c b/arch/arm/mach-pxa/tosa.c +index 13de660..b90560b 100644 +--- a/arch/arm/mach-pxa/tosa.c ++++ b/arch/arm/mach-pxa/tosa.c +@@ -673,24 +673,6 @@ static int tosa_tc6393xb_suspend(struct platform_device *dev) + return 0; + } + +-static struct mtd_partition tosa_nand_partition[] = { +- { +- .name = "smf", +- .offset = 0, +- .size = 7 * 1024 * 1024, +- }, +- { +- .name = "root", +- .offset = MTDPART_OFS_APPEND, +- .size = 28 * 1024 * 1024, +- }, +- { +- .name = "home", +- .offset = MTDPART_OFS_APPEND, +- .size = MTDPART_SIZ_FULL, +- }, +-}; +- + static uint8_t scan_ff_pattern[] = { 0xff, 0xff }; + + static struct nand_bbt_descr tosa_tc6393xb_nand_bbt = { +@@ -700,10 +682,16 @@ static struct nand_bbt_descr tosa_tc6393xb_nand_bbt = { + .pattern = scan_ff_pattern + }; + ++static const char * const probes[] = { ++ "cmdlinepart", ++ "ofpart", ++ "sharpslpart", ++ NULL, ++}; ++ + static struct tmio_nand_data tosa_tc6393xb_nand_config = { +- .num_partitions = ARRAY_SIZE(tosa_nand_partition), +- .partition = tosa_nand_partition, + .badblock_pattern = &tosa_tc6393xb_nand_bbt, ++ .part_parsers = probes, + }; + + static int tosa_tc6393xb_setup(struct platform_device *dev) +-- +2.7.4 + diff --git a/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0008-ARM-pxa-spitz-Remove-hardcoded-partitioning-use-shar.patch b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0008-ARM-pxa-spitz-Remove-hardcoded-partitioning-use-shar.patch new file mode 100644 index 0000000..f3c86bd --- /dev/null +++ b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0008-ARM-pxa-spitz-Remove-hardcoded-partitioning-use-shar.patch @@ -0,0 +1,80 @@ +From ff8d455c03fcc119bdbd0e811aa278843a1aa25e Mon Sep 17 00:00:00 2001 +From: Andrea Adami <andrea.adami@gmail.com> +Date: Mon, 14 Aug 2017 17:33:24 +0200 +Subject: [PATCH v5 8/9] ARM: pxa/spitz: Remove hardcoded partitioning, use + sharpslpart parser + +With the introduction of sharpslpart partition parser we can now read the +offsets from NAND: we specify the list of the parsers as platform data, with +cmdlinepart and ofpart parsers first allowing to override the part. table +written in NAND. This is done here in the board file. + +Signed-off-by: Andrea Adami <andrea.adami@gmail.com> +--- + arch/arm/mach-pxa/spitz.c | 34 +++++++++------------------------- + 1 file changed, 9 insertions(+), 25 deletions(-) + +diff --git a/arch/arm/mach-pxa/spitz.c b/arch/arm/mach-pxa/spitz.c +index 67d66c7..defefa3 100644 +--- a/arch/arm/mach-pxa/spitz.c ++++ b/arch/arm/mach-pxa/spitz.c +@@ -739,21 +739,6 @@ static inline void spitz_lcd_init(void) {} + * NAND Flash + ******************************************************************************/ + #if defined(CONFIG_MTD_NAND_SHARPSL) || defined(CONFIG_MTD_NAND_SHARPSL_MODULE) +-static struct mtd_partition spitz_nand_partitions[] = { +- { +- .name = "System Area", +- .offset = 0, +- .size = 7 * 1024 * 1024, +- }, { +- .name = "Root Filesystem", +- .offset = 7 * 1024 * 1024, +- }, { +- .name = "Home Filesystem", +- .offset = MTDPART_OFS_APPEND, +- .size = MTDPART_SIZ_FULL, +- }, +-}; +- + static uint8_t scan_ff_pattern[] = { 0xff, 0xff }; + + static struct nand_bbt_descr spitz_nand_bbt = { +@@ -808,10 +793,16 @@ static const struct mtd_ooblayout_ops akita_ooblayout_ops = { + .free = akita_ooblayout_free, + }; + ++static const char * const probes[] = { ++ "cmdlinepart", ++ "ofpart", ++ "sharpslpart", ++ NULL, ++}; ++ + static struct sharpsl_nand_platform_data spitz_nand_pdata = { + .badblock_pattern = &spitz_nand_bbt, +- .partitions = spitz_nand_partitions, +- .nr_partitions = ARRAY_SIZE(spitz_nand_partitions), ++ .part_parsers = probes, + }; + + static struct resource spitz_nand_resources[] = { +@@ -834,14 +825,7 @@ static struct platform_device spitz_nand_device = { + + static void __init spitz_nand_init(void) + { +- if (machine_is_spitz()) { +- spitz_nand_partitions[1].size = 5 * 1024 * 1024; +- } else if (machine_is_akita()) { +- spitz_nand_partitions[1].size = 58 * 1024 * 1024; +- spitz_nand_bbt.len = 1; +- spitz_nand_pdata.ecc_layout = &akita_ooblayout_ops; +- } else if (machine_is_borzoi()) { +- spitz_nand_partitions[1].size = 32 * 1024 * 1024; ++ if (machine_is_akita() || machine_is_borzoi()) { + spitz_nand_bbt.len = 1; + spitz_nand_pdata.ecc_layout = &akita_ooblayout_ops; + } +-- +2.7.4 + diff --git a/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0009-ARM-pxa-poodle-Remove-hardcoded-partitioning-use-sha.patch b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0009-ARM-pxa-poodle-Remove-hardcoded-partitioning-use-sha.patch new file mode 100644 index 0000000..9fa40a7 --- /dev/null +++ b/recipes-kernel/linux/linux-handheld-4.14/sharpslpart/0009-ARM-pxa-poodle-Remove-hardcoded-partitioning-use-sha.patch @@ -0,0 +1,67 @@ +From 9358ef85dce8971a198ad931cdeee8b43696a0f8 Mon Sep 17 00:00:00 2001 +From: Andrea Adami <andrea.adami@gmail.com> +Date: Mon, 14 Aug 2017 17:00:41 +0200 +Subject: [PATCH v5 9/9] ARM: pxa/poodle: Remove hardcoded partitioning, use + sharpslpart parser + +With the introduction of sharpslpart partition parser we can now read the +offsets from NAND: we specify the list of the parsers as platform data, with +cmdlinepart and ofpart parsers first allowing to override the part. table +written in NAND. This is done here in the board file. + +Signed-off-by: Andrea Adami <andrea.adami@gmail.com> +--- + arch/arm/mach-pxa/poodle.c | 28 ++++++++-------------------- + 1 file changed, 8 insertions(+), 20 deletions(-) + +diff --git a/arch/arm/mach-pxa/poodle.c b/arch/arm/mach-pxa/poodle.c +index 62a1191..fd01d6b 100644 +--- a/arch/arm/mach-pxa/poodle.c ++++ b/arch/arm/mach-pxa/poodle.c +@@ -333,24 +333,6 @@ static struct pxafb_mach_info poodle_fb_info = { + .lcd_conn = LCD_COLOR_TFT_16BPP, + }; + +-static struct mtd_partition sharpsl_nand_partitions[] = { +- { +- .name = "System Area", +- .offset = 0, +- .size = 7 * 1024 * 1024, +- }, +- { +- .name = "Root Filesystem", +- .offset = 7 * 1024 * 1024, +- .size = 22 * 1024 * 1024, +- }, +- { +- .name = "Home Filesystem", +- .offset = MTDPART_OFS_APPEND, +- .size = MTDPART_SIZ_FULL, +- }, +-}; +- + static uint8_t scan_ff_pattern[] = { 0xff, 0xff }; + + static struct nand_bbt_descr sharpsl_bbt = { +@@ -360,10 +342,16 @@ static struct nand_bbt_descr sharpsl_bbt = { + .pattern = scan_ff_pattern + }; + ++static const char * const probes[] = { ++ "cmdlinepart", ++ "ofpart", ++ "sharpslpart", ++ NULL, ++}; ++ + static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = { + .badblock_pattern = &sharpsl_bbt, +- .partitions = sharpsl_nand_partitions, +- .nr_partitions = ARRAY_SIZE(sharpsl_nand_partitions), ++ .part_parsers = probes, + }; + + static struct resource sharpsl_nand_resources[] = { +-- +2.7.4 + |