mirror of
git://git.openwrt.org/openwrt/openwrt.git
synced 2025-10-31 05:54:26 -04:00
49eec56bfc
I meant it to be GPL-2.0-only, as evidenced by the boilerplate. Signed-off-by: Thibaut VARÈNE <hacks@slashdirt.org>
366 lines
10 KiB
C
366 lines
10 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
||
/*
|
||
* Parser for MikroTik RouterBoot partitions.
|
||
*
|
||
* Copyright (C) 2020 Thibaut VARÈNE <hacks+kernel@slashdirt.org>
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify it
|
||
* under the terms of the GNU General Public License version 2 as published
|
||
* by the Free Software Foundation.
|
||
*
|
||
* This parser builds from the "fixed-partitions" one (see ofpart.c), but it can
|
||
* handle dynamic partitions as found on routerboot devices.
|
||
*
|
||
* DTS nodes are defined as follows:
|
||
* For fixed partitions:
|
||
* node-name@unit-address {
|
||
* reg = <prop-encoded-array>;
|
||
* label = <string>;
|
||
* read-only;
|
||
* lock;
|
||
* };
|
||
*
|
||
* reg property is mandatory; other properties are optional.
|
||
* reg format is <address length>. length can be 0 if the next partition is
|
||
* another fixed partition or a "well-known" partition as defined below: in that
|
||
* case the partition will extend up to the next one.
|
||
*
|
||
* For dynamic partitions:
|
||
* node-name {
|
||
* size = <prop-encoded-array>;
|
||
* label = <string>;
|
||
* read-only;
|
||
* lock;
|
||
* };
|
||
*
|
||
* size property is normally mandatory. It can only be omitted (or set to 0) if:
|
||
* - the partition is a "well-known" one (as defined below), in which case
|
||
* the partition size will be automatically adjusted; or
|
||
* - the next partition is a fixed one or a "well-known" one, in which case
|
||
* the current partition will extend up to the next one.
|
||
* Other properties are optional.
|
||
* size format is <length>.
|
||
* By default dynamic partitions are appended after the preceding one, except
|
||
* for "well-known" ones which are automatically located on flash.
|
||
*
|
||
* Well-known partitions (matched via label or node-name):
|
||
* - "hard_config"
|
||
* - "soft_config"
|
||
* - "dtb_config"
|
||
*
|
||
* Note: this parser will happily register 0-sized partitions if misused.
|
||
*
|
||
* This parser requires the DTS to list partitions in ascending order as
|
||
* expected on the MTD device.
|
||
*
|
||
* Since only the "hard_config" and "soft_config" partitions are used in OpenWRT,
|
||
* a minimal working DTS could define only these two partitions dynamically (in
|
||
* the right order, usually hard_config then soft_config).
|
||
*
|
||
* Note: some mips RB devices encode the hard_config offset and length in two
|
||
* consecutive u32 located at offset 0x14 (for ramips) or 0x24 (for ath79) on
|
||
* the SPI NOR flash. Unfortunately this seems inconsistent across machines and
|
||
* does not apply to e.g. ipq-based ones, so we ignore that information.
|
||
*
|
||
* Note: To find well-known partitions, this parser will go through the entire
|
||
* top mtd partition parsed, _before_ the DTS nodes are processed. This works
|
||
* well in the current state of affairs, and is a simpler implementation than
|
||
* searching for known partitions in the "holes" left between fixed-partition,
|
||
* _after_ processing DTS nodes.
|
||
*/
|
||
|
||
#include <linux/module.h>
|
||
#include <linux/slab.h>
|
||
#include <linux/mtd/mtd.h>
|
||
#include <linux/mtd/partitions.h>
|
||
#include <linux/of.h>
|
||
#include <linux/of_fdt.h>
|
||
#include <linux/libfdt_env.h>
|
||
#include <linux/string.h>
|
||
|
||
#define RB_MAGIC_HARD (('H') | ('a' << 8) | ('r' << 16) | ('d' << 24))
|
||
#define RB_MAGIC_SOFT (('S') | ('o' << 8) | ('f' << 16) | ('t' << 24))
|
||
#define RB_BLOCK_SIZE 0x1000
|
||
|
||
struct routerboot_dynpart {
|
||
const char * const name;
|
||
const u32 magic;
|
||
int (* const size_fixup)(struct mtd_info *, struct routerboot_dynpart *);
|
||
size_t offset;
|
||
size_t size;
|
||
bool found;
|
||
};
|
||
|
||
static int routerboot_dtbsfixup(struct mtd_info *, struct routerboot_dynpart *);
|
||
|
||
static struct routerboot_dynpart rb_dynparts[] = {
|
||
{
|
||
.name = "hard_config",
|
||
.magic = RB_MAGIC_HARD, // stored in CPU-endianness on flash
|
||
.size_fixup = NULL,
|
||
.offset = 0x0,
|
||
.size = RB_BLOCK_SIZE,
|
||
.found = false,
|
||
}, {
|
||
.name = "soft_config",
|
||
.magic = RB_MAGIC_SOFT, // stored in CPU-endianness on flash
|
||
.size_fixup = NULL,
|
||
.offset = 0x0,
|
||
.size = RB_BLOCK_SIZE,
|
||
.found = false,
|
||
}, {
|
||
.name = "dtb_config",
|
||
.magic = fdt32_to_cpu(OF_DT_HEADER), // stored BE on flash
|
||
.size_fixup = routerboot_dtbsfixup,
|
||
.offset = 0x0,
|
||
.size = 0x0,
|
||
.found = false,
|
||
}
|
||
};
|
||
|
||
static int routerboot_dtbsfixup(struct mtd_info *master, struct routerboot_dynpart *rbdpart)
|
||
{
|
||
int err;
|
||
size_t bytes_read, psize;
|
||
struct {
|
||
fdt32_t magic;
|
||
fdt32_t totalsize;
|
||
fdt32_t off_dt_struct;
|
||
fdt32_t off_dt_strings;
|
||
fdt32_t off_mem_rsvmap;
|
||
fdt32_t version;
|
||
fdt32_t last_comp_version;
|
||
fdt32_t boot_cpuid_phys;
|
||
fdt32_t size_dt_strings;
|
||
fdt32_t size_dt_struct;
|
||
} fdt_header;
|
||
|
||
err = mtd_read(master, rbdpart->offset, sizeof(fdt_header),
|
||
&bytes_read, (u8 *)&fdt_header);
|
||
if (err)
|
||
return err;
|
||
|
||
if (bytes_read != sizeof(fdt_header))
|
||
return -EIO;
|
||
|
||
psize = fdt32_to_cpu(fdt_header.totalsize);
|
||
if (!psize)
|
||
return -EINVAL;
|
||
|
||
rbdpart->size = psize;
|
||
return 0;
|
||
}
|
||
|
||
static void routerboot_find_dynparts(struct mtd_info *master)
|
||
{
|
||
size_t bytes_read, offset;
|
||
bool allfound;
|
||
int err, i;
|
||
u32 buf;
|
||
|
||
/*
|
||
* Dynamic RouterBoot partitions offsets are aligned to RB_BLOCK_SIZE:
|
||
* read the whole partition at RB_BLOCK_SIZE intervals to find sigs.
|
||
* Skip partition content when possible.
|
||
*/
|
||
offset = 0;
|
||
while (offset < master->size) {
|
||
err = mtd_read(master, offset, sizeof(buf), &bytes_read, (u8 *)&buf);
|
||
if (err) {
|
||
pr_err("%s: mtd_read error while parsing (offset: 0x%X): %d\n",
|
||
master->name, offset, err);
|
||
continue;
|
||
}
|
||
|
||
allfound = true;
|
||
|
||
for (i = 0; i < ARRAY_SIZE(rb_dynparts); i++) {
|
||
if (rb_dynparts[i].found)
|
||
continue;
|
||
|
||
allfound = false;
|
||
|
||
if (rb_dynparts[i].magic == buf) {
|
||
rb_dynparts[i].offset = offset;
|
||
|
||
if (rb_dynparts[i].size_fixup) {
|
||
err = rb_dynparts[i].size_fixup(master, &rb_dynparts[i]);
|
||
if (err) {
|
||
pr_err("%s: size fixup error while parsing \"%s\": %d\n",
|
||
master->name, rb_dynparts[i].name, err);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
rb_dynparts[i].found = true;
|
||
|
||
/*
|
||
* move offset to skip the whole partition on
|
||
* next iteration if size > RB_BLOCK_SIZE.
|
||
*/
|
||
if (rb_dynparts[i].size > RB_BLOCK_SIZE)
|
||
offset += ALIGN_DOWN((rb_dynparts[i].size - RB_BLOCK_SIZE), RB_BLOCK_SIZE);
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
offset += RB_BLOCK_SIZE;
|
||
|
||
if (allfound)
|
||
break;
|
||
}
|
||
}
|
||
|
||
static int routerboot_partitions_parse(struct mtd_info *master,
|
||
const struct mtd_partition **pparts,
|
||
struct mtd_part_parser_data *data)
|
||
{
|
||
struct device_node *rbpart_node, *pp;
|
||
struct mtd_partition *parts;
|
||
const char *partname;
|
||
size_t master_ofs;
|
||
int np;
|
||
|
||
/* Pull of_node from the master device node */
|
||
rbpart_node = mtd_get_of_node(master);
|
||
if (!rbpart_node)
|
||
return 0;
|
||
|
||
/* First count the subnodes */
|
||
np = 0;
|
||
for_each_child_of_node(rbpart_node, pp)
|
||
np++;
|
||
|
||
if (!np)
|
||
return 0;
|
||
|
||
parts = kcalloc(np, sizeof(*parts), GFP_KERNEL);
|
||
if (!parts)
|
||
return -ENOMEM;
|
||
|
||
/* Preemptively look for known parts in flash */
|
||
routerboot_find_dynparts(master);
|
||
|
||
np = 0;
|
||
master_ofs = 0;
|
||
for_each_child_of_node(rbpart_node, pp) {
|
||
const __be32 *reg, *sz;
|
||
size_t offset, size;
|
||
int i, len, a_cells, s_cells;
|
||
|
||
partname = of_get_property(pp, "label", &len);
|
||
/* Allow deprecated use of "name" instead of "label" */
|
||
if (!partname)
|
||
partname = of_get_property(pp, "name", &len);
|
||
/* Fallback to node name per spec if all else fails: partname is always set */
|
||
if (!partname)
|
||
partname = pp->name;
|
||
parts[np].name = partname;
|
||
|
||
reg = of_get_property(pp, "reg", &len);
|
||
if (reg) {
|
||
/* Fixed partition */
|
||
a_cells = of_n_addr_cells(pp);
|
||
s_cells = of_n_size_cells(pp);
|
||
|
||
if ((len / 4) != (a_cells + s_cells)) {
|
||
pr_debug("%s: routerboot partition %pOF (%pOF) error parsing reg property.\n",
|
||
master->name, pp, rbpart_node);
|
||
goto rbpart_fail;
|
||
}
|
||
|
||
offset = of_read_number(reg, a_cells);
|
||
size = of_read_number(reg + a_cells, s_cells);
|
||
} else {
|
||
/* Dynamic partition */
|
||
/* Default: part starts at current offset, 0 size */
|
||
offset = master_ofs;
|
||
size = 0;
|
||
|
||
/* Check if well-known partition */
|
||
for (i = 0; i < ARRAY_SIZE(rb_dynparts); i++) {
|
||
if (!strcmp(partname, rb_dynparts[i].name) && rb_dynparts[i].found) {
|
||
offset = rb_dynparts[i].offset;
|
||
size = rb_dynparts[i].size;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Standalone 'size' property? Override size */
|
||
sz = of_get_property(pp, "size", &len);
|
||
if (sz) {
|
||
s_cells = of_n_size_cells(pp);
|
||
if ((len / 4) != s_cells) {
|
||
pr_debug("%s: routerboot partition %pOF (%pOF) error parsing size property.\n",
|
||
master->name, pp, rbpart_node);
|
||
goto rbpart_fail;
|
||
}
|
||
|
||
size = of_read_number(sz, s_cells);
|
||
}
|
||
}
|
||
|
||
if (np > 0) {
|
||
/* Minor sanity check for overlaps */
|
||
if (offset < (parts[np-1].offset + parts[np-1].size)) {
|
||
pr_err("%s: routerboot partition %pOF (%pOF) \"%s\" overlaps with previous partition \"%s\".\n",
|
||
master->name, pp, rbpart_node,
|
||
partname, parts[np-1].name);
|
||
goto rbpart_fail;
|
||
}
|
||
|
||
/* Fixup end of previous partition if necessary */
|
||
if (!parts[np-1].size)
|
||
parts[np-1].size = (offset - parts[np-1].offset);
|
||
}
|
||
|
||
if ((offset + size) > master->size) {
|
||
pr_err("%s: routerboot partition %pOF (%pOF) \"%s\" extends past end of segment.\n",
|
||
master->name, pp, rbpart_node, partname);
|
||
goto rbpart_fail;
|
||
}
|
||
|
||
parts[np].offset = offset;
|
||
parts[np].size = size;
|
||
parts[np].of_node = pp;
|
||
|
||
if (of_get_property(pp, "read-only", &len))
|
||
parts[np].mask_flags |= MTD_WRITEABLE;
|
||
|
||
if (of_get_property(pp, "lock", &len))
|
||
parts[np].mask_flags |= MTD_POWERUP_LOCK;
|
||
|
||
/* Keep master offset aligned to RB_BLOCK_SIZE */
|
||
master_ofs = ALIGN(offset + size, RB_BLOCK_SIZE);
|
||
np++;
|
||
}
|
||
|
||
*pparts = parts;
|
||
return np;
|
||
|
||
rbpart_fail:
|
||
pr_err("%s: error parsing routerboot partition %pOF (%pOF)\n",
|
||
master->name, pp, rbpart_node);
|
||
of_node_put(pp);
|
||
kfree(parts);
|
||
return -EINVAL;
|
||
}
|
||
|
||
static const struct of_device_id parse_routerbootpart_match_table[] = {
|
||
{ .compatible = "mikrotik,routerboot-partitions" },
|
||
{},
|
||
};
|
||
MODULE_DEVICE_TABLE(of, parse_routerbootpart_match_table);
|
||
|
||
static struct mtd_part_parser routerbootpart_parser = {
|
||
.parse_fn = routerboot_partitions_parse,
|
||
.name = "routerbootpart",
|
||
.of_match_table = parse_routerbootpart_match_table,
|
||
};
|
||
module_mtd_part_parser(routerbootpart_parser);
|
||
|
||
MODULE_LICENSE("GPL v2");
|
||
MODULE_DESCRIPTION("MTD partitioning for RouterBoot");
|
||
MODULE_AUTHOR("Thibaut VARENE");
|