drivers/mtd/parsers/sharpslpart.c

   1 /*
   2  * sharpslpart.c - MTD partition parser for NAND flash using the SHARP FTL
   3  * for logical addressing, as used on the PXA models of the SHARP SL Series.
   4  *
   5  * Copyright (C) 2017 Andrea Adami <andrea.adami@gmail.com>
   6  *
   7  * Based on SHARP GPL 2.4 sources:
   8  *   http://support.ezaurus.com/developer/source/source_dl.asp
   9  *     drivers/mtd/nand/sharp_sl_logical.c
  10  *     linux/include/asm-arm/sharp_nand_logical.h
  11  *
  12  * Copyright (C) 2002 SHARP
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/slab.h>
  28 #include <linux/module.h>
  29 #include <linux/types.h>
  30 #include <linux/bitops.h>
  31 #include <linux/sizes.h>
  32 #include <linux/mtd/mtd.h>
  33 #include <linux/mtd/partitions.h>
  34
  35 /* oob structure */
  36 #define NAND_NOOB_LOGADDR_00            8
  37 #define NAND_NOOB_LOGADDR_01            9
  38 #define NAND_NOOB_LOGADDR_10            10
  39 #define NAND_NOOB_LOGADDR_11            11
  40 #define NAND_NOOB_LOGADDR_20            12
  41 #define NAND_NOOB_LOGADDR_21            13
  42
  43 #define BLOCK_IS_RESERVED               0xffff
  44 #define BLOCK_UNMASK_COMPLEMENT         1
  45
  46 /* factory defaults */
  47 #define SHARPSL_NAND_PARTS              3
  48 #define SHARPSL_FTL_PART_SIZE           (7 * SZ_1M)
  49 #define SHARPSL_PARTINFO1_LADDR         0x00060000
  50 #define SHARPSL_PARTINFO2_LADDR         0x00064000
  51
  52 #define BOOT_MAGIC                      0x424f4f54
  53 #define FSRO_MAGIC                      0x4653524f
  54 #define FSRW_MAGIC                      0x46535257
  55
  56 /**
  57  * struct sharpsl_ftl - Sharp FTL Logical Table
  58  * @logmax:             number of logical blocks
  59  * @log2phy:            the logical-to-physical table
  60  *
  61  * Structure containing the logical-to-physical translation table
  62  * used by the SHARP SL FTL.
  63  */
  64 struct sharpsl_ftl {
  65         unsigned int logmax;
  66         unsigned int *log2phy;
  67 };
  68
  69 /* verify that the OOB bytes 8 to 15 are free and available for the FTL */
  70 static int sharpsl_nand_check_ooblayout(struct mtd_info *mtd)
  71 {
  72         u8 freebytes = 0;
  73         int section = 0;
  74
  75         while (true) {
  76                 struct mtd_oob_region oobfree = { };
  77                 int ret, i;
  78
  79                 ret = mtd_ooblayout_free(mtd, section++, &oobfree);
  80                 if (ret)
  81                         break;
  82
  83                 if (!oobfree.length || oobfree.offset > 15 ||
  84                     (oobfree.offset + oobfree.length) < 8)
  85                         continue;
  86
  87                 i = oobfree.offset >= 8 ? oobfree.offset : 8;
  88                 for (; i < oobfree.offset + oobfree.length && i < 16; i++)
  89                         freebytes |= BIT(i - 8);
  90
  91                 if (freebytes == 0xff)
  92                         return 0;
  93         }
  94
  95         return -ENOTSUPP;
  96 }
  97
  98 static int sharpsl_nand_read_oob(struct mtd_info *mtd, loff_t offs, u8 *buf)
  99 {
 100         struct mtd_oob_ops ops = { };
 101         int ret;
 102
 103         ops.mode = MTD_OPS_PLACE_OOB;
 104         ops.ooblen = mtd->oobsize;
 105         ops.oobbuf = buf;
 106
 107         ret = mtd_read_oob(mtd, offs, &ops);
 108         if (ret != 0 || mtd->oobsize != ops.oobretlen)
 109                 return -1;
 110
 111         return 0;
 112 }
 113
 114 /*
 115  * The logical block number assigned to a physical block is stored in the OOB
 116  * of the first page, in 3 16-bit copies with the following layout:
 117  *
 118  * 01234567 89abcdef
 119  * -------- --------
 120  * ECC BB   xyxyxy
 121  *
 122  * When reading we check that the first two copies agree.
 123  * In case of error, matching is tried using the following pairs.
 124  * Reserved values 0xffff mean the block is kept for wear leveling.
 125  *
 126  * 01234567 89abcdef
 127  * -------- --------
 128  * ECC BB   xyxy    oob[8]==oob[10] && oob[9]==oob[11]   -> byte0=8   byte1=9
 129  * ECC BB     xyxy  oob[10]==oob[12] && oob[11]==oob[13] -> byte0=10  byte1=11
 130  * ECC BB   xy  xy  oob[12]==oob[8] && oob[13]==oob[9]   -> byte0=12  byte1=13
 131  */
 132 static int sharpsl_nand_get_logical_num(u8 *oob)
 133 {
 134         u16 us;
 135         int good0, good1;
 136
 137         if (oob[NAND_NOOB_LOGADDR_00] == oob[NAND_NOOB_LOGADDR_10] &&
 138             oob[NAND_NOOB_LOGADDR_01] == oob[NAND_NOOB_LOGADDR_11]) {
 139                 good0 = NAND_NOOB_LOGADDR_00;
 140                 good1 = NAND_NOOB_LOGADDR_01;
 141         } else if (oob[NAND_NOOB_LOGADDR_10] == oob[NAND_NOOB_LOGADDR_20] &&
 142                    oob[NAND_NOOB_LOGADDR_11] == oob[NAND_NOOB_LOGADDR_21]) {
 143                 good0 = NAND_NOOB_LOGADDR_10;
 144                 good1 = NAND_NOOB_LOGADDR_11;
 145         } else if (oob[NAND_NOOB_LOGADDR_20] == oob[NAND_NOOB_LOGADDR_00] &&
 146                    oob[NAND_NOOB_LOGADDR_21] == oob[NAND_NOOB_LOGADDR_01]) {
 147                 good0 = NAND_NOOB_LOGADDR_20;
 148                 good1 = NAND_NOOB_LOGADDR_21;
 149         } else {
 150                 return -EINVAL;
 151         }
 152
 153         us = oob[good0] | oob[good1] << 8;
 154
 155         /* parity check */
 156         if (hweight16(us) & BLOCK_UNMASK_COMPLEMENT)
 157                 return -EINVAL;
 158
 159         /* reserved */
 160         if (us == BLOCK_IS_RESERVED)
 161                 return BLOCK_IS_RESERVED;
 162
 163         return (us >> 1) & GENMASK(9, 0);
 164 }
 165
 166 static int sharpsl_nand_init_ftl(struct mtd_info *mtd, struct sharpsl_ftl *ftl)
 167 {
 168         unsigned int block_num, log_num, phymax;
 169         loff_t block_adr;
 170         u8 *oob;
 171         int i, ret;
 172
 173         oob = kzalloc(mtd->oobsize, GFP_KERNEL);
 174         if (!oob)
 175                 return -ENOMEM;
 176
 177         phymax = mtd_div_by_eb(SHARPSL_FTL_PART_SIZE, mtd);
 178
 179         /* FTL reserves 5% of the blocks + 1 spare  */
 180         ftl->logmax = ((phymax * 95) / 100) - 1;
 181
 182         ftl->log2phy = kmalloc_array(ftl->logmax, sizeof(*ftl->log2phy),
 183                                      GFP_KERNEL);
 184         if (!ftl->log2phy) {
 185                 ret = -ENOMEM;
 186                 goto exit;
 187         }
 188
 189         /* initialize ftl->log2phy */
 190         for (i = 0; i < ftl->logmax; i++)
 191                 ftl->log2phy[i] = UINT_MAX;
 192
 193         /* create physical-logical table */
 194         for (block_num = 0; block_num < phymax; block_num++) {
 195                 block_adr = (loff_t)block_num * mtd->erasesize;
 196
 197                 if (mtd_block_isbad(mtd, block_adr))
 198                         continue;
 199
 200                 if (sharpsl_nand_read_oob(mtd, block_adr, oob))
 201                         continue;
 202
 203                 /* get logical block */
 204                 log_num = sharpsl_nand_get_logical_num(oob);
 205
 206                 /* cut-off errors and skip the out-of-range values */
 207                 if (log_num > 0 && log_num < ftl->logmax) {
 208                         if (ftl->log2phy[log_num] == UINT_MAX)
 209                                 ftl->log2phy[log_num] = block_num;
 210                 }
 211         }
 212
 213         pr_info("Sharp SL FTL: %d blocks used (%d logical, %d reserved)\n",
 214                 phymax, ftl->logmax, phymax - ftl->logmax);
 215
 216         ret = 0;
 217 exit:
 218         kfree(oob);
 219         return ret;
 220 }
 221
 222 static void sharpsl_nand_cleanup_ftl(struct sharpsl_ftl *ftl)
 223 {
 224         kfree(ftl->log2phy);
 225 }
 226
 227 static int sharpsl_nand_read_laddr(struct mtd_info *mtd,
 228                                    loff_t from,
 229                                    size_t len,
 230                                    void *buf,
 231                                    struct sharpsl_ftl *ftl)
 232 {
 233         unsigned int log_num, final_log_num;
 234         unsigned int block_num;
 235         loff_t block_adr;
 236         loff_t block_ofs;
 237         size_t retlen;
 238         int err;
 239
 240         log_num = mtd_div_by_eb((u32)from, mtd);
 241         final_log_num = mtd_div_by_eb(((u32)from + len - 1), mtd);
 242
 243         if (len <= 0 || log_num >= ftl->logmax || final_log_num > log_num)
 244                 return -EINVAL;
 245
 246         block_num = ftl->log2phy[log_num];
 247         block_adr = (loff_t)block_num * mtd->erasesize;
 248         block_ofs = mtd_mod_by_eb((u32)from, mtd);
 249
 250         err = mtd_read(mtd, block_adr + block_ofs, len, &retlen, buf);
 251         /* Ignore corrected ECC errors */
 252         if (mtd_is_bitflip(err))
 253                 err = 0;
 254
 255         if (!err && retlen != len)
 256                 err = -EIO;
 257
 258         if (err)
 259                 pr_err("sharpslpart: error, read failed at %#llx\n",
 260                        block_adr + block_ofs);
 261
 262         return err;
 263 }
 264
 265 /*
 266  * MTD Partition Parser
 267  *
 268  * Sample values read from SL-C860
 269  *
 270  * # cat /proc/mtd
 271  * dev:    size   erasesize  name
 272  * mtd0: 006d0000 00020000 "Filesystem"
 273  * mtd1: 00700000 00004000 "smf"
 274  * mtd2: 03500000 00004000 "root"
 275  * mtd3: 04400000 00004000 "home"
 276  *
 277  * PARTITIONINFO1
 278  * 0x00060000: 00 00 00 00 00 00 70 00 42 4f 4f 54 00 00 00 00  ......p.BOOT....
 279  * 0x00060010: 00 00 70 00 00 00 c0 03 46 53 52 4f 00 00 00 00  ..p.....FSRO....
 280  * 0x00060020: 00 00 c0 03 00 00 00 04 46 53 52 57 00 00 00 00  ........FSRW....
 281  */
 282 struct sharpsl_nand_partinfo {
 283         __le32 start;
 284         __le32 end;
 285         __be32 magic;
 286         u32 reserved;
 287 };
 288
 289 static int sharpsl_nand_read_partinfo(struct mtd_info *master,
 290                                       loff_t from,
 291                                       size_t len,
 292                                       struct sharpsl_nand_partinfo *buf,
 293                                       struct sharpsl_ftl *ftl)
 294 {
 295         int ret;
 296
 297         ret = sharpsl_nand_read_laddr(master, from, len, buf, ftl);
 298         if (ret)
 299                 return ret;
 300
 301         /* check for magics */
 302         if (be32_to_cpu(buf[0].magic) != BOOT_MAGIC ||
 303             be32_to_cpu(buf[1].magic) != FSRO_MAGIC ||
 304             be32_to_cpu(buf[2].magic) != FSRW_MAGIC) {
 305                 pr_err("sharpslpart: magic values mismatch\n");
 306                 return -EINVAL;
 307         }
 308
 309         /* fixup for hardcoded value 64 MiB (for older models) */
 310         buf[2].end = cpu_to_le32(master->size);
 311
 312         /* extra sanity check */
 313         if (le32_to_cpu(buf[0].end) <= le32_to_cpu(buf[0].start) ||
 314             le32_to_cpu(buf[1].start) < le32_to_cpu(buf[0].end) ||
 315             le32_to_cpu(buf[1].end) <= le32_to_cpu(buf[1].start) ||
 316             le32_to_cpu(buf[2].start) < le32_to_cpu(buf[1].end) ||
 317             le32_to_cpu(buf[2].end) <= le32_to_cpu(buf[2].start)) {
 318                 pr_err("sharpslpart: partition sizes mismatch\n");
 319                 return -EINVAL;
 320         }
 321
 322         return 0;
 323 }
 324
 325 static int sharpsl_parse_mtd_partitions(struct mtd_info *master,
 326                                         const struct mtd_partition **pparts,
 327                                         struct mtd_part_parser_data *data)
 328 {
 329         struct sharpsl_ftl ftl;
 330         struct sharpsl_nand_partinfo buf[SHARPSL_NAND_PARTS];
 331         struct mtd_partition *sharpsl_nand_parts;
 332         int err;
 333
 334         /* check that OOB bytes 8 to 15 used by the FTL are actually free */
 335         err = sharpsl_nand_check_ooblayout(master);
 336         if (err)
 337                 return err;
 338
 339         /* init logical mgmt (FTL) */
 340         err = sharpsl_nand_init_ftl(master, &ftl);
 341         if (err)
 342                 return err;
 343
 344         /* read and validate first partition table */
 345         pr_info("sharpslpart: try reading first partition table\n");
 346         err = sharpsl_nand_read_partinfo(master,
 347                                          SHARPSL_PARTINFO1_LADDR,
 348                                          sizeof(buf), buf, &ftl);
 349         if (err) {
 350                 /* fallback: read second partition table */
 351                 pr_warn("sharpslpart: first partition table is invalid, retry using the second\n");
 352                 err = sharpsl_nand_read_partinfo(master,
 353                                                  SHARPSL_PARTINFO2_LADDR,
 354                                                  sizeof(buf), buf, &ftl);
 355         }
 356
 357         /* cleanup logical mgmt (FTL) */
 358         sharpsl_nand_cleanup_ftl(&ftl);
 359
 360         if (err) {
 361                 pr_err("sharpslpart: both partition tables are invalid\n");
 362                 return err;
 363         }
 364
 365         sharpsl_nand_parts = kzalloc(sizeof(*sharpsl_nand_parts) *
 366                                      SHARPSL_NAND_PARTS, GFP_KERNEL);
 367         if (!sharpsl_nand_parts)
 368                 return -ENOMEM;
 369
 370         /* original names */
 371         sharpsl_nand_parts[0].name = "smf";
 372         sharpsl_nand_parts[0].offset = le32_to_cpu(buf[0].start);
 373         sharpsl_nand_parts[0].size = le32_to_cpu(buf[0].end) -
 374                                      le32_to_cpu(buf[0].start);
 375
 376         sharpsl_nand_parts[1].name = "root";
 377         sharpsl_nand_parts[1].offset = le32_to_cpu(buf[1].start);
 378         sharpsl_nand_parts[1].size = le32_to_cpu(buf[1].end) -
 379                                      le32_to_cpu(buf[1].start);
 380
 381         sharpsl_nand_parts[2].name = "home";
 382         sharpsl_nand_parts[2].offset = le32_to_cpu(buf[2].start);
 383         sharpsl_nand_parts[2].size = le32_to_cpu(buf[2].end) -
 384                                      le32_to_cpu(buf[2].start);
 385
 386         *pparts = sharpsl_nand_parts;
 387         return SHARPSL_NAND_PARTS;
 388 }
 389
 390 static struct mtd_part_parser sharpsl_mtd_parser = {
 391         .parse_fn = sharpsl_parse_mtd_partitions,
 392         .name = "sharpslpart",
 393 };
 394 module_mtd_part_parser(sharpsl_mtd_parser);
 395
 396 MODULE_LICENSE("GPL");
 397 MODULE_AUTHOR("Andrea Adami <andrea.adami@gmail.com>");
 398 MODULE_DESCRIPTION("MTD partitioning for NAND flash on Sharp SL Series");