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; 433*7cb46e72SHector Martin unsigned int board_index; 434d09ae51aSArend Van Spriel void (*done)(struct device *dev, int err, struct brcmf_fw_request *req); 43505491d2cSKalle Valo }; 43605491d2cSKalle Valo 437ce2e6db5SHans de Goede #ifdef CONFIG_EFI 43829ec3394SHans de Goede /* In some cases the EFI-var stored nvram contains "ccode=ALL" or "ccode=XV" 43929ec3394SHans de Goede * to specify "worldwide" compatible settings, but these 2 ccode-s do not work 44029ec3394SHans de Goede * properly. "ccode=ALL" causes channels 12 and 13 to not be available, 44129ec3394SHans de Goede * "ccode=XV" causes all 5GHz channels to not be available. So we replace both 44229ec3394SHans de Goede * with "ccode=X2" which allows channels 12+13 and 5Ghz channels in 44329ec3394SHans de Goede * no-Initiate-Radiation mode. This means that we will never send on these 44429ec3394SHans de Goede * channels without first having received valid wifi traffic on the channel. 44529ec3394SHans de Goede */ 44629ec3394SHans de Goede static void brcmf_fw_fix_efi_nvram_ccode(char *data, unsigned long data_len) 44729ec3394SHans de Goede { 44829ec3394SHans de Goede char *ccode; 44929ec3394SHans de Goede 45029ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=ALL", data_len); 45129ec3394SHans de Goede if (!ccode) 45229ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=XV\r", data_len); 45329ec3394SHans de Goede if (!ccode) 45429ec3394SHans de Goede return; 45529ec3394SHans de Goede 45629ec3394SHans de Goede ccode[6] = 'X'; 45729ec3394SHans de Goede ccode[7] = '2'; 45829ec3394SHans de Goede ccode[8] = '\r'; 45929ec3394SHans de Goede } 46029ec3394SHans de Goede 461ce2e6db5SHans de Goede static u8 *brcmf_fw_nvram_from_efi(size_t *data_len_ret) 462ce2e6db5SHans de Goede { 46398e152c1SArd Biesheuvel efi_guid_t guid = EFI_GUID(0x74b00bd9, 0x805a, 0x4d61, 0xb5, 0x1f, 46498e152c1SArd Biesheuvel 0x43, 0x26, 0x81, 0x23, 0xd1, 0x13); 465ce2e6db5SHans de Goede unsigned long data_len = 0; 46698e152c1SArd Biesheuvel efi_status_t status; 467ce2e6db5SHans de Goede u8 *data = NULL; 468ce2e6db5SHans de Goede 46998e152c1SArd Biesheuvel if (!efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE)) 470ce2e6db5SHans de Goede return NULL; 471ce2e6db5SHans de Goede 47298e152c1SArd Biesheuvel status = efi.get_variable(L"nvram", &guid, NULL, &data_len, NULL); 47398e152c1SArd Biesheuvel if (status != EFI_BUFFER_TOO_SMALL) 474ce2e6db5SHans de Goede goto fail; 475ce2e6db5SHans de Goede 476ce2e6db5SHans de Goede data = kmalloc(data_len, GFP_KERNEL); 477ce2e6db5SHans de Goede if (!data) 478ce2e6db5SHans de Goede goto fail; 479ce2e6db5SHans de Goede 48098e152c1SArd Biesheuvel status = efi.get_variable(L"nvram", &guid, NULL, &data_len, data); 48198e152c1SArd Biesheuvel if (status != EFI_SUCCESS) 482ce2e6db5SHans de Goede goto fail; 483ce2e6db5SHans de Goede 48429ec3394SHans de Goede brcmf_fw_fix_efi_nvram_ccode(data, data_len); 485ce2e6db5SHans de Goede brcmf_info("Using nvram EFI variable\n"); 486ce2e6db5SHans de Goede 487ce2e6db5SHans de Goede *data_len_ret = data_len; 488ce2e6db5SHans de Goede return data; 489ce2e6db5SHans de Goede fail: 490ce2e6db5SHans de Goede kfree(data); 491ce2e6db5SHans de Goede return NULL; 492ce2e6db5SHans de Goede } 493ce2e6db5SHans de Goede #else 494412dd15cSArnd Bergmann static inline u8 *brcmf_fw_nvram_from_efi(size_t *data_len) { return NULL; } 495ce2e6db5SHans de Goede #endif 496ce2e6db5SHans de Goede 497d09ae51aSArend Van Spriel static void brcmf_fw_free_request(struct brcmf_fw_request *req) 498d09ae51aSArend Van Spriel { 499d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 500d09ae51aSArend Van Spriel int i; 501d09ae51aSArend Van Spriel 502d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 503d09ae51aSArend Van Spriel if (item->type == BRCMF_FW_TYPE_BINARY) 504d09ae51aSArend Van Spriel release_firmware(item->binary); 505d09ae51aSArend Van Spriel else if (item->type == BRCMF_FW_TYPE_NVRAM) 506d09ae51aSArend Van Spriel brcmf_fw_nvram_free(item->nv_data.data); 507d09ae51aSArend Van Spriel } 508d09ae51aSArend Van Spriel kfree(req); 509d09ae51aSArend Van Spriel } 510d09ae51aSArend Van Spriel 5110b5c0305SArend Van Spriel static int brcmf_fw_request_nvram_done(const struct firmware *fw, void *ctx) 51205491d2cSKalle Valo { 51305491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 514d09ae51aSArend Van Spriel struct brcmf_fw_item *cur; 515ce2e6db5SHans de Goede bool free_bcm47xx_nvram = false; 516ce2e6db5SHans de Goede bool kfree_nvram = false; 51705491d2cSKalle Valo u32 nvram_length = 0; 51805491d2cSKalle Valo void *nvram = NULL; 51905491d2cSKalle Valo u8 *data = NULL; 52005491d2cSKalle Valo size_t data_len; 52105491d2cSKalle Valo 52205491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev)); 523d09ae51aSArend Van Spriel 524d09ae51aSArend Van Spriel cur = &fwctx->req->items[fwctx->curpos]; 525d09ae51aSArend Van Spriel 52605491d2cSKalle Valo if (fw && fw->data) { 52705491d2cSKalle Valo data = (u8 *)fw->data; 52805491d2cSKalle Valo data_len = fw->size; 52905491d2cSKalle Valo } else { 530ce2e6db5SHans de Goede if ((data = bcm47xx_nvram_get_contents(&data_len))) 531ce2e6db5SHans de Goede free_bcm47xx_nvram = true; 532ce2e6db5SHans de Goede else if ((data = brcmf_fw_nvram_from_efi(&data_len))) 533ce2e6db5SHans de Goede kfree_nvram = true; 534ce2e6db5SHans de Goede else if (!(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 53505491d2cSKalle Valo goto fail; 53605491d2cSKalle Valo } 53705491d2cSKalle Valo 53805491d2cSKalle Valo if (data) 53905491d2cSKalle Valo nvram = brcmf_fw_nvram_strip(data, data_len, &nvram_length, 540d09ae51aSArend Van Spriel fwctx->req->domain_nr, 541d09ae51aSArend Van Spriel fwctx->req->bus_nr); 54205491d2cSKalle Valo 543ce2e6db5SHans de Goede if (free_bcm47xx_nvram) 54405491d2cSKalle Valo bcm47xx_nvram_release_contents(data); 545ce2e6db5SHans de Goede if (kfree_nvram) 546ce2e6db5SHans de Goede kfree(data); 547ce2e6db5SHans de Goede 54805491d2cSKalle Valo release_firmware(fw); 549d09ae51aSArend Van Spriel if (!nvram && !(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 55005491d2cSKalle Valo goto fail; 55105491d2cSKalle Valo 552d09ae51aSArend Van Spriel brcmf_dbg(TRACE, "nvram %p len %d\n", nvram, nvram_length); 553d09ae51aSArend Van Spriel cur->nv_data.data = nvram; 554d09ae51aSArend Van Spriel cur->nv_data.len = nvram_length; 5550b5c0305SArend Van Spriel return 0; 55605491d2cSKalle Valo 55705491d2cSKalle Valo fail: 5580b5c0305SArend Van Spriel return -ENOENT; 55905491d2cSKalle Valo } 56005491d2cSKalle Valo 561a1a3b762SHans de Goede static int brcmf_fw_complete_request(const struct firmware *fw, 562a1a3b762SHans de Goede struct brcmf_fw *fwctx) 563a1a3b762SHans de Goede { 564a1a3b762SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 565a1a3b762SHans de Goede int ret = 0; 566a1a3b762SHans de Goede 567a1a3b762SHans de Goede brcmf_dbg(TRACE, "firmware %s %sfound\n", cur->path, fw ? "" : "not "); 568a1a3b762SHans de Goede 569a1a3b762SHans de Goede switch (cur->type) { 570a1a3b762SHans de Goede case BRCMF_FW_TYPE_NVRAM: 571a1a3b762SHans de Goede ret = brcmf_fw_request_nvram_done(fw, fwctx); 572a1a3b762SHans de Goede break; 573a1a3b762SHans de Goede case BRCMF_FW_TYPE_BINARY: 574a1a3b762SHans de Goede if (fw) 575a1a3b762SHans de Goede cur->binary = fw; 576a1a3b762SHans de Goede else 577a1a3b762SHans de Goede ret = -ENOENT; 578a1a3b762SHans de Goede break; 579a1a3b762SHans de Goede default: 580a1a3b762SHans de Goede /* something fishy here so bail out early */ 581a1a3b762SHans de Goede brcmf_err("unknown fw type: %d\n", cur->type); 582a1a3b762SHans de Goede release_firmware(fw); 583a1a3b762SHans de Goede ret = -EINVAL; 584a1a3b762SHans de Goede } 585a1a3b762SHans de Goede 586a1a3b762SHans de Goede return (cur->flags & BRCMF_FW_REQF_OPTIONAL) ? 0 : ret; 587a1a3b762SHans de Goede } 588a1a3b762SHans de Goede 5895ff01391SLinus Walleij static char *brcm_alt_fw_path(const char *path, const char *board_type) 5905ff01391SLinus Walleij { 591e263d722SHector Martin char base[BRCMF_FW_NAME_LEN]; 592e263d722SHector Martin const char *suffix; 593e263d722SHector Martin char *ret; 5945ff01391SLinus Walleij 595e263d722SHector Martin if (!board_type) 5965ff01391SLinus Walleij return NULL; 5975ff01391SLinus Walleij 598e263d722SHector Martin suffix = strrchr(path, '.'); 599e263d722SHector Martin if (!suffix || suffix == path) 600e263d722SHector Martin return NULL; 6015ff01391SLinus Walleij 602e263d722SHector Martin /* strip extension at the end */ 603e263d722SHector Martin strscpy(base, path, BRCMF_FW_NAME_LEN); 604e263d722SHector Martin base[suffix - path] = 0; 605e263d722SHector Martin 606e263d722SHector Martin ret = kasprintf(GFP_KERNEL, "%s.%s%s", base, board_type, suffix); 607e263d722SHector Martin if (!ret) 608e263d722SHector Martin brcmf_err("out of memory allocating firmware path for '%s'\n", 609e263d722SHector Martin path); 610e263d722SHector Martin 611e263d722SHector Martin brcmf_dbg(TRACE, "FW alt path: %s\n", ret); 612e263d722SHector Martin 613e263d722SHector Martin return ret; 6145ff01391SLinus Walleij } 6155ff01391SLinus Walleij 616eae8e506SHans de Goede static int brcmf_fw_request_firmware(const struct firmware **fw, 617eae8e506SHans de Goede struct brcmf_fw *fwctx) 618eae8e506SHans de Goede { 619eae8e506SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 620*7cb46e72SHector Martin unsigned int i; 621eae8e506SHans de Goede int ret; 622eae8e506SHans de Goede 623*7cb46e72SHector Martin /* Files can be board-specific, first try board-specific paths */ 624*7cb46e72SHector Martin for (i = 0; i < ARRAY_SIZE(fwctx->req->board_types); i++) { 6255ff01391SLinus Walleij char *alt_path; 626eae8e506SHans de Goede 627*7cb46e72SHector Martin if (!fwctx->req->board_types[i]) 628*7cb46e72SHector Martin goto fallback; 629*7cb46e72SHector Martin alt_path = brcm_alt_fw_path(cur->path, 630*7cb46e72SHector Martin fwctx->req->board_types[i]); 6315ff01391SLinus Walleij if (!alt_path) 6325ff01391SLinus Walleij goto fallback; 633eae8e506SHans de Goede 634*7cb46e72SHector Martin ret = firmware_request_nowarn(fw, alt_path, fwctx->dev); 6355ff01391SLinus Walleij kfree(alt_path); 636eae8e506SHans de Goede if (ret == 0) 637eae8e506SHans de Goede return ret; 638eae8e506SHans de Goede } 639eae8e506SHans de Goede 6405ff01391SLinus Walleij fallback: 641eae8e506SHans de Goede return request_firmware(fw, cur->path, fwctx->dev); 642eae8e506SHans de Goede } 643eae8e506SHans de Goede 644d09ae51aSArend Van Spriel static void brcmf_fw_request_done(const struct firmware *fw, void *ctx) 64505491d2cSKalle Valo { 64605491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 64755e491edSHans de Goede int ret; 648d09ae51aSArend Van Spriel 649a1a3b762SHans de Goede ret = brcmf_fw_complete_request(fw, fwctx); 6500b5c0305SArend Van Spriel 6515b587496SHans de Goede while (ret == 0 && ++fwctx->curpos < fwctx->req->n_items) { 652eae8e506SHans de Goede brcmf_fw_request_firmware(&fw, fwctx); 6535b587496SHans de Goede ret = brcmf_fw_complete_request(fw, ctx); 654d09ae51aSArend Van Spriel } 65503fb0e83SArend Van Spriel 6565b587496SHans de Goede if (ret) { 657d09ae51aSArend Van Spriel brcmf_fw_free_request(fwctx->req); 658d09ae51aSArend Van Spriel fwctx->req = NULL; 6595b587496SHans de Goede } 660d09ae51aSArend Van Spriel fwctx->done(fwctx->dev, ret, fwctx->req); 66105491d2cSKalle Valo kfree(fwctx); 66205491d2cSKalle Valo } 66305491d2cSKalle Valo 664c2dac3d2SLinus Walleij static void brcmf_fw_request_done_alt_path(const struct firmware *fw, void *ctx) 665c2dac3d2SLinus Walleij { 666c2dac3d2SLinus Walleij struct brcmf_fw *fwctx = ctx; 667c2dac3d2SLinus Walleij struct brcmf_fw_item *first = &fwctx->req->items[0]; 668*7cb46e72SHector Martin const char *board_type, *alt_path; 669c2dac3d2SLinus Walleij int ret = 0; 670c2dac3d2SLinus Walleij 671*7cb46e72SHector Martin if (fw) { 672*7cb46e72SHector Martin brcmf_fw_request_done(fw, ctx); 673*7cb46e72SHector Martin return; 674*7cb46e72SHector Martin } 675*7cb46e72SHector Martin 676*7cb46e72SHector Martin /* Try next board firmware */ 677*7cb46e72SHector Martin if (fwctx->board_index < ARRAY_SIZE(fwctx->req->board_types)) { 678*7cb46e72SHector Martin board_type = fwctx->req->board_types[fwctx->board_index++]; 679*7cb46e72SHector Martin if (!board_type) 680*7cb46e72SHector Martin goto fallback; 681*7cb46e72SHector Martin alt_path = brcm_alt_fw_path(first->path, board_type); 682*7cb46e72SHector Martin if (!alt_path) 683*7cb46e72SHector Martin goto fallback; 684*7cb46e72SHector Martin 685*7cb46e72SHector Martin ret = request_firmware_nowait(THIS_MODULE, true, alt_path, 686*7cb46e72SHector Martin fwctx->dev, GFP_KERNEL, fwctx, 687*7cb46e72SHector Martin brcmf_fw_request_done_alt_path); 688*7cb46e72SHector Martin kfree(alt_path); 689*7cb46e72SHector Martin 690*7cb46e72SHector Martin if (ret < 0) 691*7cb46e72SHector Martin brcmf_fw_request_done(fw, ctx); 692*7cb46e72SHector Martin return; 693*7cb46e72SHector Martin } 694*7cb46e72SHector Martin 695*7cb46e72SHector Martin fallback: 696c2dac3d2SLinus Walleij /* Fall back to canonical path if board firmware not found */ 697c2dac3d2SLinus Walleij ret = request_firmware_nowait(THIS_MODULE, true, first->path, 698c2dac3d2SLinus Walleij fwctx->dev, GFP_KERNEL, fwctx, 699c2dac3d2SLinus Walleij brcmf_fw_request_done); 700c2dac3d2SLinus Walleij 701*7cb46e72SHector Martin if (ret < 0) 702c2dac3d2SLinus Walleij brcmf_fw_request_done(fw, ctx); 703c2dac3d2SLinus Walleij } 704c2dac3d2SLinus Walleij 705d09ae51aSArend Van Spriel static bool brcmf_fw_request_is_valid(struct brcmf_fw_request *req) 706d09ae51aSArend Van Spriel { 707d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 708d09ae51aSArend Van Spriel int i; 709d09ae51aSArend Van Spriel 710d09ae51aSArend Van Spriel if (!req->n_items) 711d09ae51aSArend Van Spriel return false; 712d09ae51aSArend Van Spriel 713d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 714d09ae51aSArend Van Spriel if (!item->path) 715d09ae51aSArend Van Spriel return false; 716d09ae51aSArend Van Spriel } 717d09ae51aSArend Van Spriel return true; 718d09ae51aSArend Van Spriel } 719d09ae51aSArend Van Spriel 720d09ae51aSArend Van Spriel int brcmf_fw_get_firmwares(struct device *dev, struct brcmf_fw_request *req, 7216d0507a7SArend Van Spriel void (*fw_cb)(struct device *dev, int err, 722d09ae51aSArend Van Spriel struct brcmf_fw_request *req)) 72305491d2cSKalle Valo { 7245b587496SHans de Goede struct brcmf_fw_item *first = &req->items[0]; 72505491d2cSKalle Valo struct brcmf_fw *fwctx; 726665408f4SPhil Elwell char *alt_path = NULL; 7275b587496SHans de Goede int ret; 72805491d2cSKalle Valo 72905491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(dev)); 730d09ae51aSArend Van Spriel if (!fw_cb) 73105491d2cSKalle Valo return -EINVAL; 73205491d2cSKalle Valo 733d09ae51aSArend Van Spriel if (!brcmf_fw_request_is_valid(req)) 73405491d2cSKalle Valo return -EINVAL; 73505491d2cSKalle Valo 73605491d2cSKalle Valo fwctx = kzalloc(sizeof(*fwctx), GFP_KERNEL); 73705491d2cSKalle Valo if (!fwctx) 73805491d2cSKalle Valo return -ENOMEM; 73905491d2cSKalle Valo 74005491d2cSKalle Valo fwctx->dev = dev; 741d09ae51aSArend Van Spriel fwctx->req = req; 74205491d2cSKalle Valo fwctx->done = fw_cb; 74305491d2cSKalle Valo 7445ff01391SLinus Walleij /* First try alternative board-specific path if any */ 745*7cb46e72SHector Martin if (fwctx->req->board_types[0]) 746665408f4SPhil Elwell alt_path = brcm_alt_fw_path(first->path, 747*7cb46e72SHector Martin fwctx->req->board_types[0]); 7485ff01391SLinus Walleij if (alt_path) { 749*7cb46e72SHector Martin fwctx->board_index++; 7505ff01391SLinus Walleij ret = request_firmware_nowait(THIS_MODULE, true, alt_path, 7515ff01391SLinus Walleij fwctx->dev, GFP_KERNEL, fwctx, 752c2dac3d2SLinus Walleij brcmf_fw_request_done_alt_path); 7535ff01391SLinus Walleij kfree(alt_path); 754c2dac3d2SLinus Walleij } else { 7555b587496SHans de Goede ret = request_firmware_nowait(THIS_MODULE, true, first->path, 7565b587496SHans de Goede fwctx->dev, GFP_KERNEL, fwctx, 7575b587496SHans de Goede brcmf_fw_request_done); 7585ff01391SLinus Walleij } 7595b587496SHans de Goede if (ret < 0) 7605b587496SHans de Goede brcmf_fw_request_done(NULL, fwctx); 7615b587496SHans de Goede 762d09ae51aSArend Van Spriel return 0; 76305491d2cSKalle Valo } 76405491d2cSKalle Valo 7652baa3aaeSArend Van Spriel struct brcmf_fw_request * 7662baa3aaeSArend Van Spriel brcmf_fw_alloc_request(u32 chip, u32 chiprev, 767ff68c9f9SArend Van Spriel const struct brcmf_firmware_mapping mapping_table[], 7682baa3aaeSArend Van Spriel u32 table_size, struct brcmf_fw_name *fwnames, 7692baa3aaeSArend Van Spriel u32 n_fwnames) 7702baa3aaeSArend Van Spriel { 7712baa3aaeSArend Van Spriel struct brcmf_fw_request *fwreq; 7722baa3aaeSArend Van Spriel char chipname[12]; 7732baa3aaeSArend Van Spriel const char *mp_path; 774b72c51a5SLyude Paul size_t mp_path_len; 7752baa3aaeSArend Van Spriel u32 i, j; 776b72c51a5SLyude Paul char end = '\0'; 7772baa3aaeSArend Van Spriel 7782baa3aaeSArend Van Spriel for (i = 0; i < table_size; i++) { 7792baa3aaeSArend Van Spriel if (mapping_table[i].chipid == chip && 7802baa3aaeSArend Van Spriel mapping_table[i].revmask & BIT(chiprev)) 7812baa3aaeSArend Van Spriel break; 7822baa3aaeSArend Van Spriel } 7832baa3aaeSArend Van Spriel 784a250c91cSArend van Spriel brcmf_chip_name(chip, chiprev, chipname, sizeof(chipname)); 785a250c91cSArend van Spriel 7862baa3aaeSArend Van Spriel if (i == table_size) { 787a250c91cSArend van Spriel brcmf_err("Unknown chip %s\n", chipname); 7882baa3aaeSArend Van Spriel return NULL; 7892baa3aaeSArend Van Spriel } 7902baa3aaeSArend Van Spriel 7910cf83903SGustavo A. R. Silva fwreq = kzalloc(struct_size(fwreq, items, n_fwnames), GFP_KERNEL); 7922baa3aaeSArend Van Spriel if (!fwreq) 7932baa3aaeSArend Van Spriel return NULL; 7942baa3aaeSArend Van Spriel 7952baa3aaeSArend Van Spriel brcmf_info("using %s for chip %s\n", 7962baa3aaeSArend Van Spriel mapping_table[i].fw_base, chipname); 7972baa3aaeSArend Van Spriel 7982baa3aaeSArend Van Spriel mp_path = brcmf_mp_global.firmware_path; 799b72c51a5SLyude Paul mp_path_len = strnlen(mp_path, BRCMF_FW_ALTPATH_LEN); 800b72c51a5SLyude Paul if (mp_path_len) 801b72c51a5SLyude Paul end = mp_path[mp_path_len - 1]; 802b72c51a5SLyude Paul 8032baa3aaeSArend Van Spriel fwreq->n_items = n_fwnames; 8042baa3aaeSArend Van Spriel 8052baa3aaeSArend Van Spriel for (j = 0; j < n_fwnames; j++) { 8062baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 807c9692820SRafał Miłecki fwnames[j].path[0] = '\0'; 8082baa3aaeSArend Van Spriel /* check if firmware path is provided by module parameter */ 8092baa3aaeSArend Van Spriel if (brcmf_mp_global.firmware_path[0] != '\0') { 810bf99f11dSWolfram Sang strscpy(fwnames[j].path, mp_path, 8112baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 8122baa3aaeSArend Van Spriel 8132baa3aaeSArend Van Spriel if (end != '/') { 8142baa3aaeSArend Van Spriel strlcat(fwnames[j].path, "/", 8152baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 8162baa3aaeSArend Van Spriel } 8172baa3aaeSArend Van Spriel } 818bf291b72SArend Van Spriel strlcat(fwnames[j].path, mapping_table[i].fw_base, 819bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 820bf291b72SArend Van Spriel strlcat(fwnames[j].path, fwnames[j].extension, 821bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 8222baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 8232baa3aaeSArend Van Spriel } 8242baa3aaeSArend Van Spriel 8252baa3aaeSArend Van Spriel return fwreq; 8262baa3aaeSArend Van Spriel } 827