2 * MTD split for Broadcom Whole Flash Image
4 * Copyright (C) 2020 Álvaro Fernández Rojas <noltari@gmail.com>
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.
12 #define je16_to_cpu(x) ((x).v16)
13 #define je32_to_cpu(x) ((x).v32)
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>
27 #define char_to_num(c) ((c >= '0' && c <= '9') ? (c - '0') : (0))
29 #define BCM_WFI_PARTS 3
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)
38 #define UBI_MAGIC 0x55424923
40 #define CFE_MAGIC_PFX "cferam."
41 #define CFE_MAGIC_PFX_LEN (sizeof(CFE_MAGIC_PFX) - 1)
42 #define CFE_MAGIC "cferam.000"
43 #define CFE_MAGIC_LEN (sizeof(CFE_MAGIC) - 1)
44 #define SERCOMM_MAGIC_PFX "eRcOmM."
45 #define SERCOMM_MAGIC_PFX_LEN (sizeof(SERCOMM_MAGIC_PFX) - 1)
46 #define SERCOMM_MAGIC "eRcOmM.000"
47 #define SERCOMM_MAGIC_LEN (sizeof(SERCOMM_MAGIC) - 1)
49 static u32 jffs2_dirent_crc(struct jffs2_raw_dirent *node)
51 return crc32(0, node, sizeof(struct jffs2_raw_dirent) - 8);
54 static bool jffs2_dirent_valid(struct jffs2_raw_dirent *node)
56 return ((je16_to_cpu(node->magic) == JFFS2_MAGIC_BITMASK) &&
57 (je16_to_cpu(node->nodetype) == JFFS2_NODETYPE_DIRENT) &&
58 je32_to_cpu(node->ino) &&
59 je32_to_cpu(node->node_crc) == jffs2_dirent_crc(node));
62 static int jffs2_find_file(struct mtd_info *mtd, uint8_t *buf,
63 const char *name, size_t name_len,
64 loff_t *offs, loff_t size,
65 char **out_name, size_t *out_name_len)
67 const loff_t end = *offs + size;
68 struct jffs2_raw_dirent *node;
74 for (; *offs < end; *offs += mtd->erasesize) {
75 unsigned int block_offs = 0;
77 /* Skip CFE erased blocks */
78 rc = mtd_read(mtd, *offs, sizeof(magic), &retlen,
80 if (rc || retlen != sizeof(magic)) {
84 /* Skip blocks not starting with JFFS2 magic */
85 if (magic != JFFS2_MAGIC_BITMASK)
89 rc = mtd_read(mtd, *offs, mtd->erasesize, &retlen,
93 if (retlen != mtd->erasesize)
96 while (block_offs < mtd->erasesize) {
97 node = (struct jffs2_raw_dirent *) &buf[block_offs];
99 if (!jffs2_dirent_valid(node)) {
104 if (!memcmp(node->name, OPENWRT_NAME,
107 } else if (!memcmp(node->name, name, name_len)) {
112 *out_name = kstrndup(node->name,
117 *out_name_len = node->nsize;
122 block_offs += je32_to_cpu(node->totlen);
123 block_offs = (block_offs + 0x3) & ~0x3;
130 static int ubifs_find(struct mtd_info *mtd, loff_t *offs, loff_t size)
132 const loff_t end = *offs + size;
137 for (; *offs < end; *offs += mtd->erasesize) {
138 rc = mtd_read(mtd, *offs, sizeof(magic), &retlen,
139 (unsigned char *) &magic);
140 if (rc || retlen != sizeof(magic))
143 if (be32_to_cpu(magic) == UBI_MAGIC)
150 static int parse_bcm_wfi(struct mtd_info *master,
151 const struct mtd_partition **pparts,
152 uint8_t *buf, loff_t off, loff_t size, bool cfe_part)
154 struct mtd_partition *parts;
155 loff_t cfe_off, kernel_off, rootfs_off;
156 unsigned int num_parts = BCM_WFI_PARTS, cur_part = 0;
163 ret = jffs2_find_file(master, buf, CFERAM_NAME,
164 CFERAM_NAME_LEN, &cfe_off,
165 size - (cfe_off - off), NULL, NULL);
169 kernel_off = cfe_off + master->erasesize;
174 ret = jffs2_find_file(master, buf, KERNEL_NAME, KERNEL_NAME_LEN,
175 &kernel_off, size - (kernel_off - off),
180 rootfs_off = kernel_off + master->erasesize;
181 ret = ubifs_find(master, &rootfs_off, size - (rootfs_off - off));
185 parts = kzalloc(num_parts * sizeof(*parts), GFP_KERNEL);
190 parts[cur_part].name = "cferam";
191 parts[cur_part].mask_flags = MTD_WRITEABLE;
192 parts[cur_part].offset = cfe_off;
193 parts[cur_part].size = kernel_off - cfe_off;
197 parts[cur_part].name = "firmware";
198 parts[cur_part].offset = kernel_off;
199 parts[cur_part].size = size - (kernel_off - off);
202 parts[cur_part].name = KERNEL_PART_NAME;
203 parts[cur_part].offset = kernel_off;
204 parts[cur_part].size = rootfs_off - kernel_off;
207 parts[cur_part].name = UBI_PART_NAME;
208 parts[cur_part].offset = rootfs_off;
209 parts[cur_part].size = size - (rootfs_off - off);
217 static int mtdsplit_parse_bcm_wfi(struct mtd_info *master,
218 const struct mtd_partition **pparts,
219 struct mtd_part_parser_data *data)
221 struct device_node *mtd_node;
222 bool cfe_part = true;
226 mtd_node = mtd_get_of_node(master);
230 buf = kzalloc(master->erasesize, GFP_KERNEL);
234 if (of_property_read_bool(mtd_node, "brcm,no-cferam"))
237 ret = parse_bcm_wfi(master, pparts, buf, 0, master->size, cfe_part);
244 static const struct of_device_id mtdsplit_bcm_wfi_of_match[] = {
245 { .compatible = "brcm,wfi" },
249 static struct mtd_part_parser mtdsplit_bcm_wfi_parser = {
250 .owner = THIS_MODULE,
251 .name = "bcm-wfi-fw",
252 .of_match_table = mtdsplit_bcm_wfi_of_match,
253 .parse_fn = mtdsplit_parse_bcm_wfi,
254 .type = MTD_PARSER_TYPE_FIRMWARE,
257 static int cferam_bootflag_value(const char *name, size_t name_len)
262 (name_len >= CFE_MAGIC_LEN) &&
263 !memcmp(name, CFE_MAGIC_PFX, CFE_MAGIC_PFX_LEN)) {
264 rc = char_to_num(name[CFE_MAGIC_PFX_LEN + 0]) * 100;
265 rc += char_to_num(name[CFE_MAGIC_PFX_LEN + 1]) * 10;
266 rc += char_to_num(name[CFE_MAGIC_PFX_LEN + 2]) * 1;
272 static int mtdsplit_parse_bcm_wfi_split(struct mtd_info *master,
273 const struct mtd_partition **pparts,
274 struct mtd_part_parser_data *data)
278 loff_t img2_off = master->size / 2;
279 loff_t img1_size = (img2_off - img1_off);
280 loff_t img2_size = (master->size - img2_off);
281 loff_t active_off, inactive_off;
282 loff_t active_size, inactive_size;
284 char *cfe1_name = NULL, *cfe2_name = NULL;
285 size_t cfe1_size = 0, cfe2_size = 0;
289 buf = kzalloc(master->erasesize, GFP_KERNEL);
294 ret = jffs2_find_file(master, buf, CFERAM_NAME, CFERAM_NAME_LEN,
295 &cfe_off, img1_size, &cfe1_name, &cfe1_size);
298 ret = jffs2_find_file(master, buf, CFERAM_NAME, CFERAM_NAME_LEN,
299 &cfe_off, img2_size, &cfe2_name, &cfe2_size);
301 bf1 = cferam_bootflag_value(cfe1_name, cfe1_size);
303 printk("cferam: bootflag1=%d\n", bf1);
305 bf2 = cferam_bootflag_value(cfe2_name, cfe2_size);
307 printk("cferam: bootflag2=%d\n", bf2);
313 active_off = img1_off;
314 active_size = img1_size;
315 inactive_off = img2_off;
316 inactive_size = img2_size;
318 active_off = img2_off;
319 active_size = img2_size;
320 inactive_off = img1_off;
321 inactive_size = img1_size;
324 ret = parse_bcm_wfi(master, pparts, buf, active_off, active_size, true);
329 struct mtd_partition *parts;
331 parts = kzalloc((ret + 1) * sizeof(*parts), GFP_KERNEL);
335 memcpy(parts, *pparts, ret * sizeof(*parts));
338 parts[ret].name = "img2";
339 parts[ret].offset = inactive_off;
340 parts[ret].size = inactive_size;
349 static const struct of_device_id mtdsplit_bcm_wfi_split_of_match[] = {
350 { .compatible = "brcm,wfi-split" },
354 static struct mtd_part_parser mtdsplit_bcm_wfi_split_parser = {
355 .owner = THIS_MODULE,
356 .name = "bcm-wfi-split-fw",
357 .of_match_table = mtdsplit_bcm_wfi_split_of_match,
358 .parse_fn = mtdsplit_parse_bcm_wfi_split,
359 .type = MTD_PARSER_TYPE_FIRMWARE,
362 static int sercomm_bootflag_value(struct mtd_info *mtd, uint8_t *buf)
368 for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
369 rc = mtd_read(mtd, offs, SERCOMM_MAGIC_LEN, &retlen, buf);
370 if (rc || retlen != SERCOMM_MAGIC_LEN)
373 if (memcmp(buf, SERCOMM_MAGIC_PFX, SERCOMM_MAGIC_PFX_LEN))
376 rc = char_to_num(buf[SERCOMM_MAGIC_PFX_LEN + 0]) * 100;
377 rc += char_to_num(buf[SERCOMM_MAGIC_PFX_LEN + 1]) * 10;
378 rc += char_to_num(buf[SERCOMM_MAGIC_PFX_LEN + 2]) * 1;
386 static int mtdsplit_parse_ser_wfi(struct mtd_info *master,
387 const struct mtd_partition **pparts,
388 struct mtd_part_parser_data *data)
390 struct mtd_info *mtd_bf1, *mtd_bf2;
391 struct erase_info bf_erase;
393 loff_t img2_off = master->size / 2;
394 loff_t img1_size = (img2_off - img1_off);
395 loff_t img2_size = (master->size - img2_off);
396 loff_t active_off, inactive_off;
397 loff_t active_size, inactive_size;
402 mtd_bf1 = get_mtd_device_nm("bootflag1");
406 mtd_bf2 = get_mtd_device_nm("bootflag2");
410 buf = kzalloc(master->erasesize, GFP_KERNEL);
414 bf1 = sercomm_bootflag_value(mtd_bf1, buf);
416 printk("sercomm: bootflag1=%d\n", bf1);
418 bf2 = sercomm_bootflag_value(mtd_bf2, buf);
420 printk("sercomm: bootflag2=%d\n", bf2);
422 if (bf1 == bf2 && bf2 >= 0) {
425 bf_erase.len = mtd_bf2->size;
426 mtd_erase(mtd_bf2, &bf_erase);
430 active_off = img1_off;
431 active_size = img1_size;
432 inactive_off = img2_off;
433 inactive_size = img2_size;
435 active_off = img2_off;
436 active_size = img2_size;
437 inactive_off = img1_off;
438 inactive_size = img1_size;
441 ret = parse_bcm_wfi(master, pparts, buf, active_off, active_size, false);
446 struct mtd_partition *parts;
448 parts = kzalloc((ret + 1) * sizeof(*parts), GFP_KERNEL);
452 memcpy(parts, *pparts, ret * sizeof(*parts));
455 parts[ret].name = "img2";
456 parts[ret].offset = inactive_off;
457 parts[ret].size = inactive_size;
466 static const struct of_device_id mtdsplit_ser_wfi_of_match[] = {
467 { .compatible = "sercomm,wfi" },
471 static struct mtd_part_parser mtdsplit_ser_wfi_parser = {
472 .owner = THIS_MODULE,
473 .name = "ser-wfi-fw",
474 .of_match_table = mtdsplit_ser_wfi_of_match,
475 .parse_fn = mtdsplit_parse_ser_wfi,
476 .type = MTD_PARSER_TYPE_FIRMWARE,
479 static int __init mtdsplit_bcm_wfi_init(void)
481 register_mtd_parser(&mtdsplit_bcm_wfi_parser);
482 register_mtd_parser(&mtdsplit_bcm_wfi_split_parser);
483 register_mtd_parser(&mtdsplit_ser_wfi_parser);
488 module_init(mtdsplit_bcm_wfi_init);