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 #include "chip.h"
  29
  30 #define BRCMF_FW_MAX_NVRAM_SIZE                 64000
  31 #define BRCMF_FW_NVRAM_DEVPATH_LEN              19      /* devpath0=pcie/1/4/ */
  32 #define BRCMF_FW_NVRAM_PCIEDEV_LEN              10      /* pcie/1/4/ + \0 */
  33 #define BRCMF_FW_DEFAULT_BOARDREV               "boardrev=0xff"
  34
  35 enum nvram_parser_state {
  36         IDLE,
  37         KEY,
  38         VALUE,
  39         COMMENT,
  40         END
  41 };
  42
  43 /**
  44  * struct nvram_parser - internal info for parser.
  45  *
  46  * @state: current parser state.
  47  * @data: input buffer being parsed.
  48  * @nvram: output buffer with parse result.
  49  * @nvram_len: lenght of parse result.
  50  * @line: current line.
  51  * @column: current column in line.
  52  * @pos: byte offset in input buffer.
  53  * @entry: start position of key,value entry.
  54  * @multi_dev_v1: detect pcie multi device v1 (compressed).
  55  * @multi_dev_v2: detect pcie multi device v2.
  56  * @boardrev_found: nvram contains boardrev information.
  57  */
  58 struct nvram_parser {
  59         enum nvram_parser_state state;
  60         const u8 *data;
  61         u8 *nvram;
  62         u32 nvram_len;
  63         u32 line;
  64         u32 column;
  65         u32 pos;
  66         u32 entry;
  67         bool multi_dev_v1;
  68         bool multi_dev_v2;
  69         bool boardrev_found;
  70 };
  71
  72 /**
  73  * is_nvram_char() - check if char is a valid one for NVRAM entry
  74  *
  75  * It accepts all printable ASCII chars except for '#' which opens a comment.
  76  * Please note that ' ' (space) while accepted is not a valid key name char.
  77  */
  78 static bool is_nvram_char(char c)
  79 {
  80         /* comment marker excluded */
  81         if (c == '#')
  82                 return false;
  83
  84         /* key and value may have any other readable character */
  85         return (c >= 0x20 && c < 0x7f);
  86 }
  87
  88 static bool is_whitespace(char c)
  89 {
  90         return (c == ' ' || c == '\r' || c == '\n' || c == '\t');
  91 }
  92
  93 static enum nvram_parser_state brcmf_nvram_handle_idle(struct nvram_parser *nvp)
  94 {
  95         char c;
  96
  97         c = nvp->data[nvp->pos];
  98         if (c == '\n')
  99                 return COMMENT;
 100         if (is_whitespace(c) || c == '\0')
 101                 goto proceed;
 102         if (c == '#')
 103                 return COMMENT;
 104         if (is_nvram_char(c)) {
 105                 nvp->entry = nvp->pos;
 106                 return KEY;
 107         }
 108         brcmf_dbg(INFO, "warning: ln=%d:col=%d: ignoring invalid character\n",
 109                   nvp->line, nvp->column);
 110 proceed:
 111         nvp->column++;
 112         nvp->pos++;
 113         return IDLE;
 114 }
 115
 116 static enum nvram_parser_state brcmf_nvram_handle_key(struct nvram_parser *nvp)
 117 {
 118         enum nvram_parser_state st = nvp->state;
 119         char c;
 120
 121         c = nvp->data[nvp->pos];
 122         if (c == '=') {
 123                 /* ignore RAW1 by treating as comment */
 124                 if (strncmp(&nvp->data[nvp->entry], "RAW1", 4) == 0)
 125                         st = COMMENT;
 126                 else
 127                         st = VALUE;
 128                 if (strncmp(&nvp->data[nvp->entry], "devpath", 7) == 0)
 129                         nvp->multi_dev_v1 = true;
 130                 if (strncmp(&nvp->data[nvp->entry], "pcie/", 5) == 0)
 131                         nvp->multi_dev_v2 = true;
 132                 if (strncmp(&nvp->data[nvp->entry], "boardrev", 8) == 0)
 133                         nvp->boardrev_found = true;
 134         } else if (!is_nvram_char(c) || c == ' ') {
 135                 brcmf_dbg(INFO, "warning: ln=%d:col=%d: '=' expected, skip invalid key entry\n",
 136                           nvp->line, nvp->column);
 137                 return COMMENT;
 138         }
 139
 140         nvp->column++;
 141         nvp->pos++;
 142         return st;
 143 }
 144
 145 static enum nvram_parser_state
 146 brcmf_nvram_handle_value(struct nvram_parser *nvp)
 147 {
 148         char c;
 149         char *skv;
 150         char *ekv;
 151         u32 cplen;
 152
 153         c = nvp->data[nvp->pos];
 154         if (!is_nvram_char(c)) {
 155                 /* key,value pair complete */
 156                 ekv = (u8 *)&nvp->data[nvp->pos];
 157                 skv = (u8 *)&nvp->data[nvp->entry];
 158                 cplen = ekv - skv;
 159                 if (nvp->nvram_len + cplen + 1 >= BRCMF_FW_MAX_NVRAM_SIZE)
 160                         return END;
 161                 /* copy to output buffer */
 162                 memcpy(&nvp->nvram[nvp->nvram_len], skv, cplen);
 163                 nvp->nvram_len += cplen;
 164                 nvp->nvram[nvp->nvram_len] = '\0';
 165                 nvp->nvram_len++;
 166                 return IDLE;
 167         }
 168         nvp->pos++;
 169         nvp->column++;
 170         return VALUE;
 171 }
 172
 173 static enum nvram_parser_state
 174 brcmf_nvram_handle_comment(struct nvram_parser *nvp)
 175 {
 176         char *eoc, *sol;
 177
 178         sol = (char *)&nvp->data[nvp->pos];
 179         eoc = strchr(sol, '\n');
 180         if (!eoc) {
 181                 eoc = strchr(sol, '\0');
 182                 if (!eoc)
 183                         return END;
 184         }
 185
 186         /* eat all moving to next line */
 187         nvp->line++;
 188         nvp->column = 1;
 189         nvp->pos += (eoc - sol) + 1;
 190         return IDLE;
 191 }
 192
 193 static enum nvram_parser_state brcmf_nvram_handle_end(struct nvram_parser *nvp)
 194 {
 195         /* final state */
 196         return END;
 197 }
 198
 199 static enum nvram_parser_state
 200 (*nv_parser_states[])(struct nvram_parser *nvp) = {
 201         brcmf_nvram_handle_idle,
 202         brcmf_nvram_handle_key,
 203         brcmf_nvram_handle_value,
 204         brcmf_nvram_handle_comment,
 205         brcmf_nvram_handle_end
 206 };
 207
 208 static int brcmf_init_nvram_parser(struct nvram_parser *nvp,
 209                                    const u8 *data, size_t data_len)
 210 {
 211         size_t size;
 212
 213         memset(nvp, 0, sizeof(*nvp));
 214         nvp->data = data;
 215         /* Limit size to MAX_NVRAM_SIZE, some files contain lot of comment */
 216         if (data_len > BRCMF_FW_MAX_NVRAM_SIZE)
 217                 size = BRCMF_FW_MAX_NVRAM_SIZE;
 218         else
 219                 size = data_len;
 220         /* Add space for properties we may add */
 221         size += strlen(BRCMF_FW_DEFAULT_BOARDREV) + 1;
 222         /* Alloc for extra 0 byte + roundup by 4 + length field */
 223         size += 1 + 3 + sizeof(u32);
 224         nvp->nvram = kzalloc(size, GFP_KERNEL);
 225         if (!nvp->nvram)
 226                 return -ENOMEM;
 227
 228         nvp->line = 1;
 229         nvp->column = 1;
 230         return 0;
 231 }
 232
 233 /* brcmf_fw_strip_multi_v1 :Some nvram files contain settings for multiple
 234  * devices. Strip it down for one device, use domain_nr/bus_nr to determine
 235  * which data is to be returned. v1 is the version where nvram is stored
 236  * compressed and "devpath" maps to index for valid entries.
 237  */
 238 static void brcmf_fw_strip_multi_v1(struct nvram_parser *nvp, u16 domain_nr,
 239                                     u16 bus_nr)
 240 {
 241         /* Device path with a leading '=' key-value separator */
 242         char pci_path[] = "=pci/?/?";
 243         size_t pci_len;
 244         char pcie_path[] = "=pcie/?/?";
 245         size_t pcie_len;
 246
 247         u32 i, j;
 248         bool found;
 249         u8 *nvram;
 250         u8 id;
 251
 252         nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL);
 253         if (!nvram)
 254                 goto fail;
 255
 256         /* min length: devpath0=pcie/1/4/ + 0:x=y */
 257         if (nvp->nvram_len < BRCMF_FW_NVRAM_DEVPATH_LEN + 6)
 258                 goto fail;
 259
 260         /* First search for the devpathX and see if it is the configuration
 261          * for domain_nr/bus_nr. Search complete nvp
 262          */
 263         snprintf(pci_path, sizeof(pci_path), "=pci/%d/%d", domain_nr,
 264                  bus_nr);
 265         pci_len = strlen(pci_path);
 266         snprintf(pcie_path, sizeof(pcie_path), "=pcie/%d/%d", domain_nr,
 267                  bus_nr);
 268         pcie_len = strlen(pcie_path);
 269         found = false;
 270         i = 0;
 271         while (i < nvp->nvram_len - BRCMF_FW_NVRAM_DEVPATH_LEN) {
 272                 /* Format: devpathX=pcie/Y/Z/
 273                  * Y = domain_nr, Z = bus_nr, X = virtual ID
 274                  */
 275                 if (strncmp(&nvp->nvram[i], "devpath", 7) == 0 &&
 276                     (!strncmp(&nvp->nvram[i + 8], pci_path, pci_len) ||
 277                      !strncmp(&nvp->nvram[i + 8], pcie_path, pcie_len))) {
 278                         id = nvp->nvram[i + 7] - '0';
 279                         found = true;
 280                         break;
 281                 }
 282                 while (nvp->nvram[i] != 0)
 283                         i++;
 284                 i++;
 285         }
 286         if (!found)
 287                 goto fail;
 288
 289         /* Now copy all valid entries, release old nvram and assign new one */
 290         i = 0;
 291         j = 0;
 292         while (i < nvp->nvram_len) {
 293                 if ((nvp->nvram[i] - '0' == id) && (nvp->nvram[i + 1] == ':')) {
 294                         i += 2;
 295                         if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0)
 296                                 nvp->boardrev_found = true;
 297                         while (nvp->nvram[i] != 0) {
 298                                 nvram[j] = nvp->nvram[i];
 299                                 i++;
 300                                 j++;
 301                         }
 302                         nvram[j] = 0;
 303                         j++;
 304                 }
 305                 while (nvp->nvram[i] != 0)
 306                         i++;
 307                 i++;
 308         }
 309         kfree(nvp->nvram);
 310         nvp->nvram = nvram;
 311         nvp->nvram_len = j;
 312         return;
 313
 314 fail:
 315         kfree(nvram);
 316         nvp->nvram_len = 0;
 317 }
 318
 319 /* brcmf_fw_strip_multi_v2 :Some nvram files contain settings for multiple
 320  * devices. Strip it down for one device, use domain_nr/bus_nr to determine
 321  * which data is to be returned. v2 is the version where nvram is stored
 322  * uncompressed, all relevant valid entries are identified by
 323  * pcie/domain_nr/bus_nr:
 324  */
 325 static void brcmf_fw_strip_multi_v2(struct nvram_parser *nvp, u16 domain_nr,
 326                                     u16 bus_nr)
 327 {
 328         char prefix[BRCMF_FW_NVRAM_PCIEDEV_LEN];
 329         size_t len;
 330         u32 i, j;
 331         u8 *nvram;
 332
 333         nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL);
 334         if (!nvram)
 335                 goto fail;
 336
 337         /* Copy all valid entries, release old nvram and assign new one.
 338          * Valid entries are of type pcie/X/Y/ where X = domain_nr and
 339          * Y = bus_nr.
 340          */
 341         snprintf(prefix, sizeof(prefix), "pcie/%d/%d/", domain_nr, bus_nr);
 342         len = strlen(prefix);
 343         i = 0;
 344         j = 0;
 345         while (i < nvp->nvram_len - len) {
 346                 if (strncmp(&nvp->nvram[i], prefix, len) == 0) {
 347                         i += len;
 348                         if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0)
 349                                 nvp->boardrev_found = true;
 350                         while (nvp->nvram[i] != 0) {
 351                                 nvram[j] = nvp->nvram[i];
 352                                 i++;
 353                                 j++;
 354                         }
 355                         nvram[j] = 0;
 356                         j++;
 357                 }
 358                 while (nvp->nvram[i] != 0)
 359                         i++;
 360                 i++;
 361         }
 362         kfree(nvp->nvram);
 363         nvp->nvram = nvram;
 364         nvp->nvram_len = j;
 365         return;
 366 fail:
 367         kfree(nvram);
 368         nvp->nvram_len = 0;
 369 }
 370
 371 static void brcmf_fw_add_defaults(struct nvram_parser *nvp)
 372 {
 373         if (nvp->boardrev_found)
 374                 return;
 375
 376         memcpy(&nvp->nvram[nvp->nvram_len], &BRCMF_FW_DEFAULT_BOARDREV,
 377                strlen(BRCMF_FW_DEFAULT_BOARDREV));
 378         nvp->nvram_len += strlen(BRCMF_FW_DEFAULT_BOARDREV);
 379         nvp->nvram[nvp->nvram_len] = '\0';
 380         nvp->nvram_len++;
 381 }
 382
 383 /* brcmf_nvram_strip :Takes a buffer of "<var>=<value>\n" lines read from a fil
 384  * and ending in a NUL. Removes carriage returns, empty lines, comment lines,
 385  * and converts newlines to NULs. Shortens buffer as needed and pads with NULs.
 386  * End of buffer is completed with token identifying length of buffer.
 387  */
 388 static void *brcmf_fw_nvram_strip(const u8 *data, size_t data_len,
 389                                   u32 *new_length, u16 domain_nr, u16 bus_nr)
 390 {
 391         struct nvram_parser nvp;
 392         u32 pad;
 393         u32 token;
 394         __le32 token_le;
 395
 396         if (brcmf_init_nvram_parser(&nvp, data, data_len) < 0)
 397                 return NULL;
 398
 399         while (nvp.pos < data_len) {
 400                 nvp.state = nv_parser_states[nvp.state](&nvp);
 401                 if (nvp.state == END)
 402                         break;
 403         }
 404         if (nvp.multi_dev_v1) {
 405                 nvp.boardrev_found = false;
 406                 brcmf_fw_strip_multi_v1(&nvp, domain_nr, bus_nr);
 407         } else if (nvp.multi_dev_v2) {
 408                 nvp.boardrev_found = false;
 409                 brcmf_fw_strip_multi_v2(&nvp, domain_nr, bus_nr);
 410         }
 411
 412         if (nvp.nvram_len == 0) {
 413                 kfree(nvp.nvram);
 414                 return NULL;
 415         }
 416
 417         brcmf_fw_add_defaults(&nvp);
 418
 419         pad = nvp.nvram_len;
 420         *new_length = roundup(nvp.nvram_len + 1, 4);
 421         while (pad != *new_length) {
 422                 nvp.nvram[pad] = 0;
 423                 pad++;
 424         }
 425
 426         token = *new_length / 4;
 427         token = (~token << 16) | (token & 0x0000FFFF);
 428         token_le = cpu_to_le32(token);
 429
 430         memcpy(&nvp.nvram[*new_length], &token_le, sizeof(token_le));
 431         *new_length += sizeof(token_le);
 432
 433         return nvp.nvram;
 434 }
 435
 436 void brcmf_fw_nvram_free(void *nvram)
 437 {
 438         kfree(nvram);
 439 }
 440
 441 struct brcmf_fw {
 442         struct device *dev;
 443         struct brcmf_fw_request *req;
 444         u32 curpos;
 445         void (*done)(struct device *dev, int err, struct brcmf_fw_request *req);
 446 };
 447
 448 static void brcmf_fw_request_done(const struct firmware *fw, void *ctx);
 449
 450 static void brcmf_fw_free_request(struct brcmf_fw_request *req)
 451 {
 452         struct brcmf_fw_item *item;
 453         int i;
 454
 455         for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) {
 456                 if (item->type == BRCMF_FW_TYPE_BINARY)
 457                         release_firmware(item->binary);
 458                 else if (item->type == BRCMF_FW_TYPE_NVRAM)
 459                         brcmf_fw_nvram_free(item->nv_data.data);
 460         }
 461         kfree(req);
 462 }
 463
 464 static int brcmf_fw_request_nvram_done(const struct firmware *fw, void *ctx)
 465 {
 466         struct brcmf_fw *fwctx = ctx;
 467         struct brcmf_fw_item *cur;
 468         u32 nvram_length = 0;
 469         void *nvram = NULL;
 470         u8 *data = NULL;
 471         size_t data_len;
 472         bool raw_nvram;
 473
 474         brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev));
 475
 476         cur = &fwctx->req->items[fwctx->curpos];
 477
 478         if (fw && fw->data) {
 479                 data = (u8 *)fw->data;
 480                 data_len = fw->size;
 481                 raw_nvram = false;
 482         } else {
 483                 data = bcm47xx_nvram_get_contents(&data_len);
 484                 if (!data && !(cur->flags & BRCMF_FW_REQF_OPTIONAL))
 485                         goto fail;
 486                 raw_nvram = true;
 487         }
 488
 489         if (data)
 490                 nvram = brcmf_fw_nvram_strip(data, data_len, &nvram_length,
 491                                              fwctx->req->domain_nr,
 492                                              fwctx->req->bus_nr);
 493
 494         if (raw_nvram)
 495                 bcm47xx_nvram_release_contents(data);
 496         release_firmware(fw);
 497         if (!nvram && !(cur->flags & BRCMF_FW_REQF_OPTIONAL))
 498                 goto fail;
 499
 500         brcmf_dbg(TRACE, "nvram %p len %d\n", nvram, nvram_length);
 501         cur->nv_data.data = nvram;
 502         cur->nv_data.len = nvram_length;
 503         return 0;
 504
 505 fail:
 506         return -ENOENT;
 507 }
 508
 509 static int brcmf_fw_request_next_item(struct brcmf_fw *fwctx, bool async)
 510 {
 511         struct brcmf_fw_item *cur;
 512         const struct firmware *fw = NULL;
 513         int ret;
 514
 515         cur = &fwctx->req->items[fwctx->curpos];
 516
 517         brcmf_dbg(TRACE, "%srequest for %s\n", async ? "async " : "",
 518                   cur->path);
 519
 520         if (async)
 521                 ret = reject_firmware_nowait(THIS_MODULE, true, cur->path,
 522                                               fwctx->dev, GFP_KERNEL, fwctx,
 523                                               brcmf_fw_request_done);
 524         else
 525                 ret = reject_firmware(&fw, cur->path, fwctx->dev);
 526
 527         if (ret < 0) {
 528                 brcmf_fw_request_done(NULL, fwctx);
 529         } else if (!async && fw) {
 530                 brcmf_dbg(TRACE, "firmware %s %sfound\n", cur->path,
 531                           fw ? "" : "not ");
 532                 if (cur->type == BRCMF_FW_TYPE_BINARY)
 533                         cur->binary = fw;
 534                 else if (cur->type == BRCMF_FW_TYPE_NVRAM)
 535                         brcmf_fw_request_nvram_done(fw, fwctx);
 536                 else
 537                         release_firmware(fw);
 538
 539                 return -EAGAIN;
 540         }
 541         return 0;
 542 }
 543
 544 static void brcmf_fw_request_done(const struct firmware *fw, void *ctx)
 545 {
 546         struct brcmf_fw *fwctx = ctx;
 547         struct brcmf_fw_item *cur;
 548         int ret = 0;
 549
 550         cur = &fwctx->req->items[fwctx->curpos];
 551
 552         brcmf_dbg(TRACE, "enter: firmware %s %sfound\n", cur->path,
 553                   fw ? "" : "not ");
 554
 555         if (!fw)
 556                 ret = -ENOENT;
 557
 558         switch (cur->type) {
 559         case BRCMF_FW_TYPE_NVRAM:
 560                 ret = brcmf_fw_request_nvram_done(fw, fwctx);
 561                 break;
 562         case BRCMF_FW_TYPE_BINARY:
 563                 cur->binary = fw;
 564                 break;
 565         default:
 566                 /* something fishy here so bail out early */
 567                 brcmf_err("unknown fw type: %d\n", cur->type);
 568                 release_firmware(fw);
 569                 ret = -EINVAL;
 570                 goto fail;
 571         }
 572
 573         if (ret < 0 && !(cur->flags & BRCMF_FW_REQF_OPTIONAL))
 574                 goto fail;
 575
 576         do {
 577                 if (++fwctx->curpos == fwctx->req->n_items) {
 578                         ret = 0;
 579                         goto done;
 580                 }
 581
 582                 ret = brcmf_fw_request_next_item(fwctx, false);
 583         } while (ret == -EAGAIN);
 584
 585         return;
 586
 587 fail:
 588         brcmf_dbg(TRACE, "failed err=%d: dev=%s, fw=%s\n", ret,
 589                   dev_name(fwctx->dev), cur->path);
 590         brcmf_fw_free_request(fwctx->req);
 591         fwctx->req = NULL;
 592 done:
 593         fwctx->done(fwctx->dev, ret, fwctx->req);
 594         kfree(fwctx);
 595 }
 596
 597 static bool brcmf_fw_request_is_valid(struct brcmf_fw_request *req)
 598 {
 599         struct brcmf_fw_item *item;
 600         int i;
 601
 602         if (!req->n_items)
 603                 return false;
 604
 605         for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) {
 606                 if (!item->path)
 607                         return false;
 608         }
 609         return true;
 610 }
 611
 612 int brcmf_fw_get_firmwares(struct device *dev, struct brcmf_fw_request *req,
 613                            void (*fw_cb)(struct device *dev, int err,
 614                                          struct brcmf_fw_request *req))
 615 {
 616         struct brcmf_fw *fwctx;
 617
 618         brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(dev));
 619         if (!fw_cb)
 620                 return -EINVAL;
 621
 622         if (!brcmf_fw_request_is_valid(req))
 623                 return -EINVAL;
 624
 625         fwctx = kzalloc(sizeof(*fwctx), GFP_KERNEL);
 626         if (!fwctx)
 627                 return -ENOMEM;
 628
 629         fwctx->dev = dev;
 630         fwctx->req = req;
 631         fwctx->done = fw_cb;
 632
 633         brcmf_fw_request_next_item(fwctx, true);
 634         return 0;
 635 }
 636
 637 struct brcmf_fw_request *
 638 brcmf_fw_alloc_request(u32 chip, u32 chiprev,
 639                        const struct brcmf_firmware_mapping mapping_table[],
 640                        u32 table_size, struct brcmf_fw_name *fwnames,
 641                        u32 n_fwnames)
 642 {
 643         struct brcmf_fw_request *fwreq;
 644         char chipname[12];
 645         const char *mp_path;
 646         size_t mp_path_len;
 647         u32 i, j;
 648         char end = '\0';
 649         size_t reqsz;
 650
 651         for (i = 0; i < table_size; i++) {
 652                 if (mapping_table[i].chipid == chip &&
 653                     mapping_table[i].revmask & BIT(chiprev))
 654                         break;
 655         }
 656
 657         if (i == table_size) {
 658                 brcmf_err("Unknown chipid %d [%d]\n", chip, chiprev);
 659                 return NULL;
 660         }
 661
 662         reqsz = sizeof(*fwreq) + n_fwnames * sizeof(struct brcmf_fw_item);
 663         fwreq = kzalloc(reqsz, GFP_KERNEL);
 664         if (!fwreq)
 665                 return NULL;
 666
 667         brcmf_chip_name(chip, chiprev, chipname, sizeof(chipname));
 668
 669         brcmf_info("using %s for chip %s\n",
 670                    mapping_table[i].fw_base, chipname);
 671
 672         mp_path = brcmf_mp_global.firmware_path;
 673         mp_path_len = strnlen(mp_path, BRCMF_FW_ALTPATH_LEN);
 674         if (mp_path_len)
 675                 end = mp_path[mp_path_len - 1];
 676
 677         fwreq->n_items = n_fwnames;
 678
 679         for (j = 0; j < n_fwnames; j++) {
 680                 fwreq->items[j].path = fwnames[j].path;
 681                 /* check if firmware path is provided by module parameter */
 682                 if (brcmf_mp_global.firmware_path[0] != '\0') {
 683                         strlcpy(fwnames[j].path, mp_path,
 684                                 BRCMF_FW_NAME_LEN);
 685
 686                         if (end != '/') {
 687                                 strlcat(fwnames[j].path, "/",
 688                                         BRCMF_FW_NAME_LEN);
 689                         }
 690                 }
 691                 strlcat(fwnames[j].path, mapping_table[i].fw_base,
 692                         BRCMF_FW_NAME_LEN);
 693                 strlcat(fwnames[j].path, fwnames[j].extension,
 694                         BRCMF_FW_NAME_LEN);
 695                 fwreq->items[j].path = fwnames[j].path;
 696         }
 697
 698         return fwreq;
 699 }