#include <linux/vmalloc.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
+#include <linux/version.h>
#include <linux/byteorder/generic.h>
+#include <linux/of.h>
#include "mtdsplit.h"
/*
* uimage_header itself is only 64B, but it may be prepended with another data.
- * Currently the biggest size is for Edimax devices: 20B + 64B
+ * Currently the biggest size is for Fon(Foxconn) devices: 64B + 32B
*/
-#define MAX_HEADER_LEN 84
+#define MAX_HEADER_LEN 96
#define IH_MAGIC 0x27051956 /* Image Magic Number */
#define IH_NMLEN 32 /* Image Name Length */
* __mtdsplit_parse_uimage - scan partition and create kernel + rootfs parts
*
* @find_header: function to call for a block of data that will return offset
- * of a valid uImage header if found
+ * and tail padding length of a valid uImage header if found
*/
static int __mtdsplit_parse_uimage(struct mtd_info *master,
- struct mtd_partition **pparts,
- struct mtd_part_parser_data *data,
- ssize_t (*find_header)(u_char *buf, size_t len))
+ const struct mtd_partition **pparts,
+ struct mtd_part_parser_data *data,
+ ssize_t (*find_header)(u_char *buf, size_t len, int *extralen))
{
struct mtd_partition *parts;
u_char *buf;
size_t rootfs_size = 0;
int uimage_part, rf_part;
int ret;
+ int extralen;
enum mtdsplit_part_type type;
nr_parts = 2;
if (ret)
continue;
- ret = find_header(buf, MAX_HEADER_LEN);
+ extralen = 0;
+ ret = find_header(buf, MAX_HEADER_LEN, &extralen);
if (ret < 0) {
pr_debug("no valid uImage found in \"%s\" at offset %llx\n",
master->name, (unsigned long long) offset);
}
header = (struct uimage_header *)(buf + ret);
- uimage_size = sizeof(*header) + be32_to_cpu(header->ih_size);
+ uimage_size = sizeof(*header) +
+ be32_to_cpu(header->ih_size) + ret + extralen;
+
if ((offset + uimage_size) > master->size) {
pr_debug("uImage exceeds MTD device \"%s\"\n",
master->name);
return ret;
}
-static ssize_t uimage_verify_default(u_char *buf, size_t len)
+static ssize_t uimage_verify_default(u_char *buf, size_t len, int *extralen)
{
struct uimage_header *header = (struct uimage_header *)buf;
static int
mtdsplit_uimage_parse_generic(struct mtd_info *master,
- struct mtd_partition **pparts,
+ const struct mtd_partition **pparts,
struct mtd_part_parser_data *data)
{
return __mtdsplit_parse_uimage(master, pparts, data,
uimage_verify_default);
}
+static const struct of_device_id mtdsplit_uimage_of_match_table[] = {
+ { .compatible = "denx,uimage" },
+ {},
+};
+
static struct mtd_part_parser uimage_generic_parser = {
.owner = THIS_MODULE,
.name = "uimage-fw",
+ .of_match_table = mtdsplit_uimage_of_match_table,
.parse_fn = mtdsplit_uimage_parse_generic,
.type = MTD_PARSER_TYPE_FIRMWARE,
};
+#define FW_MAGIC_GS110TPPV1 0x4e474520
+#define FW_MAGIC_WNR2000V1 0x32303031
#define FW_MAGIC_WNR2000V3 0x32303033
#define FW_MAGIC_WNR2000V4 0x32303034
#define FW_MAGIC_WNR2200 0x32323030
#define FW_MAGIC_WNDR3700V2 0x33373031
#define FW_MAGIC_WPN824N 0x31313030
-static ssize_t uimage_verify_wndr3700(u_char *buf, size_t len)
+static ssize_t uimage_verify_wndr3700(u_char *buf, size_t len, int *extralen)
{
struct uimage_header *header = (struct uimage_header *)buf;
uint8_t expected_type = IH_TYPE_FILESYSTEM;
- switch be32_to_cpu(header->ih_magic) {
+ switch (be32_to_cpu(header->ih_magic)) {
+ case FW_MAGIC_GS110TPPV1:
+ case FW_MAGIC_WNR2000V4:
+ expected_type = IH_TYPE_KERNEL;
+ break;
case FW_MAGIC_WNR612V2:
case FW_MAGIC_WNR1000V2:
case FW_MAGIC_WNR1000V2_VC:
+ case FW_MAGIC_WNR2000V1:
case FW_MAGIC_WNR2000V3:
case FW_MAGIC_WNR2200:
case FW_MAGIC_WNDR3700:
case FW_MAGIC_WNDR3700V2:
case FW_MAGIC_WPN824N:
break;
- case FW_MAGIC_WNR2000V4:
- expected_type = IH_TYPE_KERNEL;
- break;
default:
return -EINVAL;
}
static int
mtdsplit_uimage_parse_netgear(struct mtd_info *master,
- struct mtd_partition **pparts,
+ const struct mtd_partition **pparts,
struct mtd_part_parser_data *data)
{
return __mtdsplit_parse_uimage(master, pparts, data,
uimage_verify_wndr3700);
}
+static const struct of_device_id mtdsplit_uimage_netgear_of_match_table[] = {
+ { .compatible = "netgear,uimage" },
+ {},
+};
+
static struct mtd_part_parser uimage_netgear_parser = {
.owner = THIS_MODULE,
.name = "netgear-fw",
+ .of_match_table = mtdsplit_uimage_netgear_of_match_table,
.parse_fn = mtdsplit_uimage_parse_netgear,
.type = MTD_PARSER_TYPE_FIRMWARE,
+
};
+
+/**************************************************
+ * ALLNET
+ **************************************************/
+
+#define FW_MAGIC_SG8208M 0x00000006
+#define FW_MAGIC_SG8310PM 0x83000006
+
+static ssize_t uimage_verify_allnet(u_char *buf, size_t len, int *extralen)
+{
+ struct uimage_header *header = (struct uimage_header *)buf;
+
+ switch (be32_to_cpu(header->ih_magic)) {
+ case FW_MAGIC_SG8208M:
+ case FW_MAGIC_SG8310PM:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ if (header->ih_os != IH_OS_LINUX)
+ return -EINVAL;
+
+ return 0;
+}
+
+static int
+mtdsplit_uimage_parse_allnet(struct mtd_info *master,
+ const struct mtd_partition **pparts,
+ struct mtd_part_parser_data *data)
+{
+ return __mtdsplit_parse_uimage(master, pparts, data,
+ uimage_verify_allnet);
+}
+
+static const struct of_device_id mtdsplit_uimage_allnet_of_match_table[] = {
+ { .compatible = "allnet,uimage" },
+ {},
+};
+
+static struct mtd_part_parser uimage_allnet_parser = {
+ .owner = THIS_MODULE,
+ .name = "allnet-fw",
+ .of_match_table = mtdsplit_uimage_allnet_of_match_table,
+ .parse_fn = mtdsplit_uimage_parse_allnet,
+};
+
+
/**************************************************
* Edimax
**************************************************/
#define FW_EDIMAX_OFFSET 20
#define FW_MAGIC_EDIMAX 0x43535953
-static ssize_t uimage_find_edimax(u_char *buf, size_t len)
+static ssize_t uimage_find_edimax(u_char *buf, size_t len, int *extralen)
{
- struct uimage_header *header;
+ u32 *magic;
- if (len < FW_EDIMAX_OFFSET + sizeof(*header)) {
+ if (len < FW_EDIMAX_OFFSET + sizeof(struct uimage_header)) {
pr_err("Buffer too small for checking Edimax header\n");
return -ENOSPC;
}
- header = (struct uimage_header *)(buf + FW_EDIMAX_OFFSET);
-
- switch be32_to_cpu(header->ih_magic) {
- case FW_MAGIC_EDIMAX:
- break;
- default:
+ magic = (u32 *)buf;
+ if (be32_to_cpu(*magic) != FW_MAGIC_EDIMAX)
return -EINVAL;
- }
- if (header->ih_os != IH_OS_LINUX ||
- header->ih_type != IH_TYPE_FILESYSTEM)
- return -EINVAL;
+ if (!uimage_verify_default(buf + FW_EDIMAX_OFFSET, len, extralen))
+ return FW_EDIMAX_OFFSET;
- return FW_EDIMAX_OFFSET;
+ return -EINVAL;
}
static int
mtdsplit_uimage_parse_edimax(struct mtd_info *master,
- struct mtd_partition **pparts,
+ const struct mtd_partition **pparts,
struct mtd_part_parser_data *data)
{
return __mtdsplit_parse_uimage(master, pparts, data,
uimage_find_edimax);
}
+static const struct of_device_id mtdsplit_uimage_edimax_of_match_table[] = {
+ { .compatible = "edimax,uimage" },
+ {},
+};
+
static struct mtd_part_parser uimage_edimax_parser = {
.owner = THIS_MODULE,
.name = "edimax-fw",
+ .of_match_table = mtdsplit_uimage_edimax_of_match_table,
.parse_fn = mtdsplit_uimage_parse_edimax,
.type = MTD_PARSER_TYPE_FIRMWARE,
};
+
+/**************************************************
+ * Fon(Foxconn)
+ **************************************************/
+
+#define FONFXC_PAD_LEN 32
+
+static ssize_t uimage_find_fonfxc(u_char *buf, size_t len, int *extralen)
+{
+ if (uimage_verify_default(buf, len, extralen) < 0)
+ return -EINVAL;
+
+ *extralen = FONFXC_PAD_LEN;
+
+ return 0;
+}
+
+static int
+mtdsplit_uimage_parse_fonfxc(struct mtd_info *master,
+ const struct mtd_partition **pparts,
+ struct mtd_part_parser_data *data)
+{
+ return __mtdsplit_parse_uimage(master, pparts, data,
+ uimage_find_fonfxc);
+}
+
+static const struct of_device_id mtdsplit_uimage_fonfxc_of_match_table[] = {
+ { .compatible = "fonfxc,uimage" },
+ {},
+};
+
+static struct mtd_part_parser uimage_fonfxc_parser = {
+ .owner = THIS_MODULE,
+ .name = "fonfxc-fw",
+ .of_match_table = mtdsplit_uimage_fonfxc_of_match_table,
+ .parse_fn = mtdsplit_uimage_parse_fonfxc,
+};
+
+/**************************************************
+ * SGE (T&W) Shenzhen Gongjin Electronics
+ **************************************************/
+
+#define SGE_PAD_LEN 96
+
+static ssize_t uimage_find_sge(u_char *buf, size_t len, int *extralen)
+{
+ if (uimage_verify_default(buf, len, extralen) < 0)
+ return -EINVAL;
+
+ *extralen = SGE_PAD_LEN;
+
+ return 0;
+}
+
+static int
+mtdsplit_uimage_parse_sge(struct mtd_info *master,
+ const struct mtd_partition **pparts,
+ struct mtd_part_parser_data *data)
+{
+ return __mtdsplit_parse_uimage(master, pparts, data,
+ uimage_find_sge);
+}
+
+static const struct of_device_id mtdsplit_uimage_sge_of_match_table[] = {
+ { .compatible = "sge,uimage" },
+ {},
+};
+
+static struct mtd_part_parser uimage_sge_parser = {
+ .owner = THIS_MODULE,
+ .name = "sge-fw",
+ .of_match_table = mtdsplit_uimage_sge_of_match_table,
+ .parse_fn = mtdsplit_uimage_parse_sge,
+};
+
+/**************************************************
+ * OKLI (OpenWrt Kernel Loader Image)
+ **************************************************/
+
+#define IH_MAGIC_OKLI 0x4f4b4c49
+
+static ssize_t uimage_verify_okli(u_char *buf, size_t len, int *extralen)
+{
+ struct uimage_header *header = (struct uimage_header *)buf;
+
+ /* default sanity checks */
+ if (be32_to_cpu(header->ih_magic) != IH_MAGIC_OKLI) {
+ pr_debug("invalid uImage magic: %08x\n",
+ be32_to_cpu(header->ih_magic));
+ return -EINVAL;
+ }
+
+ if (header->ih_os != IH_OS_LINUX) {
+ pr_debug("invalid uImage OS: %08x\n",
+ be32_to_cpu(header->ih_os));
+ return -EINVAL;
+ }
+
+ if (header->ih_type != IH_TYPE_KERNEL) {
+ pr_debug("invalid uImage type: %08x\n",
+ be32_to_cpu(header->ih_type));
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int
+mtdsplit_uimage_parse_okli(struct mtd_info *master,
+ const struct mtd_partition **pparts,
+ struct mtd_part_parser_data *data)
+{
+ return __mtdsplit_parse_uimage(master, pparts, data,
+ uimage_verify_okli);
+}
+
+static const struct of_device_id mtdsplit_uimage_okli_of_match_table[] = {
+ { .compatible = "openwrt,okli" },
+ {},
+};
+
+static struct mtd_part_parser uimage_okli_parser = {
+ .owner = THIS_MODULE,
+ .name = "okli-fw",
+ .of_match_table = mtdsplit_uimage_okli_of_match_table,
+ .parse_fn = mtdsplit_uimage_parse_okli,
+};
+
/**************************************************
* Init
**************************************************/
{
register_mtd_parser(&uimage_generic_parser);
register_mtd_parser(&uimage_netgear_parser);
+ register_mtd_parser(&uimage_allnet_parser);
register_mtd_parser(&uimage_edimax_parser);
+ register_mtd_parser(&uimage_fonfxc_parser);
+ register_mtd_parser(&uimage_sge_parser);
+ register_mtd_parser(&uimage_okli_parser);
return 0;
}