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

   1 /*
   2  *  Copyright (C) 2013 Gabor Juhos <juhosg@openwrt.org>
   3  *  Copyright (C) 2014 Felix Fietkau <nbd@nbd.name>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify it
   6  *  under the terms of the GNU General Public License version 2 as published
   7  *  by the Free Software Foundation.
   8  *
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/mtd/mtd.h>
  16 #include <linux/mtd/partitions.h>
  17 #include <linux/version.h>
  18 #include <linux/byteorder/generic.h>
  19
  20 #include "mtdsplit.h"
  21
  22 #define TPLINK_NR_PARTS         2
  23 #define TPLINK_MIN_ROOTFS_OFFS  0x80000 /* 512KiB */
  24
  25 #define MD5SUM_LEN  16
  26
  27 struct fw_v1 {
  28         char            vendor_name[24];
  29         char            fw_version[36];
  30         uint32_t        hw_id;          /* hardware id */
  31         uint32_t        hw_rev;         /* hardware revision */
  32         uint32_t        unk1;
  33         uint8_t         md5sum1[MD5SUM_LEN];
  34         uint32_t        unk2;
  35         uint8_t         md5sum2[MD5SUM_LEN];
  36         uint32_t        unk3;
  37         uint32_t        kernel_la;      /* kernel load address */
  38         uint32_t        kernel_ep;      /* kernel entry point */
  39         uint32_t        fw_length;      /* total length of the firmware */
  40         uint32_t        kernel_ofs;     /* kernel data offset */
  41         uint32_t        kernel_len;     /* kernel data length */
  42         uint32_t        rootfs_ofs;     /* rootfs data offset */
  43         uint32_t        rootfs_len;     /* rootfs data length */
  44         uint32_t        boot_ofs;       /* bootloader data offset */
  45         uint32_t        boot_len;       /* bootloader data length */
  46         uint8_t         pad[360];
  47 } __attribute__ ((packed));
  48
  49 struct fw_v2 {
  50         char            fw_version[48]; /* 0x04: fw version string */
  51         uint32_t        hw_id;          /* 0x34: hardware id */
  52         uint32_t        hw_rev;         /* 0x38: FIXME: hardware revision? */
  53         uint32_t        unk1;           /* 0x3c: 0x00000000 */
  54         uint8_t         md5sum1[MD5SUM_LEN]; /* 0x40 */
  55         uint32_t        unk2;           /* 0x50: 0x00000000 */
  56         uint8_t         md5sum2[MD5SUM_LEN]; /* 0x54 */
  57         uint32_t        unk3;           /* 0x64: 0xffffffff */
  58
  59         uint32_t        kernel_la;      /* 0x68: kernel load address */
  60         uint32_t        kernel_ep;      /* 0x6c: kernel entry point */
  61         uint32_t        fw_length;      /* 0x70: total length of the image */
  62         uint32_t        kernel_ofs;     /* 0x74: kernel data offset */
  63         uint32_t        kernel_len;     /* 0x78: kernel data length */
  64         uint32_t        rootfs_ofs;     /* 0x7c: rootfs data offset */
  65         uint32_t        rootfs_len;     /* 0x80: rootfs data length */
  66         uint32_t        boot_ofs;       /* 0x84: FIXME: seems to be unused */
  67         uint32_t        boot_len;       /* 0x88: FIXME: seems to be unused */
  68         uint16_t        unk4;           /* 0x8c: 0x55aa */
  69         uint8_t         sver_hi;        /* 0x8e */
  70         uint8_t         sver_lo;        /* 0x8f */
  71         uint8_t         unk5;           /* 0x90: magic: 0xa5 */
  72         uint8_t         ver_hi;         /* 0x91 */
  73         uint8_t         ver_mid;        /* 0x92 */
  74         uint8_t         ver_lo;         /* 0x93 */
  75         uint8_t         pad[364];
  76 } __attribute__ ((packed));
  77
  78 struct tplink_fw_header {
  79         uint32_t version;
  80         union {
  81                 struct fw_v1 v1;
  82                 struct fw_v2 v2;
  83         };
  84 };
  85
  86 static int mtdsplit_parse_tplink(struct mtd_info *master,
  87                                  const struct mtd_partition **pparts,
  88                                  struct mtd_part_parser_data *data)
  89 {
  90         struct tplink_fw_header hdr;
  91         size_t hdr_len, retlen, kernel_size;
  92         size_t rootfs_offset;
  93         struct mtd_partition *parts;
  94         int err;
  95
  96         hdr_len = sizeof(hdr);
  97         err = mtd_read(master, 0, hdr_len, &retlen, (void *) &hdr);
  98         if (err)
  99                 return err;
 100
 101         if (retlen != hdr_len)
 102                 return -EIO;
 103
 104         switch (le32_to_cpu(hdr.version)) {
 105         case 1:
 106                 if (be32_to_cpu(hdr.v1.kernel_ofs) != sizeof(hdr))
 107                         return -EINVAL;
 108
 109                 kernel_size = sizeof(hdr) + be32_to_cpu(hdr.v1.kernel_len);
 110                 rootfs_offset = be32_to_cpu(hdr.v1.rootfs_ofs);
 111                 break;
 112         case 2:
 113         case 3:
 114                 if (be32_to_cpu(hdr.v2.kernel_ofs) != sizeof(hdr))
 115                         return -EINVAL;
 116
 117                 kernel_size = sizeof(hdr) + be32_to_cpu(hdr.v2.kernel_len);
 118                 rootfs_offset = be32_to_cpu(hdr.v2.rootfs_ofs);
 119                 break;
 120         default:
 121                 return -EINVAL;
 122         }
 123
 124         if (kernel_size > master->size)
 125                 return -EINVAL;
 126
 127         /* Find the rootfs */
 128         err = mtd_check_rootfs_magic(master, rootfs_offset, NULL);
 129         if (err) {
 130                 /*
 131                  * The size in the header might cover the rootfs as well.
 132                  * Start the search from an arbitrary offset.
 133                  */
 134                 err = mtd_find_rootfs_from(master, TPLINK_MIN_ROOTFS_OFFS,
 135                                            master->size, &rootfs_offset, NULL);
 136                 if (err)
 137                         return err;
 138         }
 139
 140         parts = kzalloc(TPLINK_NR_PARTS * sizeof(*parts), GFP_KERNEL);
 141         if (!parts)
 142                 return -ENOMEM;
 143
 144         parts[0].name = KERNEL_PART_NAME;
 145         parts[0].offset = 0;
 146         parts[0].size = kernel_size;
 147
 148         parts[1].name = ROOTFS_PART_NAME;
 149         parts[1].offset = rootfs_offset;
 150         parts[1].size = master->size - rootfs_offset;
 151
 152         *pparts = parts;
 153         return TPLINK_NR_PARTS;
 154 }
 155
 156 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
 157 static const struct of_device_id mtdsplit_tplink_of_match_table[] = {
 158         { .compatible = "tplink,firmware" },
 159         {},
 160 };
 161 #endif
 162
 163 static struct mtd_part_parser mtdsplit_tplink_parser = {
 164         .owner = THIS_MODULE,
 165         .name = "tplink-fw",
 166 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
 167         .of_match_table = mtdsplit_tplink_of_match_table,
 168 #endif
 169         .parse_fn = mtdsplit_parse_tplink,
 170         .type = MTD_PARSER_TYPE_FIRMWARE,
 171 };
 172
 173 static int __init mtdsplit_tplink_init(void)
 174 {
 175         register_mtd_parser(&mtdsplit_tplink_parser);
 176
 177         return 0;
 178 }
 179
 180 subsys_initcall(mtdsplit_tplink_init);