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; 21005491d2cSKalle Valo /* Alloc for extra 0 byte + roundup by 4 + length field */ 21105491d2cSKalle Valo size += 1 + 3 + sizeof(u32); 21205491d2cSKalle Valo nvp->nvram = kzalloc(size, GFP_KERNEL); 21305491d2cSKalle Valo if (!nvp->nvram) 21405491d2cSKalle Valo return -ENOMEM; 21505491d2cSKalle Valo 21605491d2cSKalle Valo nvp->line = 1; 21705491d2cSKalle Valo nvp->column = 1; 21805491d2cSKalle Valo return 0; 21905491d2cSKalle Valo } 22005491d2cSKalle Valo 22105491d2cSKalle Valo /* brcmf_fw_strip_multi_v1 :Some nvram files contain settings for multiple 22205491d2cSKalle Valo * devices. Strip it down for one device, use domain_nr/bus_nr to determine 22305491d2cSKalle Valo * which data is to be returned. v1 is the version where nvram is stored 22405491d2cSKalle Valo * compressed and "devpath" maps to index for valid entries. 22505491d2cSKalle Valo */ 22605491d2cSKalle Valo static void brcmf_fw_strip_multi_v1(struct nvram_parser *nvp, u16 domain_nr, 22705491d2cSKalle Valo u16 bus_nr) 22805491d2cSKalle Valo { 22905491d2cSKalle Valo /* Device path with a leading '=' key-value separator */ 23005491d2cSKalle Valo char pci_path[] = "=pci/?/?"; 23105491d2cSKalle Valo size_t pci_len; 23205491d2cSKalle Valo char pcie_path[] = "=pcie/?/?"; 23305491d2cSKalle Valo size_t pcie_len; 23405491d2cSKalle Valo 23505491d2cSKalle Valo u32 i, j; 23605491d2cSKalle Valo bool found; 23705491d2cSKalle Valo u8 *nvram; 23805491d2cSKalle Valo u8 id; 23905491d2cSKalle Valo 24005491d2cSKalle Valo nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL); 24105491d2cSKalle Valo if (!nvram) 24205491d2cSKalle Valo goto fail; 24305491d2cSKalle Valo 24405491d2cSKalle Valo /* min length: devpath0=pcie/1/4/ + 0:x=y */ 24505491d2cSKalle Valo if (nvp->nvram_len < BRCMF_FW_NVRAM_DEVPATH_LEN + 6) 24605491d2cSKalle Valo goto fail; 24705491d2cSKalle Valo 24805491d2cSKalle Valo /* First search for the devpathX and see if it is the configuration 24905491d2cSKalle Valo * for domain_nr/bus_nr. Search complete nvp 25005491d2cSKalle Valo */ 25105491d2cSKalle Valo snprintf(pci_path, sizeof(pci_path), "=pci/%d/%d", domain_nr, 25205491d2cSKalle Valo bus_nr); 25305491d2cSKalle Valo pci_len = strlen(pci_path); 25405491d2cSKalle Valo snprintf(pcie_path, sizeof(pcie_path), "=pcie/%d/%d", domain_nr, 25505491d2cSKalle Valo bus_nr); 25605491d2cSKalle Valo pcie_len = strlen(pcie_path); 25705491d2cSKalle Valo found = false; 25805491d2cSKalle Valo i = 0; 25905491d2cSKalle Valo while (i < nvp->nvram_len - BRCMF_FW_NVRAM_DEVPATH_LEN) { 26005491d2cSKalle Valo /* Format: devpathX=pcie/Y/Z/ 26105491d2cSKalle Valo * Y = domain_nr, Z = bus_nr, X = virtual ID 26205491d2cSKalle Valo */ 26305491d2cSKalle Valo if (strncmp(&nvp->nvram[i], "devpath", 7) == 0 && 26405491d2cSKalle Valo (!strncmp(&nvp->nvram[i + 8], pci_path, pci_len) || 26505491d2cSKalle Valo !strncmp(&nvp->nvram[i + 8], pcie_path, pcie_len))) { 26605491d2cSKalle Valo id = nvp->nvram[i + 7] - '0'; 26705491d2cSKalle Valo found = true; 26805491d2cSKalle Valo break; 26905491d2cSKalle Valo } 27005491d2cSKalle Valo while (nvp->nvram[i] != 0) 27105491d2cSKalle Valo i++; 27205491d2cSKalle Valo i++; 27305491d2cSKalle Valo } 27405491d2cSKalle Valo if (!found) 27505491d2cSKalle Valo goto fail; 27605491d2cSKalle Valo 27705491d2cSKalle Valo /* Now copy all valid entries, release old nvram and assign new one */ 27805491d2cSKalle Valo i = 0; 27905491d2cSKalle Valo j = 0; 28005491d2cSKalle Valo while (i < nvp->nvram_len) { 28105491d2cSKalle Valo if ((nvp->nvram[i] - '0' == id) && (nvp->nvram[i + 1] == ':')) { 28205491d2cSKalle Valo i += 2; 28346f2b38aSHante Meuleman if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0) 28446f2b38aSHante Meuleman nvp->boardrev_found = true; 28505491d2cSKalle Valo while (nvp->nvram[i] != 0) { 28605491d2cSKalle Valo nvram[j] = nvp->nvram[i]; 28705491d2cSKalle Valo i++; 28805491d2cSKalle Valo j++; 28905491d2cSKalle Valo } 29005491d2cSKalle Valo nvram[j] = 0; 29105491d2cSKalle Valo j++; 29205491d2cSKalle Valo } 29305491d2cSKalle Valo while (nvp->nvram[i] != 0) 29405491d2cSKalle Valo i++; 29505491d2cSKalle Valo i++; 29605491d2cSKalle Valo } 29705491d2cSKalle Valo kfree(nvp->nvram); 29805491d2cSKalle Valo nvp->nvram = nvram; 29905491d2cSKalle Valo nvp->nvram_len = j; 30005491d2cSKalle Valo return; 30105491d2cSKalle Valo 30205491d2cSKalle Valo fail: 30305491d2cSKalle Valo kfree(nvram); 30405491d2cSKalle Valo nvp->nvram_len = 0; 30505491d2cSKalle Valo } 30605491d2cSKalle Valo 30705491d2cSKalle Valo /* brcmf_fw_strip_multi_v2 :Some nvram files contain settings for multiple 30805491d2cSKalle Valo * devices. Strip it down for one device, use domain_nr/bus_nr to determine 30905491d2cSKalle Valo * which data is to be returned. v2 is the version where nvram is stored 31005491d2cSKalle Valo * uncompressed, all relevant valid entries are identified by 31105491d2cSKalle Valo * pcie/domain_nr/bus_nr: 31205491d2cSKalle Valo */ 31305491d2cSKalle Valo static void brcmf_fw_strip_multi_v2(struct nvram_parser *nvp, u16 domain_nr, 31405491d2cSKalle Valo u16 bus_nr) 31505491d2cSKalle Valo { 31605491d2cSKalle Valo char prefix[BRCMF_FW_NVRAM_PCIEDEV_LEN]; 31705491d2cSKalle Valo size_t len; 31805491d2cSKalle Valo u32 i, j; 31905491d2cSKalle Valo u8 *nvram; 32005491d2cSKalle Valo 32105491d2cSKalle Valo nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL); 32273c65541SZheng Yongjun if (!nvram) { 32373c65541SZheng Yongjun nvp->nvram_len = 0; 32473c65541SZheng Yongjun return; 32573c65541SZheng Yongjun } 32605491d2cSKalle Valo 32705491d2cSKalle Valo /* Copy all valid entries, release old nvram and assign new one. 32805491d2cSKalle Valo * Valid entries are of type pcie/X/Y/ where X = domain_nr and 32905491d2cSKalle Valo * Y = bus_nr. 33005491d2cSKalle Valo */ 33105491d2cSKalle Valo snprintf(prefix, sizeof(prefix), "pcie/%d/%d/", domain_nr, bus_nr); 33205491d2cSKalle Valo len = strlen(prefix); 33305491d2cSKalle Valo i = 0; 33405491d2cSKalle Valo j = 0; 33505491d2cSKalle Valo while (i < nvp->nvram_len - len) { 33605491d2cSKalle Valo if (strncmp(&nvp->nvram[i], prefix, len) == 0) { 33705491d2cSKalle Valo i += len; 33846f2b38aSHante Meuleman if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0) 33946f2b38aSHante Meuleman nvp->boardrev_found = true; 34005491d2cSKalle Valo while (nvp->nvram[i] != 0) { 34105491d2cSKalle Valo nvram[j] = nvp->nvram[i]; 34205491d2cSKalle Valo i++; 34305491d2cSKalle Valo j++; 34405491d2cSKalle Valo } 34505491d2cSKalle Valo nvram[j] = 0; 34605491d2cSKalle Valo j++; 34705491d2cSKalle Valo } 34805491d2cSKalle Valo while (nvp->nvram[i] != 0) 34905491d2cSKalle Valo i++; 35005491d2cSKalle Valo i++; 35105491d2cSKalle Valo } 35205491d2cSKalle Valo kfree(nvp->nvram); 35305491d2cSKalle Valo nvp->nvram = nvram; 35405491d2cSKalle Valo nvp->nvram_len = j; 35505491d2cSKalle Valo } 35605491d2cSKalle Valo 35746f2b38aSHante Meuleman static void brcmf_fw_add_defaults(struct nvram_parser *nvp) 35846f2b38aSHante Meuleman { 35946f2b38aSHante Meuleman if (nvp->boardrev_found) 36046f2b38aSHante Meuleman return; 36146f2b38aSHante Meuleman 36246f2b38aSHante Meuleman memcpy(&nvp->nvram[nvp->nvram_len], &BRCMF_FW_DEFAULT_BOARDREV, 36346f2b38aSHante Meuleman strlen(BRCMF_FW_DEFAULT_BOARDREV)); 36446f2b38aSHante Meuleman nvp->nvram_len += strlen(BRCMF_FW_DEFAULT_BOARDREV); 36546f2b38aSHante Meuleman nvp->nvram[nvp->nvram_len] = '\0'; 36646f2b38aSHante Meuleman nvp->nvram_len++; 36746f2b38aSHante Meuleman } 36846f2b38aSHante Meuleman 36905491d2cSKalle Valo /* brcmf_nvram_strip :Takes a buffer of "<var>=<value>\n" lines read from a fil 37005491d2cSKalle Valo * and ending in a NUL. Removes carriage returns, empty lines, comment lines, 37105491d2cSKalle Valo * and converts newlines to NULs. Shortens buffer as needed and pads with NULs. 37205491d2cSKalle Valo * End of buffer is completed with token identifying length of buffer. 37305491d2cSKalle Valo */ 37405491d2cSKalle Valo static void *brcmf_fw_nvram_strip(const u8 *data, size_t data_len, 37505491d2cSKalle Valo u32 *new_length, u16 domain_nr, u16 bus_nr) 37605491d2cSKalle Valo { 37705491d2cSKalle Valo struct nvram_parser nvp; 37805491d2cSKalle Valo u32 pad; 37905491d2cSKalle Valo u32 token; 38005491d2cSKalle Valo __le32 token_le; 38105491d2cSKalle Valo 38205491d2cSKalle Valo if (brcmf_init_nvram_parser(&nvp, data, data_len) < 0) 38305491d2cSKalle Valo return NULL; 38405491d2cSKalle Valo 38505491d2cSKalle Valo while (nvp.pos < data_len) { 38605491d2cSKalle Valo nvp.state = nv_parser_states[nvp.state](&nvp); 38705491d2cSKalle Valo if (nvp.state == END) 38805491d2cSKalle Valo break; 38905491d2cSKalle Valo } 39046f2b38aSHante Meuleman if (nvp.multi_dev_v1) { 39146f2b38aSHante Meuleman nvp.boardrev_found = false; 39205491d2cSKalle Valo brcmf_fw_strip_multi_v1(&nvp, domain_nr, bus_nr); 39346f2b38aSHante Meuleman } else if (nvp.multi_dev_v2) { 39446f2b38aSHante Meuleman nvp.boardrev_found = false; 39505491d2cSKalle Valo brcmf_fw_strip_multi_v2(&nvp, domain_nr, bus_nr); 39646f2b38aSHante Meuleman } 39705491d2cSKalle Valo 39805491d2cSKalle Valo if (nvp.nvram_len == 0) { 39905491d2cSKalle Valo kfree(nvp.nvram); 40005491d2cSKalle Valo return NULL; 40105491d2cSKalle Valo } 40205491d2cSKalle Valo 40346f2b38aSHante Meuleman brcmf_fw_add_defaults(&nvp); 40446f2b38aSHante Meuleman 40505491d2cSKalle Valo pad = nvp.nvram_len; 40605491d2cSKalle Valo *new_length = roundup(nvp.nvram_len + 1, 4); 40705491d2cSKalle Valo while (pad != *new_length) { 40805491d2cSKalle Valo nvp.nvram[pad] = 0; 40905491d2cSKalle Valo pad++; 41005491d2cSKalle Valo } 41105491d2cSKalle Valo 41205491d2cSKalle Valo token = *new_length / 4; 41305491d2cSKalle Valo token = (~token << 16) | (token & 0x0000FFFF); 41405491d2cSKalle Valo token_le = cpu_to_le32(token); 41505491d2cSKalle Valo 41605491d2cSKalle Valo memcpy(&nvp.nvram[*new_length], &token_le, sizeof(token_le)); 41705491d2cSKalle Valo *new_length += sizeof(token_le); 41805491d2cSKalle Valo 41905491d2cSKalle Valo return nvp.nvram; 42005491d2cSKalle Valo } 42105491d2cSKalle Valo 42205491d2cSKalle Valo void brcmf_fw_nvram_free(void *nvram) 42305491d2cSKalle Valo { 42405491d2cSKalle Valo kfree(nvram); 42505491d2cSKalle Valo } 42605491d2cSKalle Valo 42705491d2cSKalle Valo struct brcmf_fw { 42805491d2cSKalle Valo struct device *dev; 429d09ae51aSArend Van Spriel struct brcmf_fw_request *req; 430d09ae51aSArend Van Spriel u32 curpos; 431d09ae51aSArend Van Spriel void (*done)(struct device *dev, int err, struct brcmf_fw_request *req); 43205491d2cSKalle Valo }; 43305491d2cSKalle Valo 434ce2e6db5SHans de Goede #ifdef CONFIG_EFI 43529ec3394SHans de Goede /* In some cases the EFI-var stored nvram contains "ccode=ALL" or "ccode=XV" 43629ec3394SHans de Goede * to specify "worldwide" compatible settings, but these 2 ccode-s do not work 43729ec3394SHans de Goede * properly. "ccode=ALL" causes channels 12 and 13 to not be available, 43829ec3394SHans de Goede * "ccode=XV" causes all 5GHz channels to not be available. So we replace both 43929ec3394SHans de Goede * with "ccode=X2" which allows channels 12+13 and 5Ghz channels in 44029ec3394SHans de Goede * no-Initiate-Radiation mode. This means that we will never send on these 44129ec3394SHans de Goede * channels without first having received valid wifi traffic on the channel. 44229ec3394SHans de Goede */ 44329ec3394SHans de Goede static void brcmf_fw_fix_efi_nvram_ccode(char *data, unsigned long data_len) 44429ec3394SHans de Goede { 44529ec3394SHans de Goede char *ccode; 44629ec3394SHans de Goede 44729ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=ALL", data_len); 44829ec3394SHans de Goede if (!ccode) 44929ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=XV\r", data_len); 45029ec3394SHans de Goede if (!ccode) 45129ec3394SHans de Goede return; 45229ec3394SHans de Goede 45329ec3394SHans de Goede ccode[6] = 'X'; 45429ec3394SHans de Goede ccode[7] = '2'; 45529ec3394SHans de Goede ccode[8] = '\r'; 45629ec3394SHans de Goede } 45729ec3394SHans de Goede 458ce2e6db5SHans de Goede static u8 *brcmf_fw_nvram_from_efi(size_t *data_len_ret) 459ce2e6db5SHans de Goede { 460ce2e6db5SHans de Goede const u16 name[] = { 'n', 'v', 'r', 'a', 'm', 0 }; 461ce2e6db5SHans de Goede struct efivar_entry *nvram_efivar; 462ce2e6db5SHans de Goede unsigned long data_len = 0; 463ce2e6db5SHans de Goede u8 *data = NULL; 464ce2e6db5SHans de Goede int err; 465ce2e6db5SHans de Goede 466ce2e6db5SHans de Goede nvram_efivar = kzalloc(sizeof(*nvram_efivar), GFP_KERNEL); 467ce2e6db5SHans de Goede if (!nvram_efivar) 468ce2e6db5SHans de Goede return NULL; 469ce2e6db5SHans de Goede 470ce2e6db5SHans de Goede memcpy(&nvram_efivar->var.VariableName, name, sizeof(name)); 471ce2e6db5SHans de Goede nvram_efivar->var.VendorGuid = EFI_GUID(0x74b00bd9, 0x805a, 0x4d61, 472ce2e6db5SHans de Goede 0xb5, 0x1f, 0x43, 0x26, 473ce2e6db5SHans de Goede 0x81, 0x23, 0xd1, 0x13); 474ce2e6db5SHans de Goede 475ce2e6db5SHans de Goede err = efivar_entry_size(nvram_efivar, &data_len); 476ce2e6db5SHans de Goede if (err) 477ce2e6db5SHans de Goede goto fail; 478ce2e6db5SHans de Goede 479ce2e6db5SHans de Goede data = kmalloc(data_len, GFP_KERNEL); 480ce2e6db5SHans de Goede if (!data) 481ce2e6db5SHans de Goede goto fail; 482ce2e6db5SHans de Goede 483ce2e6db5SHans de Goede err = efivar_entry_get(nvram_efivar, NULL, &data_len, data); 484ce2e6db5SHans de Goede if (err) 485ce2e6db5SHans de Goede goto fail; 486ce2e6db5SHans de Goede 48729ec3394SHans de Goede brcmf_fw_fix_efi_nvram_ccode(data, data_len); 488ce2e6db5SHans de Goede brcmf_info("Using nvram EFI variable\n"); 489ce2e6db5SHans de Goede 490ce2e6db5SHans de Goede kfree(nvram_efivar); 491ce2e6db5SHans de Goede *data_len_ret = data_len; 492ce2e6db5SHans de Goede return data; 493ce2e6db5SHans de Goede 494ce2e6db5SHans de Goede fail: 495ce2e6db5SHans de Goede kfree(data); 496ce2e6db5SHans de Goede kfree(nvram_efivar); 497ce2e6db5SHans de Goede return NULL; 498ce2e6db5SHans de Goede } 499ce2e6db5SHans de Goede #else 500412dd15cSArnd Bergmann static inline u8 *brcmf_fw_nvram_from_efi(size_t *data_len) { return NULL; } 501ce2e6db5SHans de Goede #endif 502ce2e6db5SHans de Goede 503d09ae51aSArend Van Spriel static void brcmf_fw_free_request(struct brcmf_fw_request *req) 504d09ae51aSArend Van Spriel { 505d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 506d09ae51aSArend Van Spriel int i; 507d09ae51aSArend Van Spriel 508d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 509d09ae51aSArend Van Spriel if (item->type == BRCMF_FW_TYPE_BINARY) 510d09ae51aSArend Van Spriel release_firmware(item->binary); 511d09ae51aSArend Van Spriel else if (item->type == BRCMF_FW_TYPE_NVRAM) 512d09ae51aSArend Van Spriel brcmf_fw_nvram_free(item->nv_data.data); 513d09ae51aSArend Van Spriel } 514d09ae51aSArend Van Spriel kfree(req); 515d09ae51aSArend Van Spriel } 516d09ae51aSArend Van Spriel 5170b5c0305SArend Van Spriel static int brcmf_fw_request_nvram_done(const struct firmware *fw, void *ctx) 51805491d2cSKalle Valo { 51905491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 520d09ae51aSArend Van Spriel struct brcmf_fw_item *cur; 521ce2e6db5SHans de Goede bool free_bcm47xx_nvram = false; 522ce2e6db5SHans de Goede bool kfree_nvram = false; 52305491d2cSKalle Valo u32 nvram_length = 0; 52405491d2cSKalle Valo void *nvram = NULL; 52505491d2cSKalle Valo u8 *data = NULL; 52605491d2cSKalle Valo size_t data_len; 52705491d2cSKalle Valo 52805491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev)); 529d09ae51aSArend Van Spriel 530d09ae51aSArend Van Spriel cur = &fwctx->req->items[fwctx->curpos]; 531d09ae51aSArend Van Spriel 53205491d2cSKalle Valo if (fw && fw->data) { 53305491d2cSKalle Valo data = (u8 *)fw->data; 53405491d2cSKalle Valo data_len = fw->size; 53505491d2cSKalle Valo } else { 536ce2e6db5SHans de Goede if ((data = bcm47xx_nvram_get_contents(&data_len))) 537ce2e6db5SHans de Goede free_bcm47xx_nvram = true; 538ce2e6db5SHans de Goede else if ((data = brcmf_fw_nvram_from_efi(&data_len))) 539ce2e6db5SHans de Goede kfree_nvram = true; 540ce2e6db5SHans de Goede else if (!(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 54105491d2cSKalle Valo goto fail; 54205491d2cSKalle Valo } 54305491d2cSKalle Valo 54405491d2cSKalle Valo if (data) 54505491d2cSKalle Valo nvram = brcmf_fw_nvram_strip(data, data_len, &nvram_length, 546d09ae51aSArend Van Spriel fwctx->req->domain_nr, 547d09ae51aSArend Van Spriel fwctx->req->bus_nr); 54805491d2cSKalle Valo 549ce2e6db5SHans de Goede if (free_bcm47xx_nvram) 55005491d2cSKalle Valo bcm47xx_nvram_release_contents(data); 551ce2e6db5SHans de Goede if (kfree_nvram) 552ce2e6db5SHans de Goede kfree(data); 553ce2e6db5SHans de Goede 55405491d2cSKalle Valo release_firmware(fw); 555d09ae51aSArend Van Spriel if (!nvram && !(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 55605491d2cSKalle Valo goto fail; 55705491d2cSKalle Valo 558d09ae51aSArend Van Spriel brcmf_dbg(TRACE, "nvram %p len %d\n", nvram, nvram_length); 559d09ae51aSArend Van Spriel cur->nv_data.data = nvram; 560d09ae51aSArend Van Spriel cur->nv_data.len = nvram_length; 5610b5c0305SArend Van Spriel return 0; 56205491d2cSKalle Valo 56305491d2cSKalle Valo fail: 5640b5c0305SArend Van Spriel return -ENOENT; 56505491d2cSKalle Valo } 56605491d2cSKalle Valo 567a1a3b762SHans de Goede static int brcmf_fw_complete_request(const struct firmware *fw, 568a1a3b762SHans de Goede struct brcmf_fw *fwctx) 569a1a3b762SHans de Goede { 570a1a3b762SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 571a1a3b762SHans de Goede int ret = 0; 572a1a3b762SHans de Goede 573a1a3b762SHans de Goede brcmf_dbg(TRACE, "firmware %s %sfound\n", cur->path, fw ? "" : "not "); 574a1a3b762SHans de Goede 575a1a3b762SHans de Goede switch (cur->type) { 576a1a3b762SHans de Goede case BRCMF_FW_TYPE_NVRAM: 577a1a3b762SHans de Goede ret = brcmf_fw_request_nvram_done(fw, fwctx); 578a1a3b762SHans de Goede break; 579a1a3b762SHans de Goede case BRCMF_FW_TYPE_BINARY: 580a1a3b762SHans de Goede if (fw) 581a1a3b762SHans de Goede cur->binary = fw; 582a1a3b762SHans de Goede else 583a1a3b762SHans de Goede ret = -ENOENT; 584a1a3b762SHans de Goede break; 585a1a3b762SHans de Goede default: 586a1a3b762SHans de Goede /* something fishy here so bail out early */ 587a1a3b762SHans de Goede brcmf_err("unknown fw type: %d\n", cur->type); 588a1a3b762SHans de Goede release_firmware(fw); 589a1a3b762SHans de Goede ret = -EINVAL; 590a1a3b762SHans de Goede } 591a1a3b762SHans de Goede 592a1a3b762SHans de Goede return (cur->flags & BRCMF_FW_REQF_OPTIONAL) ? 0 : ret; 593a1a3b762SHans de Goede } 594a1a3b762SHans de Goede 5955ff01391SLinus Walleij static char *brcm_alt_fw_path(const char *path, const char *board_type) 5965ff01391SLinus Walleij { 5975ff01391SLinus Walleij char alt_path[BRCMF_FW_NAME_LEN]; 5985ff01391SLinus Walleij char suffix[5]; 5995ff01391SLinus Walleij 6005ff01391SLinus Walleij strscpy(alt_path, path, BRCMF_FW_NAME_LEN); 6015ff01391SLinus Walleij /* At least one character + suffix */ 6025ff01391SLinus Walleij if (strlen(alt_path) < 5) 6035ff01391SLinus Walleij return NULL; 6045ff01391SLinus Walleij 6055ff01391SLinus Walleij /* strip .txt or .bin at the end */ 6065ff01391SLinus Walleij strscpy(suffix, alt_path + strlen(alt_path) - 4, 5); 6075ff01391SLinus Walleij alt_path[strlen(alt_path) - 4] = 0; 6085ff01391SLinus Walleij strlcat(alt_path, ".", BRCMF_FW_NAME_LEN); 6095ff01391SLinus Walleij strlcat(alt_path, board_type, BRCMF_FW_NAME_LEN); 6105ff01391SLinus Walleij strlcat(alt_path, suffix, BRCMF_FW_NAME_LEN); 6115ff01391SLinus Walleij 6125ff01391SLinus Walleij return kstrdup(alt_path, GFP_KERNEL); 6135ff01391SLinus Walleij } 6145ff01391SLinus Walleij 615eae8e506SHans de Goede static int brcmf_fw_request_firmware(const struct firmware **fw, 616eae8e506SHans de Goede struct brcmf_fw *fwctx) 617eae8e506SHans de Goede { 618eae8e506SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 619eae8e506SHans de Goede int ret; 620eae8e506SHans de Goede 6215ff01391SLinus Walleij /* Files can be board-specific, first try a board-specific path */ 622eae8e506SHans de Goede if (cur->type == BRCMF_FW_TYPE_NVRAM && fwctx->req->board_type) { 6235ff01391SLinus Walleij char *alt_path; 624eae8e506SHans de Goede 6255ff01391SLinus Walleij alt_path = brcm_alt_fw_path(cur->path, fwctx->req->board_type); 6265ff01391SLinus Walleij if (!alt_path) 6275ff01391SLinus Walleij goto fallback; 628eae8e506SHans de Goede 629eae8e506SHans de Goede ret = request_firmware(fw, alt_path, fwctx->dev); 6305ff01391SLinus Walleij kfree(alt_path); 631eae8e506SHans de Goede if (ret == 0) 632eae8e506SHans de Goede return ret; 633eae8e506SHans de Goede } 634eae8e506SHans de Goede 6355ff01391SLinus Walleij fallback: 636eae8e506SHans de Goede return request_firmware(fw, cur->path, fwctx->dev); 637eae8e506SHans de Goede } 638eae8e506SHans de Goede 639d09ae51aSArend Van Spriel static void brcmf_fw_request_done(const struct firmware *fw, void *ctx) 64005491d2cSKalle Valo { 64105491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 64255e491edSHans de Goede int ret; 643d09ae51aSArend Van Spriel 644a1a3b762SHans de Goede ret = brcmf_fw_complete_request(fw, fwctx); 6450b5c0305SArend Van Spriel 6465b587496SHans de Goede while (ret == 0 && ++fwctx->curpos < fwctx->req->n_items) { 647eae8e506SHans de Goede brcmf_fw_request_firmware(&fw, fwctx); 6485b587496SHans de Goede ret = brcmf_fw_complete_request(fw, ctx); 649d09ae51aSArend Van Spriel } 65003fb0e83SArend Van Spriel 6515b587496SHans de Goede if (ret) { 652d09ae51aSArend Van Spriel brcmf_fw_free_request(fwctx->req); 653d09ae51aSArend Van Spriel fwctx->req = NULL; 6545b587496SHans de Goede } 655d09ae51aSArend Van Spriel fwctx->done(fwctx->dev, ret, fwctx->req); 65605491d2cSKalle Valo kfree(fwctx); 65705491d2cSKalle Valo } 65805491d2cSKalle Valo 659*c2dac3d2SLinus Walleij static void brcmf_fw_request_done_alt_path(const struct firmware *fw, void *ctx) 660*c2dac3d2SLinus Walleij { 661*c2dac3d2SLinus Walleij struct brcmf_fw *fwctx = ctx; 662*c2dac3d2SLinus Walleij struct brcmf_fw_item *first = &fwctx->req->items[0]; 663*c2dac3d2SLinus Walleij int ret = 0; 664*c2dac3d2SLinus Walleij 665*c2dac3d2SLinus Walleij /* Fall back to canonical path if board firmware not found */ 666*c2dac3d2SLinus Walleij if (!fw) 667*c2dac3d2SLinus Walleij ret = request_firmware_nowait(THIS_MODULE, true, first->path, 668*c2dac3d2SLinus Walleij fwctx->dev, GFP_KERNEL, fwctx, 669*c2dac3d2SLinus Walleij brcmf_fw_request_done); 670*c2dac3d2SLinus Walleij 671*c2dac3d2SLinus Walleij if (fw || ret < 0) 672*c2dac3d2SLinus Walleij brcmf_fw_request_done(fw, ctx); 673*c2dac3d2SLinus Walleij } 674*c2dac3d2SLinus Walleij 675d09ae51aSArend Van Spriel static bool brcmf_fw_request_is_valid(struct brcmf_fw_request *req) 676d09ae51aSArend Van Spriel { 677d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 678d09ae51aSArend Van Spriel int i; 679d09ae51aSArend Van Spriel 680d09ae51aSArend Van Spriel if (!req->n_items) 681d09ae51aSArend Van Spriel return false; 682d09ae51aSArend Van Spriel 683d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 684d09ae51aSArend Van Spriel if (!item->path) 685d09ae51aSArend Van Spriel return false; 686d09ae51aSArend Van Spriel } 687d09ae51aSArend Van Spriel return true; 688d09ae51aSArend Van Spriel } 689d09ae51aSArend Van Spriel 690d09ae51aSArend Van Spriel int brcmf_fw_get_firmwares(struct device *dev, struct brcmf_fw_request *req, 6916d0507a7SArend Van Spriel void (*fw_cb)(struct device *dev, int err, 692d09ae51aSArend Van Spriel struct brcmf_fw_request *req)) 69305491d2cSKalle Valo { 6945b587496SHans de Goede struct brcmf_fw_item *first = &req->items[0]; 69505491d2cSKalle Valo struct brcmf_fw *fwctx; 6965ff01391SLinus Walleij char *alt_path; 6975b587496SHans de Goede int ret; 69805491d2cSKalle Valo 69905491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(dev)); 700d09ae51aSArend Van Spriel if (!fw_cb) 70105491d2cSKalle Valo return -EINVAL; 70205491d2cSKalle Valo 703d09ae51aSArend Van Spriel if (!brcmf_fw_request_is_valid(req)) 70405491d2cSKalle Valo return -EINVAL; 70505491d2cSKalle Valo 70605491d2cSKalle Valo fwctx = kzalloc(sizeof(*fwctx), GFP_KERNEL); 70705491d2cSKalle Valo if (!fwctx) 70805491d2cSKalle Valo return -ENOMEM; 70905491d2cSKalle Valo 71005491d2cSKalle Valo fwctx->dev = dev; 711d09ae51aSArend Van Spriel fwctx->req = req; 71205491d2cSKalle Valo fwctx->done = fw_cb; 71305491d2cSKalle Valo 7145ff01391SLinus Walleij /* First try alternative board-specific path if any */ 7155ff01391SLinus Walleij alt_path = brcm_alt_fw_path(first->path, fwctx->req->board_type); 7165ff01391SLinus Walleij if (alt_path) { 7175ff01391SLinus Walleij ret = request_firmware_nowait(THIS_MODULE, true, alt_path, 7185ff01391SLinus Walleij fwctx->dev, GFP_KERNEL, fwctx, 719*c2dac3d2SLinus Walleij brcmf_fw_request_done_alt_path); 7205ff01391SLinus Walleij kfree(alt_path); 721*c2dac3d2SLinus Walleij } else { 7225b587496SHans de Goede ret = request_firmware_nowait(THIS_MODULE, true, first->path, 7235b587496SHans de Goede fwctx->dev, GFP_KERNEL, fwctx, 7245b587496SHans de Goede brcmf_fw_request_done); 7255ff01391SLinus Walleij } 7265b587496SHans de Goede if (ret < 0) 7275b587496SHans de Goede brcmf_fw_request_done(NULL, fwctx); 7285b587496SHans de Goede 729d09ae51aSArend Van Spriel return 0; 73005491d2cSKalle Valo } 73105491d2cSKalle Valo 7322baa3aaeSArend Van Spriel struct brcmf_fw_request * 7332baa3aaeSArend Van Spriel brcmf_fw_alloc_request(u32 chip, u32 chiprev, 734ff68c9f9SArend Van Spriel const struct brcmf_firmware_mapping mapping_table[], 7352baa3aaeSArend Van Spriel u32 table_size, struct brcmf_fw_name *fwnames, 7362baa3aaeSArend Van Spriel u32 n_fwnames) 7372baa3aaeSArend Van Spriel { 7382baa3aaeSArend Van Spriel struct brcmf_fw_request *fwreq; 7392baa3aaeSArend Van Spriel char chipname[12]; 7402baa3aaeSArend Van Spriel const char *mp_path; 741b72c51a5SLyude Paul size_t mp_path_len; 7422baa3aaeSArend Van Spriel u32 i, j; 743b72c51a5SLyude Paul char end = '\0'; 7442baa3aaeSArend Van Spriel 7452baa3aaeSArend Van Spriel for (i = 0; i < table_size; i++) { 7462baa3aaeSArend Van Spriel if (mapping_table[i].chipid == chip && 7472baa3aaeSArend Van Spriel mapping_table[i].revmask & BIT(chiprev)) 7482baa3aaeSArend Van Spriel break; 7492baa3aaeSArend Van Spriel } 7502baa3aaeSArend Van Spriel 751a250c91cSArend van Spriel brcmf_chip_name(chip, chiprev, chipname, sizeof(chipname)); 752a250c91cSArend van Spriel 7532baa3aaeSArend Van Spriel if (i == table_size) { 754a250c91cSArend van Spriel brcmf_err("Unknown chip %s\n", chipname); 7552baa3aaeSArend Van Spriel return NULL; 7562baa3aaeSArend Van Spriel } 7572baa3aaeSArend Van Spriel 7580cf83903SGustavo A. R. Silva fwreq = kzalloc(struct_size(fwreq, items, n_fwnames), GFP_KERNEL); 7592baa3aaeSArend Van Spriel if (!fwreq) 7602baa3aaeSArend Van Spriel return NULL; 7612baa3aaeSArend Van Spriel 7622baa3aaeSArend Van Spriel brcmf_info("using %s for chip %s\n", 7632baa3aaeSArend Van Spriel mapping_table[i].fw_base, chipname); 7642baa3aaeSArend Van Spriel 7652baa3aaeSArend Van Spriel mp_path = brcmf_mp_global.firmware_path; 766b72c51a5SLyude Paul mp_path_len = strnlen(mp_path, BRCMF_FW_ALTPATH_LEN); 767b72c51a5SLyude Paul if (mp_path_len) 768b72c51a5SLyude Paul end = mp_path[mp_path_len - 1]; 769b72c51a5SLyude Paul 7702baa3aaeSArend Van Spriel fwreq->n_items = n_fwnames; 7712baa3aaeSArend Van Spriel 7722baa3aaeSArend Van Spriel for (j = 0; j < n_fwnames; j++) { 7732baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 774c9692820SRafał Miłecki fwnames[j].path[0] = '\0'; 7752baa3aaeSArend Van Spriel /* check if firmware path is provided by module parameter */ 7762baa3aaeSArend Van Spriel if (brcmf_mp_global.firmware_path[0] != '\0') { 7772baa3aaeSArend Van Spriel strlcpy(fwnames[j].path, mp_path, 7782baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 7792baa3aaeSArend Van Spriel 7802baa3aaeSArend Van Spriel if (end != '/') { 7812baa3aaeSArend Van Spriel strlcat(fwnames[j].path, "/", 7822baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 7832baa3aaeSArend Van Spriel } 7842baa3aaeSArend Van Spriel } 785bf291b72SArend Van Spriel strlcat(fwnames[j].path, mapping_table[i].fw_base, 786bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 787bf291b72SArend Van Spriel strlcat(fwnames[j].path, fwnames[j].extension, 788bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 7892baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 7902baa3aaeSArend Van Spriel } 7912baa3aaeSArend Van Spriel 7922baa3aaeSArend Van Spriel return fwreq; 7932baa3aaeSArend Van Spriel } 794