drivers/net/wireless/broadcom/brcm80211/brcmfmac/firmware.c

   1 /*
   2  * Copyright (c) 2013 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/slab.h>
  19 #include <linux/device.h>
  20 #include <linux/firmware.h>
  21 #include <linux/module.h>
  22 #include <linux/bcm47xx_nvram.h>
  23
  24 #include "debug.h"
  25 #include "firmware.h"
  26 #include "core.h"
  27 #include "common.h"
  28
  29 #define BRCMF_FW_MAX_NVRAM_SIZE                 64000
  30 #define BRCMF_FW_NVRAM_DEVPATH_LEN              19      /* devpath0=pcie/1/4/ */
  31 #define BRCMF_FW_NVRAM_PCIEDEV_LEN              10      /* pcie/1/4/ + \0 */
  32
  33 enum nvram_parser_state {
  34         IDLE,
  35         KEY,
  36         VALUE,
  37         COMMENT,
  38         END
  39 };
  40
  41 /**
  42  * struct nvram_parser - internal info for parser.
  43  *
  44  * @state: current parser state.
  45  * @data: input buffer being parsed.
  46  * @nvram: output buffer with parse result.
  47  * @nvram_len: lenght of parse result.
  48  * @line: current line.
  49  * @column: current column in line.
  50  * @pos: byte offset in input buffer.
  51  * @entry: start position of key,value entry.
  52  * @multi_dev_v1: detect pcie multi device v1 (compressed).
  53  * @multi_dev_v2: detect pcie multi device v2.
  54  */
  55 struct nvram_parser {
  56         enum nvram_parser_state state;
  57         const u8 *data;
  58         u8 *nvram;
  59         u32 nvram_len;
  60         u32 line;
  61         u32 column;
  62         u32 pos;
  63         u32 entry;
  64         bool multi_dev_v1;
  65         bool multi_dev_v2;
  66 };
  67
  68 /**
  69  * is_nvram_char() - check if char is a valid one for NVRAM entry
  70  *
  71  * It accepts all printable ASCII chars except for '#' which opens a comment.
  72  * Please note that ' ' (space) while accepted is not a valid key name char.
  73  */
  74 static bool is_nvram_char(char c)
  75 {
  76         /* comment marker excluded */
  77         if (c == '#')
  78                 return false;
  79
  80         /* key and value may have any other readable character */
  81         return (c >= 0x20 && c < 0x7f);
  82 }
  83
  84 static bool is_whitespace(char c)
  85 {
  86         return (c == ' ' || c == '\r' || c == '\n' || c == '\t');
  87 }
  88
  89 static enum nvram_parser_state brcmf_nvram_handle_idle(struct nvram_parser *nvp)
  90 {
  91         char c;
  92
  93         c = nvp->data[nvp->pos];
  94         if (c == '\n')
  95                 return COMMENT;
  96         if (is_whitespace(c))
  97                 goto proceed;
  98         if (c == '#')
  99                 return COMMENT;
 100         if (is_nvram_char(c)) {
 101                 nvp->entry = nvp->pos;
 102                 return KEY;
 103         }
 104         brcmf_dbg(INFO, "warning: ln=%d:col=%d: ignoring invalid character\n",
 105                   nvp->line, nvp->column);
 106 proceed:
 107         nvp->column++;
 108         nvp->pos++;
 109         return IDLE;
 110 }
 111
 112 static enum nvram_parser_state brcmf_nvram_handle_key(struct nvram_parser *nvp)
 113 {
 114         enum nvram_parser_state st = nvp->state;
 115         char c;
 116
 117         c = nvp->data[nvp->pos];
 118         if (c == '=') {
 119                 /* ignore RAW1 by treating as comment */
 120                 if (strncmp(&nvp->data[nvp->entry], "RAW1", 4) == 0)
 121                         st = COMMENT;
 122                 else
 123                         st = VALUE;
 124                 if (strncmp(&nvp->data[nvp->entry], "devpath", 7) == 0)
 125                         nvp->multi_dev_v1 = true;
 126                 if (strncmp(&nvp->data[nvp->entry], "pcie/", 5) == 0)
 127                         nvp->multi_dev_v2 = true;
 128         } else if (!is_nvram_char(c) || c == ' ') {
 129                 brcmf_dbg(INFO, "warning: ln=%d:col=%d: '=' expected, skip invalid key entry\n",
 130                           nvp->line, nvp->column);
 131                 return COMMENT;
 132         }
 133
 134         nvp->column++;
 135         nvp->pos++;
 136         return st;
 137 }
 138
 139 static enum nvram_parser_state
 140 brcmf_nvram_handle_value(struct nvram_parser *nvp)
 141 {
 142         char c;
 143         char *skv;
 144         char *ekv;
 145         u32 cplen;
 146
 147         c = nvp->data[nvp->pos];
 148         if (!is_nvram_char(c)) {
 149                 /* key,value pair complete */
 150                 ekv = (u8 *)&nvp->data[nvp->pos];
 151                 skv = (u8 *)&nvp->data[nvp->entry];
 152                 cplen = ekv - skv;
 153                 if (nvp->nvram_len + cplen + 1 >= BRCMF_FW_MAX_NVRAM_SIZE)
 154                         return END;
 155                 /* copy to output buffer */
 156                 memcpy(&nvp->nvram[nvp->nvram_len], skv, cplen);
 157                 nvp->nvram_len += cplen;
 158                 nvp->nvram[nvp->nvram_len] = '\0';
 159                 nvp->nvram_len++;
 160                 return IDLE;
 161         }
 162         nvp->pos++;
 163         nvp->column++;
 164         return VALUE;
 165 }
 166
 167 static enum nvram_parser_state
 168 brcmf_nvram_handle_comment(struct nvram_parser *nvp)
 169 {
 170         char *eoc, *sol;
 171
 172         sol = (char *)&nvp->data[nvp->pos];
 173         eoc = strchr(sol, '\n');
 174         if (!eoc) {
 175                 eoc = strchr(sol, '\0');
 176                 if (!eoc)
 177                         return END;
 178         }
 179
 180         /* eat all moving to next line */
 181         nvp->line++;
 182         nvp->column = 1;
 183         nvp->pos += (eoc - sol) + 1;
 184         return IDLE;
 185 }
 186
 187 static enum nvram_parser_state brcmf_nvram_handle_end(struct nvram_parser *nvp)
 188 {
 189         /* final state */
 190         return END;
 191 }
 192
 193 static enum nvram_parser_state
 194 (*nv_parser_states[])(struct nvram_parser *nvp) = {
 195         brcmf_nvram_handle_idle,
 196         brcmf_nvram_handle_key,
 197         brcmf_nvram_handle_value,
 198         brcmf_nvram_handle_comment,
 199         brcmf_nvram_handle_end
 200 };
 201
 202 static int brcmf_init_nvram_parser(struct nvram_parser *nvp,
 203                                    const u8 *data, size_t data_len)
 204 {
 205         size_t size;
 206
 207         memset(nvp, 0, sizeof(*nvp));
 208         nvp->data = data;
 209         /* Limit size to MAX_NVRAM_SIZE, some files contain lot of comment */
 210         if (data_len > BRCMF_FW_MAX_NVRAM_SIZE)
 211                 size = BRCMF_FW_MAX_NVRAM_SIZE;
 212         else
 213                 size = data_len;
 214         /* Alloc for extra 0 byte + roundup by 4 + length field */
 215         size += 1 + 3 + sizeof(u32);
 216         nvp->nvram = kzalloc(size, GFP_KERNEL);
 217         if (!nvp->nvram)
 218                 return -ENOMEM;
 219
 220         nvp->line = 1;
 221         nvp->column = 1;
 222         return 0;
 223 }
 224
 225 /* brcmf_fw_strip_multi_v1 :Some nvram files contain settings for multiple
 226  * devices. Strip it down for one device, use domain_nr/bus_nr to determine
 227  * which data is to be returned. v1 is the version where nvram is stored
 228  * compressed and "devpath" maps to index for valid entries.
 229  */
 230 static void brcmf_fw_strip_multi_v1(struct nvram_parser *nvp, u16 domain_nr,
 231                                     u16 bus_nr)
 232 {
 233         /* Device path with a leading '=' key-value separator */
 234         char pci_path[] = "=pci/?/?";
 235         size_t pci_len;
 236         char pcie_path[] = "=pcie/?/?";
 237         size_t pcie_len;
 238
 239         u32 i, j;
 240         bool found;
 241         u8 *nvram;
 242         u8 id;
 243
 244         nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL);
 245         if (!nvram)
 246                 goto fail;
 247
 248         /* min length: devpath0=pcie/1/4/ + 0:x=y */
 249         if (nvp->nvram_len < BRCMF_FW_NVRAM_DEVPATH_LEN + 6)
 250                 goto fail;
 251
 252         /* First search for the devpathX and see if it is the configuration
 253          * for domain_nr/bus_nr. Search complete nvp
 254          */
 255         snprintf(pci_path, sizeof(pci_path), "=pci/%d/%d", domain_nr,
 256                  bus_nr);
 257         pci_len = strlen(pci_path);
 258         snprintf(pcie_path, sizeof(pcie_path), "=pcie/%d/%d", domain_nr,
 259                  bus_nr);
 260         pcie_len = strlen(pcie_path);
 261         found = false;
 262         i = 0;
 263         while (i < nvp->nvram_len - BRCMF_FW_NVRAM_DEVPATH_LEN) {
 264                 /* Format: devpathX=pcie/Y/Z/
 265                  * Y = domain_nr, Z = bus_nr, X = virtual ID
 266                  */
 267                 if (strncmp(&nvp->nvram[i], "devpath", 7) == 0 &&
 268                     (!strncmp(&nvp->nvram[i + 8], pci_path, pci_len) ||
 269                      !strncmp(&nvp->nvram[i + 8], pcie_path, pcie_len))) {
 270                         id = nvp->nvram[i + 7] - '0';
 271                         found = true;
 272                         break;
 273                 }
 274                 while (nvp->nvram[i] != 0)
 275                         i++;
 276                 i++;
 277         }
 278         if (!found)
 279                 goto fail;
 280
 281         /* Now copy all valid entries, release old nvram and assign new one */
 282         i = 0;
 283         j = 0;
 284         while (i < nvp->nvram_len) {
 285                 if ((nvp->nvram[i] - '0' == id) && (nvp->nvram[i + 1] == ':')) {
 286                         i += 2;
 287                         while (nvp->nvram[i] != 0) {
 288                                 nvram[j] = nvp->nvram[i];
 289                                 i++;
 290                                 j++;
 291                         }
 292                         nvram[j] = 0;
 293                         j++;
 294                 }
 295                 while (nvp->nvram[i] != 0)
 296                         i++;
 297                 i++;
 298         }
 299         kfree(nvp->nvram);
 300         nvp->nvram = nvram;
 301         nvp->nvram_len = j;
 302         return;
 303
 304 fail:
 305         kfree(nvram);
 306         nvp->nvram_len = 0;
 307 }
 308
 309 /* brcmf_fw_strip_multi_v2 :Some nvram files contain settings for multiple
 310  * devices. Strip it down for one device, use domain_nr/bus_nr to determine
 311  * which data is to be returned. v2 is the version where nvram is stored
 312  * uncompressed, all relevant valid entries are identified by
 313  * pcie/domain_nr/bus_nr:
 314  */
 315 static void brcmf_fw_strip_multi_v2(struct nvram_parser *nvp, u16 domain_nr,
 316                                     u16 bus_nr)
 317 {
 318         char prefix[BRCMF_FW_NVRAM_PCIEDEV_LEN];
 319         size_t len;
 320         u32 i, j;
 321         u8 *nvram;
 322
 323         nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL);
 324         if (!nvram)
 325                 goto fail;
 326
 327         /* Copy all valid entries, release old nvram and assign new one.
 328          * Valid entries are of type pcie/X/Y/ where X = domain_nr and
 329          * Y = bus_nr.
 330          */
 331         snprintf(prefix, sizeof(prefix), "pcie/%d/%d/", domain_nr, bus_nr);
 332         len = strlen(prefix);
 333         i = 0;
 334         j = 0;
 335         while (i < nvp->nvram_len - len) {
 336                 if (strncmp(&nvp->nvram[i], prefix, len) == 0) {
 337                         i += len;
 338                         while (nvp->nvram[i] != 0) {
 339                                 nvram[j] = nvp->nvram[i];
 340                                 i++;
 341                                 j++;
 342                         }
 343                         nvram[j] = 0;
 344                         j++;
 345                 }
 346                 while (nvp->nvram[i] != 0)
 347                         i++;
 348                 i++;
 349         }
 350         kfree(nvp->nvram);
 351         nvp->nvram = nvram;
 352         nvp->nvram_len = j;
 353         return;
 354 fail:
 355         kfree(nvram);
 356         nvp->nvram_len = 0;
 357 }
 358
 359 /* brcmf_nvram_strip :Takes a buffer of "<var>=<value>\n" lines read from a fil
 360  * and ending in a NUL. Removes carriage returns, empty lines, comment lines,
 361  * and converts newlines to NULs. Shortens buffer as needed and pads with NULs.
 362  * End of buffer is completed with token identifying length of buffer.
 363  */
 364 static void *brcmf_fw_nvram_strip(const u8 *data, size_t data_len,
 365                                   u32 *new_length, u16 domain_nr, u16 bus_nr)
 366 {
 367         struct nvram_parser nvp;
 368         u32 pad;
 369         u32 token;
 370         __le32 token_le;
 371
 372         if (brcmf_init_nvram_parser(&nvp, data, data_len) < 0)
 373                 return NULL;
 374
 375         while (nvp.pos < data_len) {
 376                 nvp.state = nv_parser_states[nvp.state](&nvp);
 377                 if (nvp.state == END)
 378                         break;
 379         }
 380         if (nvp.multi_dev_v1)
 381                 brcmf_fw_strip_multi_v1(&nvp, domain_nr, bus_nr);
 382         else if (nvp.multi_dev_v2)
 383                 brcmf_fw_strip_multi_v2(&nvp, domain_nr, bus_nr);
 384
 385         if (nvp.nvram_len == 0) {
 386                 kfree(nvp.nvram);
 387                 return NULL;
 388         }
 389
 390         pad = nvp.nvram_len;
 391         *new_length = roundup(nvp.nvram_len + 1, 4);
 392         while (pad != *new_length) {
 393                 nvp.nvram[pad] = 0;
 394                 pad++;
 395         }
 396
 397         token = *new_length / 4;
 398         token = (~token << 16) | (token & 0x0000FFFF);
 399         token_le = cpu_to_le32(token);
 400
 401         memcpy(&nvp.nvram[*new_length], &token_le, sizeof(token_le));
 402         *new_length += sizeof(token_le);
 403
 404         return nvp.nvram;
 405 }
 406
 407 void brcmf_fw_nvram_free(void *nvram)
 408 {
 409         kfree(nvram);
 410 }
 411
 412 struct brcmf_fw {
 413         struct device *dev;
 414         u16 flags;
 415         const struct firmware *code;
 416         const char *nvram_name;
 417         u16 domain_nr;
 418         u16 bus_nr;
 419         void (*done)(struct device *dev, const struct firmware *fw,
 420                      void *nvram_image, u32 nvram_len);
 421 };
 422
 423 static void brcmf_fw_request_nvram_done(const struct firmware *fw, void *ctx)
 424 {
 425         struct brcmf_fw *fwctx = ctx;
 426         u32 nvram_length = 0;
 427         void *nvram = NULL;
 428         u8 *data = NULL;
 429         size_t data_len;
 430         bool raw_nvram;
 431
 432         brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev));
 433         if (fw && fw->data) {
 434                 data = (u8 *)fw->data;
 435                 data_len = fw->size;
 436                 raw_nvram = false;
 437         } else {
 438                 data = bcm47xx_nvram_get_contents(&data_len);
 439                 if (!data && !(fwctx->flags & BRCMF_FW_REQ_NV_OPTIONAL))
 440                         goto fail;
 441                 raw_nvram = true;
 442         }
 443
 444         if (data)
 445                 nvram = brcmf_fw_nvram_strip(data, data_len, &nvram_length,
 446                                              fwctx->domain_nr, fwctx->bus_nr);
 447
 448         if (raw_nvram)
 449                 bcm47xx_nvram_release_contents(data);
 450         release_firmware(fw);
 451         if (!nvram && !(fwctx->flags & BRCMF_FW_REQ_NV_OPTIONAL))
 452                 goto fail;
 453
 454         fwctx->done(fwctx->dev, fwctx->code, nvram, nvram_length);
 455         kfree(fwctx);
 456         return;
 457
 458 fail:
 459         brcmf_dbg(TRACE, "failed: dev=%s\n", dev_name(fwctx->dev));
 460         release_firmware(fwctx->code);
 461         device_release_driver(fwctx->dev);
 462         kfree(fwctx);
 463 }
 464
 465 static void brcmf_fw_request_code_done(const struct firmware *fw, void *ctx)
 466 {
 467         struct brcmf_fw *fwctx = ctx;
 468         int ret;
 469
 470         brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev));
 471         if (!fw)
 472                 goto fail;
 473
 474         /* only requested code so done here */
 475         if (!(fwctx->flags & BRCMF_FW_REQUEST_NVRAM)) {
 476                 fwctx->done(fwctx->dev, fw, NULL, 0);
 477                 kfree(fwctx);
 478                 return;
 479         }
 480         fwctx->code = fw;
 481         ret = request_firmware_nowait(THIS_MODULE, true, fwctx->nvram_name,
 482                                       fwctx->dev, GFP_KERNEL, fwctx,
 483                                       brcmf_fw_request_nvram_done);
 484
 485         if (!ret)
 486                 return;
 487
 488         brcmf_fw_request_nvram_done(NULL, fwctx);
 489         return;
 490
 491 fail:
 492         brcmf_dbg(TRACE, "failed: dev=%s\n", dev_name(fwctx->dev));
 493         device_release_driver(fwctx->dev);
 494         kfree(fwctx);
 495 }
 496
 497 int brcmf_fw_get_firmwares_pcie(struct device *dev, u16 flags,
 498                                 const char *code, const char *nvram,
 499                                 void (*fw_cb)(struct device *dev,
 500                                               const struct firmware *fw,
 501                                               void *nvram_image, u32 nvram_len),
 502                                 u16 domain_nr, u16 bus_nr)
 503 {
 504         struct brcmf_fw *fwctx;
 505
 506         brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(dev));
 507         if (!fw_cb || !code)
 508                 return -EINVAL;
 509
 510         if ((flags & BRCMF_FW_REQUEST_NVRAM) && !nvram)
 511                 return -EINVAL;
 512
 513         fwctx = kzalloc(sizeof(*fwctx), GFP_KERNEL);
 514         if (!fwctx)
 515                 return -ENOMEM;
 516
 517         fwctx->dev = dev;
 518         fwctx->flags = flags;
 519         fwctx->done = fw_cb;
 520         if (flags & BRCMF_FW_REQUEST_NVRAM)
 521                 fwctx->nvram_name = nvram;
 522         fwctx->domain_nr = domain_nr;
 523         fwctx->bus_nr = bus_nr;
 524
 525         return request_firmware_nowait(THIS_MODULE, true, code, dev,
 526                                        GFP_KERNEL, fwctx,
 527                                        brcmf_fw_request_code_done);
 528 }
 529
 530 int brcmf_fw_get_firmwares(struct device *dev, u16 flags,
 531                            const char *code, const char *nvram,
 532                            void (*fw_cb)(struct device *dev,
 533                                          const struct firmware *fw,
 534                                          void *nvram_image, u32 nvram_len))
 535 {
 536         return brcmf_fw_get_firmwares_pcie(dev, flags, code, nvram, fw_cb, 0,
 537                                            0);
 538 }
 539
 540 int brcmf_fw_map_chip_to_name(u32 chip, u32 chiprev,
 541                               struct brcmf_firmware_mapping mapping_table[],
 542                               u32 table_size, char fw_name[BRCMF_FW_NAME_LEN],
 543                               char nvram_name[BRCMF_FW_NAME_LEN])
 544 {
 545         u32 i;
 546         char end;
 547
 548         for (i = 0; i < table_size; i++) {
 549                 if (mapping_table[i].chipid == chip &&
 550                     mapping_table[i].revmask & BIT(chiprev))
 551                         break;
 552         }
 553
 554         if (i == table_size) {
 555                 brcmf_err("Unknown chipid %d [%d]\n", chip, chiprev);
 556                 return -ENODEV;
 557         }
 558
 559         /* check if firmware path is provided by module parameter */
 560         if (brcmf_mp_global.firmware_path[0] != '\0') {
 561                 strlcpy(fw_name, brcmf_mp_global.firmware_path,
 562                         BRCMF_FW_NAME_LEN);
 563                 if ((nvram_name) && (mapping_table[i].nvram))
 564                         strlcpy(nvram_name, brcmf_mp_global.firmware_path,
 565                                 BRCMF_FW_NAME_LEN);
 566
 567                 end = brcmf_mp_global.firmware_path[
 568                                 strlen(brcmf_mp_global.firmware_path) - 1];
 569                 if (end != '/') {
 570                         strlcat(fw_name, "/", BRCMF_FW_NAME_LEN);
 571                         if ((nvram_name) && (mapping_table[i].nvram))
 572                                 strlcat(nvram_name, "/", BRCMF_FW_NAME_LEN);
 573                 }
 574         }
 575         strlcat(fw_name, mapping_table[i].fw, BRCMF_FW_NAME_LEN);
 576         if ((nvram_name) && (mapping_table[i].nvram))
 577                 strlcat(nvram_name, mapping_table[i].nvram, BRCMF_FW_NAME_LEN);
 578
 579         return 0;
 580 }
 581