target/linux/bcm53xx/patches-5.15/800-nvmem-brcm_nvram-store-a-copy-of-NVRAM-content.patch

   1 From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= <rafal@milecki.pl>
   2 Date: Thu, 14 Sep 2023 07:59:09 +0200
   3 Subject: [PATCH] nvmem: brcm_nvram: store a copy of NVRAM content
   4 MIME-Version: 1.0
   5 Content-Type: text/plain; charset=UTF-8
   6 Content-Transfer-Encoding: 8bit
   7
   8 This driver uses MMIO access for reading NVRAM from a flash device.
   9 Underneath there is a flash controller that reads data and provides
  10 mapping window.
  11
  12 Using MMIO interface affects controller configuration and may break real
  13 controller driver. It was reported by multiple users of devices with
  14 NVRAM stored on NAND.
  15
  16 Modify driver to read & cache NVRAM content during init and use that
  17 copy to provide NVMEM data when requested. On NAND flashes due to their
  18 alignment NVRAM partitions can be quite big (1 MiB and more) while
  19 actual NVRAM content stays quite small (usually 16 to 32 KiB). To avoid
  20 allocating so much memory check for actual data length.
  21
  22 Link: https://lore.kernel.org/linux-mtd/CACna6rwf3_9QVjYcM+847biTX=K0EoWXuXcSMkJO1Vy_5vmVqA@mail.gmail.com/
  23 Fixes: 3fef9ed0627a ("nvmem: brcm_nvram: new driver exposing Broadcom's NVRAM")
  24 Cc: Arınç ÜNAL <arinc.unal@arinc9.com>
  25 Cc: Florian Fainelli <florian.fainelli@broadcom.com>
  26 Cc: Scott Branden <scott.branden@broadcom.com>
  27 Signed-off-by: Rafał Miłecki <rafal@milecki.pl>
  28 ---
  29  drivers/nvmem/brcm_nvram.c | 130 +++++++++++++++++++++++++------------
  30  1 file changed, 90 insertions(+), 40 deletions(-)
  31
  32 --- a/drivers/nvmem/brcm_nvram.c
  33 +++ b/drivers/nvmem/brcm_nvram.c
  34 @@ -17,9 +17,20 @@
  35
  36  #define NVRAM_MAGIC                    "FLSH"
  37
  38 +/**
  39 + * struct brcm_nvram - driver state internal struct
  40 + *
  41 + * @nvmem_size:                Size of the whole space available for NVRAM
  42 + * @data:              NVRAM data copy stored to avoid poking underlaying flash controller
  43 + * @data_len:          NVRAM data size
  44 + * @padding_byte:      Padding value used to fill remaining space
  45 + */
  46  struct brcm_nvram {
  47         struct device *dev;
  48 -       void __iomem *base;
  49 +       size_t nvmem_size;
  50 +       uint8_t *data;
  51 +       size_t data_len;
  52 +       uint8_t padding_byte;
  53         struct nvmem_cell_info *cells;
  54         int ncells;
  55  };
  56 @@ -36,10 +47,47 @@ static int brcm_nvram_read(void *context
  57                            size_t bytes)
  58  {
  59         struct brcm_nvram *priv = context;
  60 -       u8 *dst = val;
  61 +       size_t to_copy;
  62 +
  63 +       if (offset + bytes > priv->data_len)
  64 +               to_copy = max_t(ssize_t, (ssize_t)priv->data_len - offset, 0);
  65 +       else
  66 +               to_copy = bytes;
  67 +
  68 +       memcpy(val, priv->data + offset, to_copy);
  69 +
  70 +       memset((uint8_t *)val + to_copy, priv->padding_byte, bytes - to_copy);
  71 +
  72 +       return 0;
  73 +}
  74 +
  75 +static int brcm_nvram_copy_data(struct brcm_nvram *priv, struct platform_device *pdev)
  76 +{
  77 +       struct resource *res;
  78 +       void __iomem *base;
  79 +
  80 +       base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
  81 +       if (IS_ERR(base))
  82 +               return PTR_ERR(base);
  83 +
  84 +       priv->nvmem_size = resource_size(res);
  85 +
  86 +       priv->padding_byte = readb(base + priv->nvmem_size - 1);
  87 +       for (priv->data_len = priv->nvmem_size;
  88 +            priv->data_len;
  89 +            priv->data_len--) {
  90 +               if (readb(base + priv->data_len - 1) != priv->padding_byte)
  91 +                       break;
  92 +       }
  93 +       WARN(priv->data_len > SZ_128K, "Unexpected (big) NVRAM size: %zu B\n", priv->data_len);
  94
  95 -       while (bytes--)
  96 -               *dst++ = readb(priv->base + offset++);
  97 +       priv->data = devm_kzalloc(priv->dev, priv->data_len, GFP_KERNEL);
  98 +       if (!priv->data)
  99 +               return -ENOMEM;
 100 +
 101 +       memcpy_fromio(priv->data, base, priv->data_len);
 102 +
 103 +       bcm47xx_nvram_init_from_iomem(base, priv->data_len);
 104
 105         return 0;
 106  }
 107 @@ -67,8 +115,13 @@ static int brcm_nvram_add_cells(struct b
 108                                 size_t len)
 109  {
 110         struct device *dev = priv->dev;
 111 -       char *var, *value, *eq;
 112 +       char *var, *value;
 113 +       uint8_t tmp;
 114         int idx;
 115 +       int err = 0;
 116 +
 117 +       tmp = priv->data[len - 1];
 118 +       priv->data[len - 1] = '\0';
 119
 120         priv->ncells = 0;
 121         for (var = data + sizeof(struct brcm_nvram_header);
 122 @@ -78,67 +131,67 @@ static int brcm_nvram_add_cells(struct b
 123         }
 124
 125         priv->cells = devm_kcalloc(dev, priv->ncells, sizeof(*priv->cells), GFP_KERNEL);
 126 -       if (!priv->cells)
 127 -               return -ENOMEM;
 128 +       if (!priv->cells) {
 129 +               err = -ENOMEM;
 130 +               goto out;
 131 +       }
 132
 133         for (var = data + sizeof(struct brcm_nvram_header), idx = 0;
 134              var < (char *)data + len && *var;
 135              var = value + strlen(value) + 1, idx++) {
 136 +               char *eq, *name;
 137 +
 138                 eq = strchr(var, '=');
 139                 if (!eq)
 140                         break;
 141                 *eq = '\0';
 142 +               name = devm_kstrdup(dev, var, GFP_KERNEL);
 143 +               *eq = '=';
 144 +               if (!name) {
 145 +                       err = -ENOMEM;
 146 +                       goto out;
 147 +               }
 148                 value = eq + 1;
 149
 150 -               priv->cells[idx].name = devm_kstrdup(dev, var, GFP_KERNEL);
 151 -               if (!priv->cells[idx].name)
 152 -                       return -ENOMEM;
 153 +               priv->cells[idx].name = name;
 154                 priv->cells[idx].offset = value - (char *)data;
 155                 priv->cells[idx].bytes = strlen(value);
 156                 priv->cells[idx].np = of_get_child_by_name(dev->of_node, priv->cells[idx].name);
 157 -               if (!strcmp(var, "et0macaddr") ||
 158 -                   !strcmp(var, "et1macaddr") ||
 159 -                   !strcmp(var, "et2macaddr")) {
 160 +               if (!strcmp(name, "et0macaddr") ||
 161 +                   !strcmp(name, "et1macaddr") ||
 162 +                   !strcmp(name, "et2macaddr")) {
 163                         priv->cells[idx].raw_len = strlen(value);
 164                         priv->cells[idx].bytes = ETH_ALEN;
 165                         priv->cells[idx].read_post_process = brcm_nvram_read_post_process_macaddr;
 166                 }
 167         }
 168
 169 -       return 0;
 170 +out:
 171 +       priv->data[len - 1] = tmp;
 172 +       return err;
 173  }
 174
 175  static int brcm_nvram_parse(struct brcm_nvram *priv)
 176  {
 177 +       struct brcm_nvram_header *header = (struct brcm_nvram_header *)priv->data;
 178         struct device *dev = priv->dev;
 179 -       struct brcm_nvram_header header;
 180 -       uint8_t *data;
 181         size_t len;
 182         int err;
 183
 184 -       memcpy_fromio(&header, priv->base, sizeof(header));
 185 -
 186 -       if (memcmp(header.magic, NVRAM_MAGIC, 4)) {
 187 +       if (memcmp(header->magic, NVRAM_MAGIC, 4)) {
 188                 dev_err(dev, "Invalid NVRAM magic\n");
 189                 return -EINVAL;
 190         }
 191
 192 -       len = le32_to_cpu(header.len);
 193 -
 194 -       data = kzalloc(len, GFP_KERNEL);
 195 -       if (!data)
 196 -               return -ENOMEM;
 197 -
 198 -       memcpy_fromio(data, priv->base, len);
 199 -       data[len - 1] = '\0';
 200 -
 201 -       err = brcm_nvram_add_cells(priv, data, len);
 202 -       if (err) {
 203 -               dev_err(dev, "Failed to add cells: %d\n", err);
 204 -               return err;
 205 +       len = le32_to_cpu(header->len);
 206 +       if (len > priv->nvmem_size) {
 207 +               dev_err(dev, "NVRAM length (%zd) exceeds mapped size (%zd)\n", len, priv->nvmem_size);
 208 +               return -EINVAL;
 209         }
 210
 211 -       kfree(data);
 212 +       err = brcm_nvram_add_cells(priv, priv->data, len);
 213 +       if (err)
 214 +               dev_err(dev, "Failed to add cells: %d\n", err);
 215
 216         return 0;
 217  }
 218 @@ -150,7 +203,6 @@ static int brcm_nvram_probe(struct platf
 219                 .reg_read = brcm_nvram_read,
 220         };
 221         struct device *dev = &pdev->dev;
 222 -       struct resource *res;
 223         struct brcm_nvram *priv;
 224         int err;
 225
 226 @@ -159,21 +211,19 @@ static int brcm_nvram_probe(struct platf
 227                 return -ENOMEM;
 228         priv->dev = dev;
 229
 230 -       priv->base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
 231 -       if (IS_ERR(priv->base))
 232 -               return PTR_ERR(priv->base);
 233 +       err = brcm_nvram_copy_data(priv, pdev);
 234 +       if (err)
 235 +               return err;
 236
 237         err = brcm_nvram_parse(priv);
 238         if (err)
 239                 return err;
 240
 241 -       bcm47xx_nvram_init_from_iomem(priv->base, resource_size(res));
 242 -
 243         config.dev = dev;
 244         config.cells = priv->cells;
 245         config.ncells = priv->ncells;
 246         config.priv = priv;
 247 -       config.size = resource_size(res);
 248 +       config.size = priv->nvmem_size;
 249
 250         return PTR_ERR_OR_ZERO(devm_nvmem_register(dev, &config));
 251  }