target/linux/generic/files/drivers/mtd/mtdsplit/mtdsplit_bcm_wfi.c

   1 /*
   2  * MTD split for Broadcom Whole Flash Image
   3  *
   4  * Copyright (C) 2020 Álvaro Fernández Rojas <noltari@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation.
   9  *
  10  */
  11
  12 #define je16_to_cpu(x) ((x).v16)
  13 #define je32_to_cpu(x) ((x).v32)
  14
  15 #include <linux/crc32.h>
  16 #include <linux/init.h>
  17 #include <linux/jffs2.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/slab.h>
  21 #include <linux/byteorder/generic.h>
  22 #include <linux/mtd/mtd.h>
  23 #include <linux/mtd/partitions.h>
  24
  25 #include "mtdsplit.h"
  26
  27 #define char_to_num(c)          ((c >= '0' && c <= '9') ? (c - '0') : (0))
  28
  29 #define BCM_WFI_PARTS           3
  30
  31 #define CFERAM_NAME             "cferam"
  32 #define CFERAM_NAME_LEN         (sizeof(CFERAM_NAME) - 1)
  33 #define KERNEL_NAME             "vmlinux.lz"
  34 #define KERNEL_NAME_LEN         (sizeof(KERNEL_NAME) - 1)
  35 #define OPENWRT_NAME            "1-openwrt"
  36 #define OPENWRT_NAME_LEN        (sizeof(OPENWRT_NAME) - 1)
  37
  38 #define UBI_MAGIC               0x55424923
  39
  40 #define SERCOMM_MAGIC_PFX       "eRcOmM."
  41 #define SERCOMM_MAGIC_PFX_LEN   (sizeof(SERCOMM_MAGIC_PFX) - 1)
  42 #define SERCOMM_MAGIC           "eRcOmM.000"
  43 #define SERCOMM_MAGIC_LEN       (sizeof(SERCOMM_MAGIC) - 1)
  44
  45 static u32 jffs2_dirent_crc(struct jffs2_raw_dirent *node)
  46 {
  47         return crc32(0, node, sizeof(struct jffs2_raw_dirent) - 8);
  48 }
  49
  50 static bool jffs2_dirent_valid(struct jffs2_raw_dirent *node)
  51 {
  52         return ((je16_to_cpu(node->magic) == JFFS2_MAGIC_BITMASK) &&
  53                 (je16_to_cpu(node->nodetype) == JFFS2_NODETYPE_DIRENT) &&
  54                 je32_to_cpu(node->ino) &&
  55                 je32_to_cpu(node->node_crc) == jffs2_dirent_crc(node));
  56 }
  57
  58 static int jffs2_find_file(struct mtd_info *mtd, uint8_t *buf,
  59                            const char *name, size_t name_len,
  60                            loff_t *offs, loff_t size)
  61 {
  62         const loff_t end = *offs + size;
  63         struct jffs2_raw_dirent *node;
  64         bool valid = false;
  65         size_t retlen;
  66         uint16_t magic;
  67         int rc;
  68
  69         for (; *offs < end; *offs += mtd->erasesize) {
  70                 unsigned int block_offs = 0;
  71
  72                 /* Skip CFE erased blocks */
  73                 rc = mtd_read(mtd, *offs, sizeof(magic), &retlen,
  74                               (void *) &magic);
  75                 if (rc || retlen != sizeof(magic)) {
  76                         continue;
  77                 }
  78
  79                 /* Skip blocks not starting with JFFS2 magic */
  80                 if (magic != JFFS2_MAGIC_BITMASK)
  81                         continue;
  82
  83                 /* Read full block */
  84                 rc = mtd_read(mtd, *offs, mtd->erasesize, &retlen,
  85                               (void *) buf);
  86                 if (rc)
  87                         return rc;
  88                 if (retlen != mtd->erasesize)
  89                         return -EINVAL;
  90
  91                 while (block_offs < mtd->erasesize) {
  92                         node = (struct jffs2_raw_dirent *) &buf[block_offs];
  93
  94                         if (!jffs2_dirent_valid(node)) {
  95                                 block_offs += 4;
  96                                 continue;
  97                         }
  98
  99                         if (!memcmp(node->name, OPENWRT_NAME,
 100                                     OPENWRT_NAME_LEN))
 101                                 valid = true;
 102                         else if (!memcmp(node->name, name, name_len))
 103                                 return valid ? 0 : -EINVAL;
 104
 105                         block_offs += je32_to_cpu(node->totlen);
 106                         block_offs = (block_offs + 0x3) & ~0x3;
 107                 }
 108         }
 109
 110         return -ENOENT;
 111 }
 112
 113 static int ubifs_find(struct mtd_info *mtd, loff_t *offs, loff_t size)
 114 {
 115         const loff_t end = *offs + size;
 116         uint32_t magic;
 117         size_t retlen;
 118         int rc;
 119
 120         for (; *offs < end; *offs += mtd->erasesize) {
 121                 rc = mtd_read(mtd, *offs, sizeof(magic), &retlen,
 122                               (unsigned char *) &magic);
 123                 if (rc || retlen != sizeof(magic))
 124                         continue;
 125
 126                 if (be32_to_cpu(magic) == UBI_MAGIC)
 127                         return 0;
 128         }
 129
 130         return -ENOENT;
 131 }
 132
 133 static int mtdsplit_parse_bcm_wfi(struct mtd_info *master,
 134                                   const struct mtd_partition **pparts,
 135                                   struct mtd_part_parser_data *data)
 136 {
 137         struct mtd_partition *parts;
 138         struct device_node *mtd_node;
 139         loff_t cfe_off, kernel_off, rootfs_off;
 140         bool cfe_part = true;
 141         unsigned int num_parts = BCM_WFI_PARTS, cur_part = 0;
 142         uint8_t *buf;
 143         int ret;
 144
 145         buf = kzalloc(master->erasesize, GFP_KERNEL);
 146         if (!buf)
 147                 return -ENOMEM;
 148
 149         mtd_node = mtd_get_of_node(master);
 150         if (!mtd_node)
 151                 return -EINVAL;
 152
 153         if (of_device_is_compatible(mtd_node, "brcm,wfi-sercomm"))
 154                 cfe_part = false;
 155
 156         if (cfe_part) {
 157                 num_parts++;
 158                 cfe_off = 0;
 159
 160                 ret = jffs2_find_file(master, buf, CFERAM_NAME,
 161                                       CFERAM_NAME_LEN, &cfe_off,
 162                                       master->size);
 163                 if (ret) {
 164                         kfree(buf);
 165                         return ret;
 166                 }
 167
 168                 kernel_off = cfe_off + master->erasesize;
 169         } else {
 170                 kernel_off = 0;
 171         }
 172
 173         ret = jffs2_find_file(master, buf, KERNEL_NAME, KERNEL_NAME_LEN,
 174                               &kernel_off, master->size);
 175         kfree(buf);
 176         if (ret)
 177                 return ret;
 178
 179         rootfs_off = kernel_off + master->erasesize;
 180         ret = ubifs_find(master, &rootfs_off, master->size);
 181         if (ret)
 182                 return ret;
 183
 184         parts = kzalloc(num_parts * sizeof(*parts), GFP_KERNEL);
 185         if (!parts)
 186                 return -ENOMEM;
 187
 188         if (cfe_part) {
 189                 parts[cur_part].name = "cferam";
 190                 parts[cur_part].mask_flags = MTD_WRITEABLE;
 191                 parts[cur_part].offset = 0;
 192                 parts[cur_part].size = kernel_off;
 193                 cur_part++;
 194         }
 195
 196         parts[cur_part].name = "firmware";
 197         parts[cur_part].offset = kernel_off;
 198         parts[cur_part].size = master->size - kernel_off;
 199         cur_part++;
 200
 201         parts[cur_part].name = KERNEL_PART_NAME;
 202         parts[cur_part].offset = kernel_off;
 203         parts[cur_part].size = rootfs_off - kernel_off;
 204         cur_part++;
 205
 206         parts[cur_part].name = UBI_PART_NAME;
 207         parts[cur_part].offset = rootfs_off;
 208         parts[cur_part].size = master->size - rootfs_off;
 209         cur_part++;
 210
 211         *pparts = parts;
 212
 213         return num_parts;
 214 }
 215
 216 static const struct of_device_id mtdsplit_bcm_wfi_of_match[] = {
 217         { .compatible = "brcm,wfi" },
 218         { .compatible = "brcm,wfi-sercomm" },
 219         { },
 220 };
 221
 222 static struct mtd_part_parser mtdsplit_bcm_wfi_parser = {
 223         .owner = THIS_MODULE,
 224         .name = "bcm-wfi-fw",
 225         .of_match_table = mtdsplit_bcm_wfi_of_match,
 226         .parse_fn = mtdsplit_parse_bcm_wfi,
 227         .type = MTD_PARSER_TYPE_FIRMWARE,
 228 };
 229
 230 static int sercomm_bootflag_value(struct mtd_info *mtd, uint8_t *buf)
 231 {
 232         size_t retlen;
 233         loff_t offs;
 234         int rc;
 235
 236         for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
 237                 rc = mtd_read(mtd, offs, SERCOMM_MAGIC_LEN, &retlen, buf);
 238                 if (rc || retlen != SERCOMM_MAGIC_LEN)
 239                         continue;
 240
 241                 if (memcmp(buf, SERCOMM_MAGIC_PFX, SERCOMM_MAGIC_PFX_LEN))
 242                         continue;
 243
 244                 rc = char_to_num(buf[SERCOMM_MAGIC_PFX_LEN + 0]) * 100;
 245                 rc += char_to_num(buf[SERCOMM_MAGIC_PFX_LEN + 1]) * 10;
 246                 rc += char_to_num(buf[SERCOMM_MAGIC_PFX_LEN + 2]) * 1;
 247
 248                 return rc;
 249         }
 250
 251         return -ENOENT;
 252 }
 253
 254 static int mtdsplit_parse_ser_wfi(struct mtd_info *master,
 255                                   const struct mtd_partition **pparts,
 256                                   struct mtd_part_parser_data *data)
 257 {
 258         struct mtd_info *mtd_bf1, *mtd_bf2;
 259         struct erase_info bf_erase;
 260         struct mtd_partition *parts;
 261         loff_t kernel_off, rootfs_off, img_size;
 262         loff_t img2_off, img2_size = 0;
 263         unsigned int num_parts = BCM_WFI_PARTS, cur_part = 0;
 264         uint8_t *buf;
 265         int bf1, bf2;
 266         int ret;
 267
 268         mtd_bf1 = get_mtd_device_nm("bootflag1");
 269         if (IS_ERR(mtd_bf1))
 270                 return -ENOENT;
 271
 272         mtd_bf2 = get_mtd_device_nm("bootflag2");
 273         if (IS_ERR(mtd_bf2))
 274                 return -ENOENT;
 275
 276         buf = kzalloc(master->erasesize, GFP_KERNEL);
 277         if (!buf)
 278                 return -ENOMEM;
 279
 280         bf1 = sercomm_bootflag_value(mtd_bf1, buf);
 281         if (bf1 >= 0)
 282                 printk("sercomm: bootflag1=%d\n", bf1);
 283
 284         bf2 = sercomm_bootflag_value(mtd_bf2, buf);
 285         if (bf2 >= 0)
 286                 printk("sercomm: bootflag2=%d\n", bf2);
 287
 288         if (bf1 == bf2 && bf2 >= 0) {
 289                 bf2 = -ENOENT;
 290                 bf_erase.addr = 0;
 291                 bf_erase.len = mtd_bf2->size;
 292                 mtd_erase(mtd_bf2, &bf_erase);
 293         }
 294
 295         if (bf1 >= bf2) {
 296                 kernel_off = 0;
 297                 if (bf2 >= 0) {
 298                         img_size = master->size / 2;
 299
 300                         img2_off = img_size;
 301                         img2_size = master->size - img2_off;
 302                         num_parts++;
 303                 } else {
 304                         img_size = master->size;
 305                 }
 306         } else {
 307                 kernel_off = master->size / 2;
 308                 img_size = master->size;
 309
 310                 img2_off = 0;
 311                 img2_size = kernel_off;
 312                 num_parts++;
 313         }
 314
 315         ret = jffs2_find_file(master, buf, KERNEL_NAME, KERNEL_NAME_LEN,
 316                               &kernel_off, img_size);
 317         kfree(buf);
 318         if (ret)
 319                 return ret;
 320
 321         rootfs_off = kernel_off + master->erasesize;
 322         ret = ubifs_find(master, &rootfs_off, img_size);
 323         if (ret)
 324                 return ret;
 325
 326         parts = kzalloc(num_parts * sizeof(*parts), GFP_KERNEL);
 327         if (!parts)
 328                 return -ENOMEM;
 329
 330         parts[cur_part].name = "firmware";
 331         parts[cur_part].offset = kernel_off;
 332         parts[cur_part].size = img_size - kernel_off;
 333         cur_part++;
 334
 335         parts[cur_part].name = KERNEL_PART_NAME;
 336         parts[cur_part].offset = kernel_off;
 337         parts[cur_part].size = rootfs_off - kernel_off;
 338         cur_part++;
 339
 340         parts[cur_part].name = UBI_PART_NAME;
 341         parts[cur_part].offset = rootfs_off;
 342         parts[cur_part].size = img_size - rootfs_off;
 343         cur_part++;
 344
 345         if (img2_size) {
 346                 parts[cur_part].name = "img2";
 347                 parts[cur_part].offset = img2_off;
 348                 parts[cur_part].size = img2_size;
 349                 cur_part++;
 350         }
 351
 352         *pparts = parts;
 353
 354         return num_parts;
 355 }
 356
 357 static const struct of_device_id mtdsplit_ser_wfi_of_match[] = {
 358         { .compatible = "sercomm,wfi" },
 359         { },
 360 };
 361
 362 static struct mtd_part_parser mtdsplit_ser_wfi_parser = {
 363         .owner = THIS_MODULE,
 364         .name = "ser-wfi-fw",
 365         .of_match_table = mtdsplit_ser_wfi_of_match,
 366         .parse_fn = mtdsplit_parse_ser_wfi,
 367         .type = MTD_PARSER_TYPE_FIRMWARE,
 368 };
 369
 370 static int __init mtdsplit_bcm_wfi_init(void)
 371 {
 372         register_mtd_parser(&mtdsplit_bcm_wfi_parser);
 373         register_mtd_parser(&mtdsplit_ser_wfi_parser);
 374
 375         return 0;
 376 }
 377
 378 module_init(mtdsplit_bcm_wfi_init);