block/partitions/of.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include <linux/blkdev.h>
   4 #include <linux/major.h>
   5 #include <linux/of.h>
   6 #include <linux/string.h>
   7 #include "check.h"
   8
   9 static int validate_of_partition(struct device_node *np, int slot)
  10 {
  11         u64 offset, size;
  12         int len;
  13
  14         const __be32 *reg = of_get_property(np, "reg", &len);
  15         int a_cells = of_n_addr_cells(np);
  16         int s_cells = of_n_size_cells(np);
  17
  18         /* Make sure reg len match the expected addr and size cells */
  19         if (len / sizeof(*reg) != a_cells + s_cells)
  20                 return -EINVAL;
  21
  22         /* Validate offset conversion from bytes to sectors */
  23         offset = of_read_number(reg, a_cells);
  24         if (offset % SECTOR_SIZE)
  25                 return -EINVAL;
  26
  27         /* Validate size conversion from bytes to sectors */
  28         size = of_read_number(reg + a_cells, s_cells);
  29         if (!size || size % SECTOR_SIZE)
  30                 return -EINVAL;
  31
  32         return 0;
  33 }
  34
  35 static void add_of_partition(struct parsed_partitions *state, int slot,
  36                              struct device_node *np)
  37 {
  38         struct partition_meta_info *info;
  39         char tmp[sizeof(info->volname) + 4];
  40         const char *partname;
  41         int len;
  42
  43         const __be32 *reg = of_get_property(np, "reg", &len);
  44         int a_cells = of_n_addr_cells(np);
  45         int s_cells = of_n_size_cells(np);
  46
  47         /* Convert bytes to sector size */
  48         u64 offset = of_read_number(reg, a_cells) / SECTOR_SIZE;
  49         u64 size = of_read_number(reg + a_cells, s_cells) / SECTOR_SIZE;
  50
  51         put_partition(state, slot, offset, size);
  52
  53         if (of_property_read_bool(np, "read-only"))
  54                 state->parts[slot].flags |= ADDPART_FLAG_READONLY;
  55
  56         /*
  57          * Follow MTD label logic, search for label property,
  58          * fallback to node name if not found.
  59          */
  60         info = &state->parts[slot].info;
  61         partname = of_get_property(np, "label", &len);
  62         if (!partname)
  63                 partname = of_get_property(np, "name", &len);
  64         strscpy(info->volname, partname, sizeof(info->volname));
  65
  66         snprintf(tmp, sizeof(tmp), "(%s)", info->volname);
  67         strlcat(state->pp_buf, tmp, PAGE_SIZE);
  68 }
  69
  70 int of_partition(struct parsed_partitions *state)
  71 {
  72         struct device *ddev = disk_to_dev(state->disk);
  73         struct device_node *np;
  74         int slot;
  75
  76         struct device_node *partitions_np = of_node_get(ddev->of_node);
  77
  78         if (!partitions_np ||
  79             !of_device_is_compatible(partitions_np, "fixed-partitions"))
  80                 return 0;
  81
  82         slot = 1;
  83         /* Validate parition offset and size */
  84         for_each_child_of_node(partitions_np, np) {
  85                 if (validate_of_partition(np, slot)) {
  86                         of_node_put(np);
  87                         of_node_put(partitions_np);
  88
  89                         return -1;
  90                 }
  91
  92                 slot++;
  93         }
  94
  95         slot = 1;
  96         for_each_child_of_node(partitions_np, np) {
  97                 if (slot >= state->limit) {
  98                         of_node_put(np);
  99                         break;
 100                 }
 101
 102                 add_of_partition(state, slot, np);
 103
 104                 slot++;
 105         }
 106
 107         strlcat(state->pp_buf, "\n", PAGE_SIZE);
 108
 109         return 1;
 110 }