1daeccac2SArend van Spriel // SPDX-License-Identifier: ISC 205491d2cSKalle Valo /* 305491d2cSKalle Valo * Copyright (c) 2013 Broadcom Corporation 405491d2cSKalle Valo */ 505491d2cSKalle Valo 6ce2e6db5SHans de Goede #include <linux/efi.h> 705491d2cSKalle Valo #include <linux/kernel.h> 805491d2cSKalle Valo #include <linux/slab.h> 905491d2cSKalle Valo #include <linux/device.h> 1005491d2cSKalle Valo #include <linux/firmware.h> 1105491d2cSKalle Valo #include <linux/module.h> 1205491d2cSKalle Valo #include <linux/bcm47xx_nvram.h> 1305491d2cSKalle Valo 1405491d2cSKalle Valo #include "debug.h" 1505491d2cSKalle Valo #include "firmware.h" 167d34b056SHante Meuleman #include "core.h" 177d34b056SHante Meuleman #include "common.h" 18c88cfa07SArend Van Spriel #include "chip.h" 1905491d2cSKalle Valo 2005491d2cSKalle Valo #define BRCMF_FW_MAX_NVRAM_SIZE 64000 2105491d2cSKalle Valo #define BRCMF_FW_NVRAM_DEVPATH_LEN 19 /* devpath0=pcie/1/4/ */ 2205491d2cSKalle Valo #define BRCMF_FW_NVRAM_PCIEDEV_LEN 10 /* pcie/1/4/ + \0 */ 2346f2b38aSHante Meuleman #define BRCMF_FW_DEFAULT_BOARDREV "boardrev=0xff" 2405491d2cSKalle Valo 2505491d2cSKalle Valo enum nvram_parser_state { 2605491d2cSKalle Valo IDLE, 2705491d2cSKalle Valo KEY, 2805491d2cSKalle Valo VALUE, 2905491d2cSKalle Valo COMMENT, 3005491d2cSKalle Valo END 3105491d2cSKalle Valo }; 3205491d2cSKalle Valo 3305491d2cSKalle Valo /** 3405491d2cSKalle Valo * struct nvram_parser - internal info for parser. 3505491d2cSKalle Valo * 3605491d2cSKalle Valo * @state: current parser state. 3705491d2cSKalle Valo * @data: input buffer being parsed. 3805491d2cSKalle Valo * @nvram: output buffer with parse result. 392359dd09SMatteo Croce * @nvram_len: length of parse result. 4005491d2cSKalle Valo * @line: current line. 4105491d2cSKalle Valo * @column: current column in line. 4205491d2cSKalle Valo * @pos: byte offset in input buffer. 4305491d2cSKalle Valo * @entry: start position of key,value entry. 4405491d2cSKalle Valo * @multi_dev_v1: detect pcie multi device v1 (compressed). 4505491d2cSKalle Valo * @multi_dev_v2: detect pcie multi device v2. 4646f2b38aSHante Meuleman * @boardrev_found: nvram contains boardrev information. 4705491d2cSKalle Valo */ 4805491d2cSKalle Valo struct nvram_parser { 4905491d2cSKalle Valo enum nvram_parser_state state; 5005491d2cSKalle Valo const u8 *data; 5105491d2cSKalle Valo u8 *nvram; 5205491d2cSKalle Valo u32 nvram_len; 5305491d2cSKalle Valo u32 line; 5405491d2cSKalle Valo u32 column; 5505491d2cSKalle Valo u32 pos; 5605491d2cSKalle Valo u32 entry; 5705491d2cSKalle Valo bool multi_dev_v1; 5805491d2cSKalle Valo bool multi_dev_v2; 5946f2b38aSHante Meuleman bool boardrev_found; 6005491d2cSKalle Valo }; 6105491d2cSKalle Valo 62866cf939SLee Jones /* 6305491d2cSKalle Valo * is_nvram_char() - check if char is a valid one for NVRAM entry 6405491d2cSKalle Valo * 6505491d2cSKalle Valo * It accepts all printable ASCII chars except for '#' which opens a comment. 6605491d2cSKalle Valo * Please note that ' ' (space) while accepted is not a valid key name char. 6705491d2cSKalle Valo */ 6805491d2cSKalle Valo static bool is_nvram_char(char c) 6905491d2cSKalle Valo { 7005491d2cSKalle Valo /* comment marker excluded */ 7105491d2cSKalle Valo if (c == '#') 7205491d2cSKalle Valo return false; 7305491d2cSKalle Valo 7405491d2cSKalle Valo /* key and value may have any other readable character */ 7505491d2cSKalle Valo return (c >= 0x20 && c < 0x7f); 7605491d2cSKalle Valo } 7705491d2cSKalle Valo 7805491d2cSKalle Valo static bool is_whitespace(char c) 7905491d2cSKalle Valo { 8005491d2cSKalle Valo return (c == ' ' || c == '\r' || c == '\n' || c == '\t'); 8105491d2cSKalle Valo } 8205491d2cSKalle Valo 8305491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_idle(struct nvram_parser *nvp) 8405491d2cSKalle Valo { 8505491d2cSKalle Valo char c; 8605491d2cSKalle Valo 8705491d2cSKalle Valo c = nvp->data[nvp->pos]; 8805491d2cSKalle Valo if (c == '\n') 8905491d2cSKalle Valo return COMMENT; 90d1e61b86SRafał Miłecki if (is_whitespace(c) || c == '\0') 9105491d2cSKalle Valo goto proceed; 9205491d2cSKalle Valo if (c == '#') 9305491d2cSKalle Valo return COMMENT; 9405491d2cSKalle Valo if (is_nvram_char(c)) { 9505491d2cSKalle Valo nvp->entry = nvp->pos; 9605491d2cSKalle Valo return KEY; 9705491d2cSKalle Valo } 9805491d2cSKalle Valo brcmf_dbg(INFO, "warning: ln=%d:col=%d: ignoring invalid character\n", 9905491d2cSKalle Valo nvp->line, nvp->column); 10005491d2cSKalle Valo proceed: 10105491d2cSKalle Valo nvp->column++; 10205491d2cSKalle Valo nvp->pos++; 10305491d2cSKalle Valo return IDLE; 10405491d2cSKalle Valo } 10505491d2cSKalle Valo 10605491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_key(struct nvram_parser *nvp) 10705491d2cSKalle Valo { 10805491d2cSKalle Valo enum nvram_parser_state st = nvp->state; 10905491d2cSKalle Valo char c; 11005491d2cSKalle Valo 11105491d2cSKalle Valo c = nvp->data[nvp->pos]; 11205491d2cSKalle Valo if (c == '=') { 11305491d2cSKalle Valo /* ignore RAW1 by treating as comment */ 11405491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "RAW1", 4) == 0) 11505491d2cSKalle Valo st = COMMENT; 11605491d2cSKalle Valo else 11705491d2cSKalle Valo st = VALUE; 11805491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "devpath", 7) == 0) 11905491d2cSKalle Valo nvp->multi_dev_v1 = true; 12005491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "pcie/", 5) == 0) 12105491d2cSKalle Valo nvp->multi_dev_v2 = true; 12246f2b38aSHante Meuleman if (strncmp(&nvp->data[nvp->entry], "boardrev", 8) == 0) 12346f2b38aSHante Meuleman nvp->boardrev_found = true; 12405491d2cSKalle Valo } else if (!is_nvram_char(c) || c == ' ') { 12505491d2cSKalle Valo brcmf_dbg(INFO, "warning: ln=%d:col=%d: '=' expected, skip invalid key entry\n", 12605491d2cSKalle Valo nvp->line, nvp->column); 12705491d2cSKalle Valo return COMMENT; 12805491d2cSKalle Valo } 12905491d2cSKalle Valo 13005491d2cSKalle Valo nvp->column++; 13105491d2cSKalle Valo nvp->pos++; 13205491d2cSKalle Valo return st; 13305491d2cSKalle Valo } 13405491d2cSKalle Valo 13505491d2cSKalle Valo static enum nvram_parser_state 13605491d2cSKalle Valo brcmf_nvram_handle_value(struct nvram_parser *nvp) 13705491d2cSKalle Valo { 13805491d2cSKalle Valo char c; 13905491d2cSKalle Valo char *skv; 14005491d2cSKalle Valo char *ekv; 14105491d2cSKalle Valo u32 cplen; 14205491d2cSKalle Valo 14305491d2cSKalle Valo c = nvp->data[nvp->pos]; 14405491d2cSKalle Valo if (!is_nvram_char(c)) { 14505491d2cSKalle Valo /* key,value pair complete */ 14605491d2cSKalle Valo ekv = (u8 *)&nvp->data[nvp->pos]; 14705491d2cSKalle Valo skv = (u8 *)&nvp->data[nvp->entry]; 14805491d2cSKalle Valo cplen = ekv - skv; 14905491d2cSKalle Valo if (nvp->nvram_len + cplen + 1 >= BRCMF_FW_MAX_NVRAM_SIZE) 15005491d2cSKalle Valo return END; 15105491d2cSKalle Valo /* copy to output buffer */ 15205491d2cSKalle Valo memcpy(&nvp->nvram[nvp->nvram_len], skv, cplen); 15305491d2cSKalle Valo nvp->nvram_len += cplen; 15405491d2cSKalle Valo nvp->nvram[nvp->nvram_len] = '\0'; 15505491d2cSKalle Valo nvp->nvram_len++; 15605491d2cSKalle Valo return IDLE; 15705491d2cSKalle Valo } 15805491d2cSKalle Valo nvp->pos++; 15905491d2cSKalle Valo nvp->column++; 16005491d2cSKalle Valo return VALUE; 16105491d2cSKalle Valo } 16205491d2cSKalle Valo 16305491d2cSKalle Valo static enum nvram_parser_state 16405491d2cSKalle Valo brcmf_nvram_handle_comment(struct nvram_parser *nvp) 16505491d2cSKalle Valo { 16605491d2cSKalle Valo char *eoc, *sol; 16705491d2cSKalle Valo 16805491d2cSKalle Valo sol = (char *)&nvp->data[nvp->pos]; 16905491d2cSKalle Valo eoc = strchr(sol, '\n'); 17005491d2cSKalle Valo if (!eoc) { 17105491d2cSKalle Valo eoc = strchr(sol, '\0'); 17205491d2cSKalle Valo if (!eoc) 17305491d2cSKalle Valo return END; 17405491d2cSKalle Valo } 17505491d2cSKalle Valo 17605491d2cSKalle Valo /* eat all moving to next line */ 17705491d2cSKalle Valo nvp->line++; 17805491d2cSKalle Valo nvp->column = 1; 17905491d2cSKalle Valo nvp->pos += (eoc - sol) + 1; 18005491d2cSKalle Valo return IDLE; 18105491d2cSKalle Valo } 18205491d2cSKalle Valo 18305491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_end(struct nvram_parser *nvp) 18405491d2cSKalle Valo { 18505491d2cSKalle Valo /* final state */ 18605491d2cSKalle Valo return END; 18705491d2cSKalle Valo } 18805491d2cSKalle Valo 18905491d2cSKalle Valo static enum nvram_parser_state 19005491d2cSKalle Valo (*nv_parser_states[])(struct nvram_parser *nvp) = { 19105491d2cSKalle Valo brcmf_nvram_handle_idle, 19205491d2cSKalle Valo brcmf_nvram_handle_key, 19305491d2cSKalle Valo brcmf_nvram_handle_value, 19405491d2cSKalle Valo brcmf_nvram_handle_comment, 19505491d2cSKalle Valo brcmf_nvram_handle_end 19605491d2cSKalle Valo }; 19705491d2cSKalle Valo 19805491d2cSKalle Valo static int brcmf_init_nvram_parser(struct nvram_parser *nvp, 19905491d2cSKalle Valo const u8 *data, size_t data_len) 20005491d2cSKalle Valo { 20105491d2cSKalle Valo size_t size; 20205491d2cSKalle Valo 20305491d2cSKalle Valo memset(nvp, 0, sizeof(*nvp)); 20405491d2cSKalle Valo nvp->data = data; 20505491d2cSKalle Valo /* Limit size to MAX_NVRAM_SIZE, some files contain lot of comment */ 20605491d2cSKalle Valo if (data_len > BRCMF_FW_MAX_NVRAM_SIZE) 20705491d2cSKalle Valo size = BRCMF_FW_MAX_NVRAM_SIZE; 20805491d2cSKalle Valo else 20905491d2cSKalle Valo size = data_len; 210d19d8e3bSHector Martin /* Add space for properties we may add */ 211d19d8e3bSHector Martin size += strlen(BRCMF_FW_DEFAULT_BOARDREV) + 1; 21205491d2cSKalle Valo /* Alloc for extra 0 byte + roundup by 4 + length field */ 21305491d2cSKalle Valo size += 1 + 3 + sizeof(u32); 21405491d2cSKalle Valo nvp->nvram = kzalloc(size, GFP_KERNEL); 21505491d2cSKalle Valo if (!nvp->nvram) 21605491d2cSKalle Valo return -ENOMEM; 21705491d2cSKalle Valo 21805491d2cSKalle Valo nvp->line = 1; 21905491d2cSKalle Valo nvp->column = 1; 22005491d2cSKalle Valo return 0; 22105491d2cSKalle Valo } 22205491d2cSKalle Valo 22305491d2cSKalle Valo /* brcmf_fw_strip_multi_v1 :Some nvram files contain settings for multiple 22405491d2cSKalle Valo * devices. Strip it down for one device, use domain_nr/bus_nr to determine 22505491d2cSKalle Valo * which data is to be returned. v1 is the version where nvram is stored 22605491d2cSKalle Valo * compressed and "devpath" maps to index for valid entries. 22705491d2cSKalle Valo */ 22805491d2cSKalle Valo static void brcmf_fw_strip_multi_v1(struct nvram_parser *nvp, u16 domain_nr, 22905491d2cSKalle Valo u16 bus_nr) 23005491d2cSKalle Valo { 23105491d2cSKalle Valo /* Device path with a leading '=' key-value separator */ 23205491d2cSKalle Valo char pci_path[] = "=pci/?/?"; 23305491d2cSKalle Valo size_t pci_len; 23405491d2cSKalle Valo char pcie_path[] = "=pcie/?/?"; 23505491d2cSKalle Valo size_t pcie_len; 23605491d2cSKalle Valo 23705491d2cSKalle Valo u32 i, j; 23805491d2cSKalle Valo bool found; 23905491d2cSKalle Valo u8 *nvram; 24005491d2cSKalle Valo u8 id; 24105491d2cSKalle Valo 24205491d2cSKalle Valo nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL); 24305491d2cSKalle Valo if (!nvram) 24405491d2cSKalle Valo goto fail; 24505491d2cSKalle Valo 24605491d2cSKalle Valo /* min length: devpath0=pcie/1/4/ + 0:x=y */ 24705491d2cSKalle Valo if (nvp->nvram_len < BRCMF_FW_NVRAM_DEVPATH_LEN + 6) 24805491d2cSKalle Valo goto fail; 24905491d2cSKalle Valo 25005491d2cSKalle Valo /* First search for the devpathX and see if it is the configuration 25105491d2cSKalle Valo * for domain_nr/bus_nr. Search complete nvp 25205491d2cSKalle Valo */ 25305491d2cSKalle Valo snprintf(pci_path, sizeof(pci_path), "=pci/%d/%d", domain_nr, 25405491d2cSKalle Valo bus_nr); 25505491d2cSKalle Valo pci_len = strlen(pci_path); 25605491d2cSKalle Valo snprintf(pcie_path, sizeof(pcie_path), "=pcie/%d/%d", domain_nr, 25705491d2cSKalle Valo bus_nr); 25805491d2cSKalle Valo pcie_len = strlen(pcie_path); 25905491d2cSKalle Valo found = false; 26005491d2cSKalle Valo i = 0; 26105491d2cSKalle Valo while (i < nvp->nvram_len - BRCMF_FW_NVRAM_DEVPATH_LEN) { 26205491d2cSKalle Valo /* Format: devpathX=pcie/Y/Z/ 26305491d2cSKalle Valo * Y = domain_nr, Z = bus_nr, X = virtual ID 26405491d2cSKalle Valo */ 26505491d2cSKalle Valo if (strncmp(&nvp->nvram[i], "devpath", 7) == 0 && 26605491d2cSKalle Valo (!strncmp(&nvp->nvram[i + 8], pci_path, pci_len) || 26705491d2cSKalle Valo !strncmp(&nvp->nvram[i + 8], pcie_path, pcie_len))) { 26805491d2cSKalle Valo id = nvp->nvram[i + 7] - '0'; 26905491d2cSKalle Valo found = true; 27005491d2cSKalle Valo break; 27105491d2cSKalle Valo } 27205491d2cSKalle Valo while (nvp->nvram[i] != 0) 27305491d2cSKalle Valo i++; 27405491d2cSKalle Valo i++; 27505491d2cSKalle Valo } 27605491d2cSKalle Valo if (!found) 27705491d2cSKalle Valo goto fail; 27805491d2cSKalle Valo 27905491d2cSKalle Valo /* Now copy all valid entries, release old nvram and assign new one */ 28005491d2cSKalle Valo i = 0; 28105491d2cSKalle Valo j = 0; 28205491d2cSKalle Valo while (i < nvp->nvram_len) { 28305491d2cSKalle Valo if ((nvp->nvram[i] - '0' == id) && (nvp->nvram[i + 1] == ':')) { 28405491d2cSKalle Valo i += 2; 28546f2b38aSHante Meuleman if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0) 28646f2b38aSHante Meuleman nvp->boardrev_found = true; 28705491d2cSKalle Valo while (nvp->nvram[i] != 0) { 28805491d2cSKalle Valo nvram[j] = nvp->nvram[i]; 28905491d2cSKalle Valo i++; 29005491d2cSKalle Valo j++; 29105491d2cSKalle Valo } 29205491d2cSKalle Valo nvram[j] = 0; 29305491d2cSKalle Valo j++; 29405491d2cSKalle Valo } 29505491d2cSKalle Valo while (nvp->nvram[i] != 0) 29605491d2cSKalle Valo i++; 29705491d2cSKalle Valo i++; 29805491d2cSKalle Valo } 29905491d2cSKalle Valo kfree(nvp->nvram); 30005491d2cSKalle Valo nvp->nvram = nvram; 30105491d2cSKalle Valo nvp->nvram_len = j; 30205491d2cSKalle Valo return; 30305491d2cSKalle Valo 30405491d2cSKalle Valo fail: 30505491d2cSKalle Valo kfree(nvram); 30605491d2cSKalle Valo nvp->nvram_len = 0; 30705491d2cSKalle Valo } 30805491d2cSKalle Valo 30905491d2cSKalle Valo /* brcmf_fw_strip_multi_v2 :Some nvram files contain settings for multiple 31005491d2cSKalle Valo * devices. Strip it down for one device, use domain_nr/bus_nr to determine 31105491d2cSKalle Valo * which data is to be returned. v2 is the version where nvram is stored 31205491d2cSKalle Valo * uncompressed, all relevant valid entries are identified by 31305491d2cSKalle Valo * pcie/domain_nr/bus_nr: 31405491d2cSKalle Valo */ 31505491d2cSKalle Valo static void brcmf_fw_strip_multi_v2(struct nvram_parser *nvp, u16 domain_nr, 31605491d2cSKalle Valo u16 bus_nr) 31705491d2cSKalle Valo { 31805491d2cSKalle Valo char prefix[BRCMF_FW_NVRAM_PCIEDEV_LEN]; 31905491d2cSKalle Valo size_t len; 32005491d2cSKalle Valo u32 i, j; 32105491d2cSKalle Valo u8 *nvram; 32205491d2cSKalle Valo 32305491d2cSKalle Valo nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL); 32473c65541SZheng Yongjun if (!nvram) { 32573c65541SZheng Yongjun nvp->nvram_len = 0; 32673c65541SZheng Yongjun return; 32773c65541SZheng Yongjun } 32805491d2cSKalle Valo 32905491d2cSKalle Valo /* Copy all valid entries, release old nvram and assign new one. 33005491d2cSKalle Valo * Valid entries are of type pcie/X/Y/ where X = domain_nr and 33105491d2cSKalle Valo * Y = bus_nr. 33205491d2cSKalle Valo */ 33305491d2cSKalle Valo snprintf(prefix, sizeof(prefix), "pcie/%d/%d/", domain_nr, bus_nr); 33405491d2cSKalle Valo len = strlen(prefix); 33505491d2cSKalle Valo i = 0; 33605491d2cSKalle Valo j = 0; 33705491d2cSKalle Valo while (i < nvp->nvram_len - len) { 33805491d2cSKalle Valo if (strncmp(&nvp->nvram[i], prefix, len) == 0) { 33905491d2cSKalle Valo i += len; 34046f2b38aSHante Meuleman if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0) 34146f2b38aSHante Meuleman nvp->boardrev_found = true; 34205491d2cSKalle Valo while (nvp->nvram[i] != 0) { 34305491d2cSKalle Valo nvram[j] = nvp->nvram[i]; 34405491d2cSKalle Valo i++; 34505491d2cSKalle Valo j++; 34605491d2cSKalle Valo } 34705491d2cSKalle Valo nvram[j] = 0; 34805491d2cSKalle Valo j++; 34905491d2cSKalle Valo } 35005491d2cSKalle Valo while (nvp->nvram[i] != 0) 35105491d2cSKalle Valo i++; 35205491d2cSKalle Valo i++; 35305491d2cSKalle Valo } 35405491d2cSKalle Valo kfree(nvp->nvram); 35505491d2cSKalle Valo nvp->nvram = nvram; 35605491d2cSKalle Valo nvp->nvram_len = j; 35705491d2cSKalle Valo } 35805491d2cSKalle Valo 35946f2b38aSHante Meuleman static void brcmf_fw_add_defaults(struct nvram_parser *nvp) 36046f2b38aSHante Meuleman { 36146f2b38aSHante Meuleman if (nvp->boardrev_found) 36246f2b38aSHante Meuleman return; 36346f2b38aSHante Meuleman 36446f2b38aSHante Meuleman memcpy(&nvp->nvram[nvp->nvram_len], &BRCMF_FW_DEFAULT_BOARDREV, 36546f2b38aSHante Meuleman strlen(BRCMF_FW_DEFAULT_BOARDREV)); 36646f2b38aSHante Meuleman nvp->nvram_len += strlen(BRCMF_FW_DEFAULT_BOARDREV); 36746f2b38aSHante Meuleman nvp->nvram[nvp->nvram_len] = '\0'; 36846f2b38aSHante Meuleman nvp->nvram_len++; 36946f2b38aSHante Meuleman } 37046f2b38aSHante Meuleman 37105491d2cSKalle Valo /* brcmf_nvram_strip :Takes a buffer of "<var>=<value>\n" lines read from a fil 37205491d2cSKalle Valo * and ending in a NUL. Removes carriage returns, empty lines, comment lines, 37305491d2cSKalle Valo * and converts newlines to NULs. Shortens buffer as needed and pads with NULs. 37405491d2cSKalle Valo * End of buffer is completed with token identifying length of buffer. 37505491d2cSKalle Valo */ 37605491d2cSKalle Valo static void *brcmf_fw_nvram_strip(const u8 *data, size_t data_len, 37705491d2cSKalle Valo u32 *new_length, u16 domain_nr, u16 bus_nr) 37805491d2cSKalle Valo { 37905491d2cSKalle Valo struct nvram_parser nvp; 38005491d2cSKalle Valo u32 pad; 38105491d2cSKalle Valo u32 token; 38205491d2cSKalle Valo __le32 token_le; 38305491d2cSKalle Valo 38405491d2cSKalle Valo if (brcmf_init_nvram_parser(&nvp, data, data_len) < 0) 38505491d2cSKalle Valo return NULL; 38605491d2cSKalle Valo 38705491d2cSKalle Valo while (nvp.pos < data_len) { 38805491d2cSKalle Valo nvp.state = nv_parser_states[nvp.state](&nvp); 38905491d2cSKalle Valo if (nvp.state == END) 39005491d2cSKalle Valo break; 39105491d2cSKalle Valo } 39246f2b38aSHante Meuleman if (nvp.multi_dev_v1) { 39346f2b38aSHante Meuleman nvp.boardrev_found = false; 39405491d2cSKalle Valo brcmf_fw_strip_multi_v1(&nvp, domain_nr, bus_nr); 39546f2b38aSHante Meuleman } else if (nvp.multi_dev_v2) { 39646f2b38aSHante Meuleman nvp.boardrev_found = false; 39705491d2cSKalle Valo brcmf_fw_strip_multi_v2(&nvp, domain_nr, bus_nr); 39846f2b38aSHante Meuleman } 39905491d2cSKalle Valo 40005491d2cSKalle Valo if (nvp.nvram_len == 0) { 40105491d2cSKalle Valo kfree(nvp.nvram); 40205491d2cSKalle Valo return NULL; 40305491d2cSKalle Valo } 40405491d2cSKalle Valo 40546f2b38aSHante Meuleman brcmf_fw_add_defaults(&nvp); 40646f2b38aSHante Meuleman 40705491d2cSKalle Valo pad = nvp.nvram_len; 40805491d2cSKalle Valo *new_length = roundup(nvp.nvram_len + 1, 4); 40905491d2cSKalle Valo while (pad != *new_length) { 41005491d2cSKalle Valo nvp.nvram[pad] = 0; 41105491d2cSKalle Valo pad++; 41205491d2cSKalle Valo } 41305491d2cSKalle Valo 41405491d2cSKalle Valo token = *new_length / 4; 41505491d2cSKalle Valo token = (~token << 16) | (token & 0x0000FFFF); 41605491d2cSKalle Valo token_le = cpu_to_le32(token); 41705491d2cSKalle Valo 41805491d2cSKalle Valo memcpy(&nvp.nvram[*new_length], &token_le, sizeof(token_le)); 41905491d2cSKalle Valo *new_length += sizeof(token_le); 42005491d2cSKalle Valo 42105491d2cSKalle Valo return nvp.nvram; 42205491d2cSKalle Valo } 42305491d2cSKalle Valo 42405491d2cSKalle Valo void brcmf_fw_nvram_free(void *nvram) 42505491d2cSKalle Valo { 42605491d2cSKalle Valo kfree(nvram); 42705491d2cSKalle Valo } 42805491d2cSKalle Valo 42905491d2cSKalle Valo struct brcmf_fw { 43005491d2cSKalle Valo struct device *dev; 431d09ae51aSArend Van Spriel struct brcmf_fw_request *req; 432d09ae51aSArend Van Spriel u32 curpos; 433d09ae51aSArend Van Spriel void (*done)(struct device *dev, int err, struct brcmf_fw_request *req); 43405491d2cSKalle Valo }; 43505491d2cSKalle Valo 436ce2e6db5SHans de Goede #ifdef CONFIG_EFI 43729ec3394SHans de Goede /* In some cases the EFI-var stored nvram contains "ccode=ALL" or "ccode=XV" 43829ec3394SHans de Goede * to specify "worldwide" compatible settings, but these 2 ccode-s do not work 43929ec3394SHans de Goede * properly. "ccode=ALL" causes channels 12 and 13 to not be available, 44029ec3394SHans de Goede * "ccode=XV" causes all 5GHz channels to not be available. So we replace both 44129ec3394SHans de Goede * with "ccode=X2" which allows channels 12+13 and 5Ghz channels in 44229ec3394SHans de Goede * no-Initiate-Radiation mode. This means that we will never send on these 44329ec3394SHans de Goede * channels without first having received valid wifi traffic on the channel. 44429ec3394SHans de Goede */ 44529ec3394SHans de Goede static void brcmf_fw_fix_efi_nvram_ccode(char *data, unsigned long data_len) 44629ec3394SHans de Goede { 44729ec3394SHans de Goede char *ccode; 44829ec3394SHans de Goede 44929ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=ALL", data_len); 45029ec3394SHans de Goede if (!ccode) 45129ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=XV\r", data_len); 45229ec3394SHans de Goede if (!ccode) 45329ec3394SHans de Goede return; 45429ec3394SHans de Goede 45529ec3394SHans de Goede ccode[6] = 'X'; 45629ec3394SHans de Goede ccode[7] = '2'; 45729ec3394SHans de Goede ccode[8] = '\r'; 45829ec3394SHans de Goede } 45929ec3394SHans de Goede 460ce2e6db5SHans de Goede static u8 *brcmf_fw_nvram_from_efi(size_t *data_len_ret) 461ce2e6db5SHans de Goede { 462*98e152c1SArd Biesheuvel efi_guid_t guid = EFI_GUID(0x74b00bd9, 0x805a, 0x4d61, 0xb5, 0x1f, 463*98e152c1SArd Biesheuvel 0x43, 0x26, 0x81, 0x23, 0xd1, 0x13); 464ce2e6db5SHans de Goede unsigned long data_len = 0; 465*98e152c1SArd Biesheuvel efi_status_t status; 466ce2e6db5SHans de Goede u8 *data = NULL; 467ce2e6db5SHans de Goede 468*98e152c1SArd Biesheuvel if (!efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE)) 469ce2e6db5SHans de Goede return NULL; 470ce2e6db5SHans de Goede 471*98e152c1SArd Biesheuvel status = efi.get_variable(L"nvram", &guid, NULL, &data_len, NULL); 472*98e152c1SArd Biesheuvel if (status != EFI_BUFFER_TOO_SMALL) 473ce2e6db5SHans de Goede goto fail; 474ce2e6db5SHans de Goede 475ce2e6db5SHans de Goede data = kmalloc(data_len, GFP_KERNEL); 476ce2e6db5SHans de Goede if (!data) 477ce2e6db5SHans de Goede goto fail; 478ce2e6db5SHans de Goede 479*98e152c1SArd Biesheuvel status = efi.get_variable(L"nvram", &guid, NULL, &data_len, data); 480*98e152c1SArd Biesheuvel if (status != EFI_SUCCESS) 481ce2e6db5SHans de Goede goto fail; 482ce2e6db5SHans de Goede 48329ec3394SHans de Goede brcmf_fw_fix_efi_nvram_ccode(data, data_len); 484ce2e6db5SHans de Goede brcmf_info("Using nvram EFI variable\n"); 485ce2e6db5SHans de Goede 486ce2e6db5SHans de Goede *data_len_ret = data_len; 487ce2e6db5SHans de Goede return data; 488ce2e6db5SHans de Goede fail: 489ce2e6db5SHans de Goede kfree(data); 490ce2e6db5SHans de Goede return NULL; 491ce2e6db5SHans de Goede } 492ce2e6db5SHans de Goede #else 493412dd15cSArnd Bergmann static inline u8 *brcmf_fw_nvram_from_efi(size_t *data_len) { return NULL; } 494ce2e6db5SHans de Goede #endif 495ce2e6db5SHans de Goede 496d09ae51aSArend Van Spriel static void brcmf_fw_free_request(struct brcmf_fw_request *req) 497d09ae51aSArend Van Spriel { 498d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 499d09ae51aSArend Van Spriel int i; 500d09ae51aSArend Van Spriel 501d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 502d09ae51aSArend Van Spriel if (item->type == BRCMF_FW_TYPE_BINARY) 503d09ae51aSArend Van Spriel release_firmware(item->binary); 504d09ae51aSArend Van Spriel else if (item->type == BRCMF_FW_TYPE_NVRAM) 505d09ae51aSArend Van Spriel brcmf_fw_nvram_free(item->nv_data.data); 506d09ae51aSArend Van Spriel } 507d09ae51aSArend Van Spriel kfree(req); 508d09ae51aSArend Van Spriel } 509d09ae51aSArend Van Spriel 5100b5c0305SArend Van Spriel static int brcmf_fw_request_nvram_done(const struct firmware *fw, void *ctx) 51105491d2cSKalle Valo { 51205491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 513d09ae51aSArend Van Spriel struct brcmf_fw_item *cur; 514ce2e6db5SHans de Goede bool free_bcm47xx_nvram = false; 515ce2e6db5SHans de Goede bool kfree_nvram = false; 51605491d2cSKalle Valo u32 nvram_length = 0; 51705491d2cSKalle Valo void *nvram = NULL; 51805491d2cSKalle Valo u8 *data = NULL; 51905491d2cSKalle Valo size_t data_len; 52005491d2cSKalle Valo 52105491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev)); 522d09ae51aSArend Van Spriel 523d09ae51aSArend Van Spriel cur = &fwctx->req->items[fwctx->curpos]; 524d09ae51aSArend Van Spriel 52505491d2cSKalle Valo if (fw && fw->data) { 52605491d2cSKalle Valo data = (u8 *)fw->data; 52705491d2cSKalle Valo data_len = fw->size; 52805491d2cSKalle Valo } else { 529ce2e6db5SHans de Goede if ((data = bcm47xx_nvram_get_contents(&data_len))) 530ce2e6db5SHans de Goede free_bcm47xx_nvram = true; 531ce2e6db5SHans de Goede else if ((data = brcmf_fw_nvram_from_efi(&data_len))) 532ce2e6db5SHans de Goede kfree_nvram = true; 533ce2e6db5SHans de Goede else if (!(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 53405491d2cSKalle Valo goto fail; 53505491d2cSKalle Valo } 53605491d2cSKalle Valo 53705491d2cSKalle Valo if (data) 53805491d2cSKalle Valo nvram = brcmf_fw_nvram_strip(data, data_len, &nvram_length, 539d09ae51aSArend Van Spriel fwctx->req->domain_nr, 540d09ae51aSArend Van Spriel fwctx->req->bus_nr); 54105491d2cSKalle Valo 542ce2e6db5SHans de Goede if (free_bcm47xx_nvram) 54305491d2cSKalle Valo bcm47xx_nvram_release_contents(data); 544ce2e6db5SHans de Goede if (kfree_nvram) 545ce2e6db5SHans de Goede kfree(data); 546ce2e6db5SHans de Goede 54705491d2cSKalle Valo release_firmware(fw); 548d09ae51aSArend Van Spriel if (!nvram && !(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 54905491d2cSKalle Valo goto fail; 55005491d2cSKalle Valo 551d09ae51aSArend Van Spriel brcmf_dbg(TRACE, "nvram %p len %d\n", nvram, nvram_length); 552d09ae51aSArend Van Spriel cur->nv_data.data = nvram; 553d09ae51aSArend Van Spriel cur->nv_data.len = nvram_length; 5540b5c0305SArend Van Spriel return 0; 55505491d2cSKalle Valo 55605491d2cSKalle Valo fail: 5570b5c0305SArend Van Spriel return -ENOENT; 55805491d2cSKalle Valo } 55905491d2cSKalle Valo 560a1a3b762SHans de Goede static int brcmf_fw_complete_request(const struct firmware *fw, 561a1a3b762SHans de Goede struct brcmf_fw *fwctx) 562a1a3b762SHans de Goede { 563a1a3b762SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 564a1a3b762SHans de Goede int ret = 0; 565a1a3b762SHans de Goede 566a1a3b762SHans de Goede brcmf_dbg(TRACE, "firmware %s %sfound\n", cur->path, fw ? "" : "not "); 567a1a3b762SHans de Goede 568a1a3b762SHans de Goede switch (cur->type) { 569a1a3b762SHans de Goede case BRCMF_FW_TYPE_NVRAM: 570a1a3b762SHans de Goede ret = brcmf_fw_request_nvram_done(fw, fwctx); 571a1a3b762SHans de Goede break; 572a1a3b762SHans de Goede case BRCMF_FW_TYPE_BINARY: 573a1a3b762SHans de Goede if (fw) 574a1a3b762SHans de Goede cur->binary = fw; 575a1a3b762SHans de Goede else 576a1a3b762SHans de Goede ret = -ENOENT; 577a1a3b762SHans de Goede break; 578a1a3b762SHans de Goede default: 579a1a3b762SHans de Goede /* something fishy here so bail out early */ 580a1a3b762SHans de Goede brcmf_err("unknown fw type: %d\n", cur->type); 581a1a3b762SHans de Goede release_firmware(fw); 582a1a3b762SHans de Goede ret = -EINVAL; 583a1a3b762SHans de Goede } 584a1a3b762SHans de Goede 585a1a3b762SHans de Goede return (cur->flags & BRCMF_FW_REQF_OPTIONAL) ? 0 : ret; 586a1a3b762SHans de Goede } 587a1a3b762SHans de Goede 5885ff01391SLinus Walleij static char *brcm_alt_fw_path(const char *path, const char *board_type) 5895ff01391SLinus Walleij { 5905ff01391SLinus Walleij char alt_path[BRCMF_FW_NAME_LEN]; 5915ff01391SLinus Walleij char suffix[5]; 5925ff01391SLinus Walleij 5935ff01391SLinus Walleij strscpy(alt_path, path, BRCMF_FW_NAME_LEN); 5945ff01391SLinus Walleij /* At least one character + suffix */ 5955ff01391SLinus Walleij if (strlen(alt_path) < 5) 5965ff01391SLinus Walleij return NULL; 5975ff01391SLinus Walleij 5985ff01391SLinus Walleij /* strip .txt or .bin at the end */ 5995ff01391SLinus Walleij strscpy(suffix, alt_path + strlen(alt_path) - 4, 5); 6005ff01391SLinus Walleij alt_path[strlen(alt_path) - 4] = 0; 6015ff01391SLinus Walleij strlcat(alt_path, ".", BRCMF_FW_NAME_LEN); 6025ff01391SLinus Walleij strlcat(alt_path, board_type, BRCMF_FW_NAME_LEN); 6035ff01391SLinus Walleij strlcat(alt_path, suffix, BRCMF_FW_NAME_LEN); 6045ff01391SLinus Walleij 6055ff01391SLinus Walleij return kstrdup(alt_path, GFP_KERNEL); 6065ff01391SLinus Walleij } 6075ff01391SLinus Walleij 608eae8e506SHans de Goede static int brcmf_fw_request_firmware(const struct firmware **fw, 609eae8e506SHans de Goede struct brcmf_fw *fwctx) 610eae8e506SHans de Goede { 611eae8e506SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 612eae8e506SHans de Goede int ret; 613eae8e506SHans de Goede 6145ff01391SLinus Walleij /* Files can be board-specific, first try a board-specific path */ 615eae8e506SHans de Goede if (cur->type == BRCMF_FW_TYPE_NVRAM && fwctx->req->board_type) { 6165ff01391SLinus Walleij char *alt_path; 617eae8e506SHans de Goede 6185ff01391SLinus Walleij alt_path = brcm_alt_fw_path(cur->path, fwctx->req->board_type); 6195ff01391SLinus Walleij if (!alt_path) 6205ff01391SLinus Walleij goto fallback; 621eae8e506SHans de Goede 622eae8e506SHans de Goede ret = request_firmware(fw, alt_path, fwctx->dev); 6235ff01391SLinus Walleij kfree(alt_path); 624eae8e506SHans de Goede if (ret == 0) 625eae8e506SHans de Goede return ret; 626eae8e506SHans de Goede } 627eae8e506SHans de Goede 6285ff01391SLinus Walleij fallback: 629eae8e506SHans de Goede return request_firmware(fw, cur->path, fwctx->dev); 630eae8e506SHans de Goede } 631eae8e506SHans de Goede 632d09ae51aSArend Van Spriel static void brcmf_fw_request_done(const struct firmware *fw, void *ctx) 63305491d2cSKalle Valo { 63405491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 63555e491edSHans de Goede int ret; 636d09ae51aSArend Van Spriel 637a1a3b762SHans de Goede ret = brcmf_fw_complete_request(fw, fwctx); 6380b5c0305SArend Van Spriel 6395b587496SHans de Goede while (ret == 0 && ++fwctx->curpos < fwctx->req->n_items) { 640eae8e506SHans de Goede brcmf_fw_request_firmware(&fw, fwctx); 6415b587496SHans de Goede ret = brcmf_fw_complete_request(fw, ctx); 642d09ae51aSArend Van Spriel } 64303fb0e83SArend Van Spriel 6445b587496SHans de Goede if (ret) { 645d09ae51aSArend Van Spriel brcmf_fw_free_request(fwctx->req); 646d09ae51aSArend Van Spriel fwctx->req = NULL; 6475b587496SHans de Goede } 648d09ae51aSArend Van Spriel fwctx->done(fwctx->dev, ret, fwctx->req); 64905491d2cSKalle Valo kfree(fwctx); 65005491d2cSKalle Valo } 65105491d2cSKalle Valo 652c2dac3d2SLinus Walleij static void brcmf_fw_request_done_alt_path(const struct firmware *fw, void *ctx) 653c2dac3d2SLinus Walleij { 654c2dac3d2SLinus Walleij struct brcmf_fw *fwctx = ctx; 655c2dac3d2SLinus Walleij struct brcmf_fw_item *first = &fwctx->req->items[0]; 656c2dac3d2SLinus Walleij int ret = 0; 657c2dac3d2SLinus Walleij 658c2dac3d2SLinus Walleij /* Fall back to canonical path if board firmware not found */ 659c2dac3d2SLinus Walleij if (!fw) 660c2dac3d2SLinus Walleij ret = request_firmware_nowait(THIS_MODULE, true, first->path, 661c2dac3d2SLinus Walleij fwctx->dev, GFP_KERNEL, fwctx, 662c2dac3d2SLinus Walleij brcmf_fw_request_done); 663c2dac3d2SLinus Walleij 664c2dac3d2SLinus Walleij if (fw || ret < 0) 665c2dac3d2SLinus Walleij brcmf_fw_request_done(fw, ctx); 666c2dac3d2SLinus Walleij } 667c2dac3d2SLinus Walleij 668d09ae51aSArend Van Spriel static bool brcmf_fw_request_is_valid(struct brcmf_fw_request *req) 669d09ae51aSArend Van Spriel { 670d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 671d09ae51aSArend Van Spriel int i; 672d09ae51aSArend Van Spriel 673d09ae51aSArend Van Spriel if (!req->n_items) 674d09ae51aSArend Van Spriel return false; 675d09ae51aSArend Van Spriel 676d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 677d09ae51aSArend Van Spriel if (!item->path) 678d09ae51aSArend Van Spriel return false; 679d09ae51aSArend Van Spriel } 680d09ae51aSArend Van Spriel return true; 681d09ae51aSArend Van Spriel } 682d09ae51aSArend Van Spriel 683d09ae51aSArend Van Spriel int brcmf_fw_get_firmwares(struct device *dev, struct brcmf_fw_request *req, 6846d0507a7SArend Van Spriel void (*fw_cb)(struct device *dev, int err, 685d09ae51aSArend Van Spriel struct brcmf_fw_request *req)) 68605491d2cSKalle Valo { 6875b587496SHans de Goede struct brcmf_fw_item *first = &req->items[0]; 68805491d2cSKalle Valo struct brcmf_fw *fwctx; 689665408f4SPhil Elwell char *alt_path = NULL; 6905b587496SHans de Goede int ret; 69105491d2cSKalle Valo 69205491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(dev)); 693d09ae51aSArend Van Spriel if (!fw_cb) 69405491d2cSKalle Valo return -EINVAL; 69505491d2cSKalle Valo 696d09ae51aSArend Van Spriel if (!brcmf_fw_request_is_valid(req)) 69705491d2cSKalle Valo return -EINVAL; 69805491d2cSKalle Valo 69905491d2cSKalle Valo fwctx = kzalloc(sizeof(*fwctx), GFP_KERNEL); 70005491d2cSKalle Valo if (!fwctx) 70105491d2cSKalle Valo return -ENOMEM; 70205491d2cSKalle Valo 70305491d2cSKalle Valo fwctx->dev = dev; 704d09ae51aSArend Van Spriel fwctx->req = req; 70505491d2cSKalle Valo fwctx->done = fw_cb; 70605491d2cSKalle Valo 7075ff01391SLinus Walleij /* First try alternative board-specific path if any */ 708665408f4SPhil Elwell if (fwctx->req->board_type) 709665408f4SPhil Elwell alt_path = brcm_alt_fw_path(first->path, 710665408f4SPhil Elwell fwctx->req->board_type); 7115ff01391SLinus Walleij if (alt_path) { 7125ff01391SLinus Walleij ret = request_firmware_nowait(THIS_MODULE, true, alt_path, 7135ff01391SLinus Walleij fwctx->dev, GFP_KERNEL, fwctx, 714c2dac3d2SLinus Walleij brcmf_fw_request_done_alt_path); 7155ff01391SLinus Walleij kfree(alt_path); 716c2dac3d2SLinus Walleij } else { 7175b587496SHans de Goede ret = request_firmware_nowait(THIS_MODULE, true, first->path, 7185b587496SHans de Goede fwctx->dev, GFP_KERNEL, fwctx, 7195b587496SHans de Goede brcmf_fw_request_done); 7205ff01391SLinus Walleij } 7215b587496SHans de Goede if (ret < 0) 7225b587496SHans de Goede brcmf_fw_request_done(NULL, fwctx); 7235b587496SHans de Goede 724d09ae51aSArend Van Spriel return 0; 72505491d2cSKalle Valo } 72605491d2cSKalle Valo 7272baa3aaeSArend Van Spriel struct brcmf_fw_request * 7282baa3aaeSArend Van Spriel brcmf_fw_alloc_request(u32 chip, u32 chiprev, 729ff68c9f9SArend Van Spriel const struct brcmf_firmware_mapping mapping_table[], 7302baa3aaeSArend Van Spriel u32 table_size, struct brcmf_fw_name *fwnames, 7312baa3aaeSArend Van Spriel u32 n_fwnames) 7322baa3aaeSArend Van Spriel { 7332baa3aaeSArend Van Spriel struct brcmf_fw_request *fwreq; 7342baa3aaeSArend Van Spriel char chipname[12]; 7352baa3aaeSArend Van Spriel const char *mp_path; 736b72c51a5SLyude Paul size_t mp_path_len; 7372baa3aaeSArend Van Spriel u32 i, j; 738b72c51a5SLyude Paul char end = '\0'; 7392baa3aaeSArend Van Spriel 7402baa3aaeSArend Van Spriel for (i = 0; i < table_size; i++) { 7412baa3aaeSArend Van Spriel if (mapping_table[i].chipid == chip && 7422baa3aaeSArend Van Spriel mapping_table[i].revmask & BIT(chiprev)) 7432baa3aaeSArend Van Spriel break; 7442baa3aaeSArend Van Spriel } 7452baa3aaeSArend Van Spriel 746a250c91cSArend van Spriel brcmf_chip_name(chip, chiprev, chipname, sizeof(chipname)); 747a250c91cSArend van Spriel 7482baa3aaeSArend Van Spriel if (i == table_size) { 749a250c91cSArend van Spriel brcmf_err("Unknown chip %s\n", chipname); 7502baa3aaeSArend Van Spriel return NULL; 7512baa3aaeSArend Van Spriel } 7522baa3aaeSArend Van Spriel 7530cf83903SGustavo A. R. Silva fwreq = kzalloc(struct_size(fwreq, items, n_fwnames), GFP_KERNEL); 7542baa3aaeSArend Van Spriel if (!fwreq) 7552baa3aaeSArend Van Spriel return NULL; 7562baa3aaeSArend Van Spriel 7572baa3aaeSArend Van Spriel brcmf_info("using %s for chip %s\n", 7582baa3aaeSArend Van Spriel mapping_table[i].fw_base, chipname); 7592baa3aaeSArend Van Spriel 7602baa3aaeSArend Van Spriel mp_path = brcmf_mp_global.firmware_path; 761b72c51a5SLyude Paul mp_path_len = strnlen(mp_path, BRCMF_FW_ALTPATH_LEN); 762b72c51a5SLyude Paul if (mp_path_len) 763b72c51a5SLyude Paul end = mp_path[mp_path_len - 1]; 764b72c51a5SLyude Paul 7652baa3aaeSArend Van Spriel fwreq->n_items = n_fwnames; 7662baa3aaeSArend Van Spriel 7672baa3aaeSArend Van Spriel for (j = 0; j < n_fwnames; j++) { 7682baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 769c9692820SRafał Miłecki fwnames[j].path[0] = '\0'; 7702baa3aaeSArend Van Spriel /* check if firmware path is provided by module parameter */ 7712baa3aaeSArend Van Spriel if (brcmf_mp_global.firmware_path[0] != '\0') { 7722baa3aaeSArend Van Spriel strlcpy(fwnames[j].path, mp_path, 7732baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 7742baa3aaeSArend Van Spriel 7752baa3aaeSArend Van Spriel if (end != '/') { 7762baa3aaeSArend Van Spriel strlcat(fwnames[j].path, "/", 7772baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 7782baa3aaeSArend Van Spriel } 7792baa3aaeSArend Van Spriel } 780bf291b72SArend Van Spriel strlcat(fwnames[j].path, mapping_table[i].fw_base, 781bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 782bf291b72SArend Van Spriel strlcat(fwnames[j].path, fwnames[j].extension, 783bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 7842baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 7852baa3aaeSArend Van Spriel } 7862baa3aaeSArend Van Spriel 7872baa3aaeSArend Van Spriel return fwreq; 7882baa3aaeSArend Van Spriel } 789