target/linux/brcm63xx/patches-4.4/425-bcm63xxpart_parse_paritions_from_dt.patch

   1 --- a/drivers/mtd/bcm63xxpart.c
   2 +++ b/drivers/mtd/bcm63xxpart.c
   3 @@ -32,6 +32,7 @@
   4  #include <linux/vmalloc.h>
   5  #include <linux/mtd/mtd.h>
   6  #include <linux/mtd/partitions.h>
   7 +#include <linux/of.h>
   8
   9  #include <asm/mach-bcm63xx/bcm63xx_nvram.h>
  10  #include <asm/mach-bcm63xx/bcm963xx_tag.h>
  11 @@ -43,46 +44,35 @@
  12
  13  #define BCM63XX_CFE_MAGIC_OFFSET 0x4e0
  14
  15 -static int bcm63xx_parse_cfe_partitions(struct mtd_info *master,
  16 -                                       struct mtd_partition **pparts,
  17 -                                       struct mtd_part_parser_data *data)
  18 +static bool node_has_compatible(struct device_node *pp)
  19 +{
  20 +       return of_get_property(pp, "compatible", NULL);
  21 +}
  22 +
  23 +static int parse_bcmtag(struct mtd_info *master, struct mtd_partition *pparts,
  24 +                       int next_part, size_t offset, size_t size)
  25  {
  26 -       /* CFE, NVRAM and global Linux are always present */
  27 -       int nrparts = 3, curpart = 0;
  28         struct bcm_tag *buf;
  29 -       struct mtd_partition *parts;
  30 +       u32 computed_crc;
  31         int ret;
  32         size_t retlen;
  33 -       unsigned int rootfsaddr, kerneladdr, spareaddr;
  34 -       unsigned int rootfslen, kernellen, sparelen, totallen;
  35 -       unsigned int cfelen, nvramlen;
  36 -       unsigned int cfe_erasesize;
  37 -       int i;
  38 -       u32 computed_crc;
  39 +       unsigned int rootfsaddr, kerneladdr;
  40 +       unsigned int rootfslen, kernellen, totallen;
  41         bool rootfs_first = false;
  42 -
  43 -       if (!bcm63xx_is_cfe_present())
  44 -               return -EINVAL;
  45 -
  46 -       cfe_erasesize = max_t(uint32_t, master->erasesize,
  47 -                             BCM63XX_CFE_BLOCK_SIZE);
  48 -
  49 -       cfelen = cfe_erasesize;
  50 -       nvramlen = bcm63xx_nvram_get_psi_size() * SZ_1K;
  51 -       nvramlen = roundup(nvramlen, cfe_erasesize);
  52 +       int curr_part = next_part;
  53
  54         /* Allocate memory for buffer */
  55 -       buf = vmalloc(sizeof(struct bcm_tag));
  56 +       buf = vmalloc(sizeof(*buf));
  57         if (!buf)
  58                 return -ENOMEM;
  59
  60         /* Get the tag */
  61 -       ret = mtd_read(master, cfelen, sizeof(struct bcm_tag), &retlen,
  62 +       ret = mtd_read(master, offset, sizeof(*buf), &retlen,
  63                        (void *)buf);
  64
  65 -       if (retlen != sizeof(struct bcm_tag)) {
  66 +       if (retlen != sizeof(*buf)) {
  67                 vfree(buf);
  68 -               return -EIO;
  69 +               return 0;
  70         }
  71
  72         computed_crc = crc32_le(IMAGETAG_CRC_START, (u8 *)buf,
  73 @@ -101,7 +91,6 @@ static int bcm63xx_parse_cfe_partitions(
  74
  75                 kerneladdr = kerneladdr - BCM63XX_EXTENDED_SIZE;
  76                 rootfsaddr = rootfsaddr - BCM63XX_EXTENDED_SIZE;
  77 -               spareaddr = roundup(totallen, master->erasesize) + cfelen;
  78
  79                 if (rootfsaddr < kerneladdr) {
  80                         /* default Broadcom layout */
  81 @@ -110,8 +99,8 @@ static int bcm63xx_parse_cfe_partitions(
  82                 } else {
  83                         /* OpenWrt layout */
  84                         rootfsaddr = kerneladdr + kernellen;
  85 -                       rootfslen = buf->real_rootfs_length;
  86 -                       spareaddr = rootfsaddr + rootfslen;
  87 +                       rootfslen = size - kernellen -
  88 +                                   sizeof(*buf);
  89                 }
  90         } else {
  91                 pr_warn("CFE boot tag CRC invalid (expected %08x, actual %08x)\n",
  92 @@ -119,23 +108,139 @@ static int bcm63xx_parse_cfe_partitions(
  93                 kernellen = 0;
  94                 rootfslen = 0;
  95                 rootfsaddr = 0;
  96 -               spareaddr = cfelen;
  97         }
  98 -       sparelen = master->size - spareaddr - nvramlen;
  99
 100 -       /* Determine number of partitions */
 101 -       if (rootfslen > 0)
 102 -               nrparts++;
 103 +       if (kernellen > 0) {
 104 +               int kernelpart = curr_part;
 105 +
 106 +               if (rootfslen > 0 && rootfs_first)
 107 +                       kernelpart++;
 108 +               pparts[kernelpart].name = "kernel";
 109 +               pparts[kernelpart].offset = kerneladdr;
 110 +               pparts[kernelpart].size = kernellen;
 111 +               curr_part++;
 112 +       }
 113 +
 114 +       if (rootfslen > 0) {
 115 +               int rootfspart = curr_part;
 116 +
 117 +               if (kernellen > 0 && rootfs_first)
 118 +                       rootfspart--;
 119 +               pparts[rootfspart].name = "rootfs";
 120 +               pparts[rootfspart].offset = rootfsaddr;
 121 +               pparts[rootfspart].size = rootfslen;
 122 +
 123 +               curr_part++;
 124 +       }
 125 +
 126 +       vfree(buf);
 127 +
 128 +       return curr_part - next_part;
 129 +}
 130 +
 131 +
 132 +static int bcm63xx_parse_cfe_partitions_of(struct mtd_info *master,
 133 +                                          struct mtd_partition **pparts,
 134 +                                          struct mtd_part_parser_data *data)
 135 +{
 136 +       struct device_node *dp = mtd_get_of_node(master);
 137 +       struct device_node *pp;
 138 +       int i, nr_parts = 0;
 139 +       const char *partname;
 140 +       int len;
 141 +
 142 +       for_each_child_of_node(dp, pp) {
 143 +               if (node_has_compatible(pp))
 144 +                       continue;
 145 +
 146 +               if (!of_get_property(pp, "reg", &len))
 147 +                       continue;
 148 +
 149 +               partname = of_get_property(pp, "label", &len);
 150 +               if (!partname)
 151 +                       partname = of_get_property(pp, "name", &len);
 152 +
 153 +               if (!strcmp(partname, "linux"))
 154 +                       nr_parts += 2;
 155 +
 156 +               nr_parts++;
 157 +       }
 158 +
 159 +       *pparts = kzalloc(nr_parts * sizeof(**pparts), GFP_KERNEL);
 160 +       if (!*pparts)
 161 +               return -ENOMEM;
 162 +
 163 +       i = 0;
 164 +       for_each_child_of_node(dp, pp) {
 165 +               const __be32 *reg;
 166 +               int a_cells, s_cells;
 167 +               size_t size, offset;
 168 +
 169 +               if (node_has_compatible(pp))
 170 +                       continue;
 171 +
 172 +               reg = of_get_property(pp, "reg", &len);
 173 +               if (!reg)
 174 +                       continue;
 175 +
 176 +               a_cells = of_n_addr_cells(pp);
 177 +               s_cells = of_n_size_cells(pp);
 178 +               offset = of_read_number(reg, a_cells);
 179 +               size = of_read_number(reg + a_cells, s_cells);
 180 +               partname = of_get_property(pp, "label", &len);
 181 +               if (!partname)
 182 +                       partname = of_get_property(pp, "name", &len);
 183 +
 184 +               if (!strcmp(partname, "linux"))
 185 +                       i += parse_bcmtag(master, *pparts, i, offset, size);
 186 +
 187 +               if (of_get_property(pp, "read-only", &len))
 188 +                       (*pparts)[i].mask_flags |= MTD_WRITEABLE;
 189 +
 190 +               if (of_get_property(pp, "lock", &len))
 191 +                       (*pparts)[i].mask_flags |= MTD_POWERUP_LOCK;
 192 +
 193 +               (*pparts)[i].offset = offset;
 194 +               (*pparts)[i].size = size;
 195 +               (*pparts)[i].name = partname;
 196 +
 197 +               i++;
 198 +       }
 199 +
 200 +       return i;
 201 +}
 202 +
 203 +static int bcm63xx_parse_cfe_partitions(struct mtd_info *master,
 204 +                                       struct mtd_partition **pparts,
 205 +                                       struct mtd_part_parser_data *data)
 206 +{
 207 +       /* CFE, NVRAM and global Linux are always present */
 208 +       int nrparts = 5, curpart = 0;
 209 +       struct mtd_partition *parts;
 210 +       unsigned int nvramaddr;
 211 +       unsigned int cfelen, nvramlen;
 212 +       unsigned int cfe_erasesize;
 213 +       unsigned int imageaddr, imagelen;
 214 +       int i;
 215 +
 216 +       if (!bcm63xx_is_cfe_present())
 217 +               return -EINVAL;
 218 +
 219 +       cfe_erasesize = max_t(uint32_t, master->erasesize,
 220 +                             BCM63XX_CFE_BLOCK_SIZE);
 221 +
 222 +       cfelen = cfe_erasesize;
 223 +       nvramlen = bcm63xx_nvram_get_psi_size() * SZ_1K;
 224 +       nvramlen = roundup(nvramlen, cfe_erasesize);
 225 +       nvramaddr = master->size - nvramlen;
 226
 227 -       if (kernellen > 0)
 228 -               nrparts++;
 229 +       imageaddr = cfelen;
 230 +       imagelen = nvramaddr - imageaddr;
 231
 232         /* Ask kernel for more memory */
 233         parts = kzalloc(sizeof(*parts) * nrparts + 10 * nrparts, GFP_KERNEL);
 234 -       if (!parts) {
 235 -               vfree(buf);
 236 +       if (!parts)
 237                 return -ENOMEM;
 238 -       }
 239
 240         /* Start building partition list */
 241         parts[curpart].name = "CFE";
 242 @@ -143,29 +248,7 @@ static int bcm63xx_parse_cfe_partitions(
 243         parts[curpart].size = cfelen;
 244         curpart++;
 245
 246 -       if (kernellen > 0) {
 247 -               int kernelpart = curpart;
 248 -
 249 -               if (rootfslen > 0 && rootfs_first)
 250 -                       kernelpart++;
 251 -               parts[kernelpart].name = "kernel";
 252 -               parts[kernelpart].offset = kerneladdr;
 253 -               parts[kernelpart].size = kernellen;
 254 -               curpart++;
 255 -       }
 256 -
 257 -       if (rootfslen > 0) {
 258 -               int rootfspart = curpart;
 259 -
 260 -               if (kernellen > 0 && rootfs_first)
 261 -                       rootfspart--;
 262 -               parts[rootfspart].name = "rootfs";
 263 -               parts[rootfspart].offset = rootfsaddr;
 264 -               parts[rootfspart].size = rootfslen;
 265 -               if (sparelen > 0  && !rootfs_first)
 266 -                       parts[rootfspart].size += sparelen;
 267 -               curpart++;
 268 -       }
 269 +       curpart += parse_bcmtag(master, parts, curpart, imageaddr, imagelen);
 270
 271         parts[curpart].name = "nvram";
 272         parts[curpart].offset = master->size - nvramlen;
 273 @@ -174,25 +257,33 @@ static int bcm63xx_parse_cfe_partitions(
 274
 275         /* Global partition "linux" to make easy firmware upgrade */
 276         parts[curpart].name = "linux";
 277 -       parts[curpart].offset = cfelen;
 278 -       parts[curpart].size = master->size - cfelen - nvramlen;
 279 +       parts[curpart].offset = imageaddr;
 280 +       parts[curpart].size = imagelen;
 281 +       curpart++;
 282
 283 -       for (i = 0; i < nrparts; i++)
 284 +       for (i = 0; i < curpart; i++)
 285                 pr_info("Partition %d is %s offset %llx and length %llx\n", i,
 286                         parts[i].name, parts[i].offset, parts[i].size);
 287
 288 -       pr_info("Spare partition is offset %x and length %x\n", spareaddr,
 289 -               sparelen);
 290 -
 291         *pparts = parts;
 292 -       vfree(buf);
 293
 294         return nrparts;
 295  };
 296
 297 +
 298 +static int bcm63xx_parse_partitions(struct mtd_info *master,
 299 +                                   struct mtd_partition **pparts,
 300 +                                   struct mtd_part_parser_data *data)
 301 +{
 302 +       if (mtd_get_of_node(master) && of_get_child_count(mtd_get_of_node(master)))
 303 +               return bcm63xx_parse_cfe_partitions_of(master, pparts, data);
 304 +       else
 305 +               return bcm63xx_parse_cfe_partitions(master, pparts, data);
 306 +}
 307 +
 308  static struct mtd_part_parser bcm63xx_cfe_parser = {
 309         .owner = THIS_MODULE,
 310 -       .parse_fn = bcm63xx_parse_cfe_partitions,
 311 +       .parse_fn = bcm63xx_parse_partitions,
 312         .name = "bcm63xxpart",
 313  };
 314