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" 24*687f767dSHector Martin #define BRCMF_FW_MACADDR_FMT "macaddr=%pM" 25*687f767dSHector Martin #define BRCMF_FW_MACADDR_LEN (7 + ETH_ALEN * 3) 2605491d2cSKalle Valo 2705491d2cSKalle Valo enum nvram_parser_state { 2805491d2cSKalle Valo IDLE, 2905491d2cSKalle Valo KEY, 3005491d2cSKalle Valo VALUE, 3105491d2cSKalle Valo COMMENT, 3205491d2cSKalle Valo END 3305491d2cSKalle Valo }; 3405491d2cSKalle Valo 3505491d2cSKalle Valo /** 3605491d2cSKalle Valo * struct nvram_parser - internal info for parser. 3705491d2cSKalle Valo * 3805491d2cSKalle Valo * @state: current parser state. 3905491d2cSKalle Valo * @data: input buffer being parsed. 4005491d2cSKalle Valo * @nvram: output buffer with parse result. 412359dd09SMatteo Croce * @nvram_len: length of parse result. 4205491d2cSKalle Valo * @line: current line. 4305491d2cSKalle Valo * @column: current column in line. 4405491d2cSKalle Valo * @pos: byte offset in input buffer. 4505491d2cSKalle Valo * @entry: start position of key,value entry. 4605491d2cSKalle Valo * @multi_dev_v1: detect pcie multi device v1 (compressed). 4705491d2cSKalle Valo * @multi_dev_v2: detect pcie multi device v2. 4846f2b38aSHante Meuleman * @boardrev_found: nvram contains boardrev information. 49*687f767dSHector Martin * @strip_mac: strip the MAC address. 5005491d2cSKalle Valo */ 5105491d2cSKalle Valo struct nvram_parser { 5205491d2cSKalle Valo enum nvram_parser_state state; 5305491d2cSKalle Valo const u8 *data; 5405491d2cSKalle Valo u8 *nvram; 5505491d2cSKalle Valo u32 nvram_len; 5605491d2cSKalle Valo u32 line; 5705491d2cSKalle Valo u32 column; 5805491d2cSKalle Valo u32 pos; 5905491d2cSKalle Valo u32 entry; 6005491d2cSKalle Valo bool multi_dev_v1; 6105491d2cSKalle Valo bool multi_dev_v2; 6246f2b38aSHante Meuleman bool boardrev_found; 63*687f767dSHector Martin bool strip_mac; 6405491d2cSKalle Valo }; 6505491d2cSKalle Valo 66866cf939SLee Jones /* 6705491d2cSKalle Valo * is_nvram_char() - check if char is a valid one for NVRAM entry 6805491d2cSKalle Valo * 6905491d2cSKalle Valo * It accepts all printable ASCII chars except for '#' which opens a comment. 7005491d2cSKalle Valo * Please note that ' ' (space) while accepted is not a valid key name char. 7105491d2cSKalle Valo */ 7205491d2cSKalle Valo static bool is_nvram_char(char c) 7305491d2cSKalle Valo { 7405491d2cSKalle Valo /* comment marker excluded */ 7505491d2cSKalle Valo if (c == '#') 7605491d2cSKalle Valo return false; 7705491d2cSKalle Valo 7805491d2cSKalle Valo /* key and value may have any other readable character */ 7905491d2cSKalle Valo return (c >= 0x20 && c < 0x7f); 8005491d2cSKalle Valo } 8105491d2cSKalle Valo 8205491d2cSKalle Valo static bool is_whitespace(char c) 8305491d2cSKalle Valo { 8405491d2cSKalle Valo return (c == ' ' || c == '\r' || c == '\n' || c == '\t'); 8505491d2cSKalle Valo } 8605491d2cSKalle Valo 8705491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_idle(struct nvram_parser *nvp) 8805491d2cSKalle Valo { 8905491d2cSKalle Valo char c; 9005491d2cSKalle Valo 9105491d2cSKalle Valo c = nvp->data[nvp->pos]; 9205491d2cSKalle Valo if (c == '\n') 9305491d2cSKalle Valo return COMMENT; 94d1e61b86SRafał Miłecki if (is_whitespace(c) || c == '\0') 9505491d2cSKalle Valo goto proceed; 9605491d2cSKalle Valo if (c == '#') 9705491d2cSKalle Valo return COMMENT; 9805491d2cSKalle Valo if (is_nvram_char(c)) { 9905491d2cSKalle Valo nvp->entry = nvp->pos; 10005491d2cSKalle Valo return KEY; 10105491d2cSKalle Valo } 10205491d2cSKalle Valo brcmf_dbg(INFO, "warning: ln=%d:col=%d: ignoring invalid character\n", 10305491d2cSKalle Valo nvp->line, nvp->column); 10405491d2cSKalle Valo proceed: 10505491d2cSKalle Valo nvp->column++; 10605491d2cSKalle Valo nvp->pos++; 10705491d2cSKalle Valo return IDLE; 10805491d2cSKalle Valo } 10905491d2cSKalle Valo 11005491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_key(struct nvram_parser *nvp) 11105491d2cSKalle Valo { 11205491d2cSKalle Valo enum nvram_parser_state st = nvp->state; 11305491d2cSKalle Valo char c; 11405491d2cSKalle Valo 11505491d2cSKalle Valo c = nvp->data[nvp->pos]; 11605491d2cSKalle Valo if (c == '=') { 11705491d2cSKalle Valo /* ignore RAW1 by treating as comment */ 11805491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "RAW1", 4) == 0) 11905491d2cSKalle Valo st = COMMENT; 12005491d2cSKalle Valo else 12105491d2cSKalle Valo st = VALUE; 12205491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "devpath", 7) == 0) 12305491d2cSKalle Valo nvp->multi_dev_v1 = true; 12405491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "pcie/", 5) == 0) 12505491d2cSKalle Valo nvp->multi_dev_v2 = true; 12646f2b38aSHante Meuleman if (strncmp(&nvp->data[nvp->entry], "boardrev", 8) == 0) 12746f2b38aSHante Meuleman nvp->boardrev_found = true; 128*687f767dSHector Martin /* strip macaddr if platform MAC overrides */ 129*687f767dSHector Martin if (nvp->strip_mac && 130*687f767dSHector Martin strncmp(&nvp->data[nvp->entry], "macaddr", 7) == 0) 131*687f767dSHector Martin st = COMMENT; 13205491d2cSKalle Valo } else if (!is_nvram_char(c) || c == ' ') { 13305491d2cSKalle Valo brcmf_dbg(INFO, "warning: ln=%d:col=%d: '=' expected, skip invalid key entry\n", 13405491d2cSKalle Valo nvp->line, nvp->column); 13505491d2cSKalle Valo return COMMENT; 13605491d2cSKalle Valo } 13705491d2cSKalle Valo 13805491d2cSKalle Valo nvp->column++; 13905491d2cSKalle Valo nvp->pos++; 14005491d2cSKalle Valo return st; 14105491d2cSKalle Valo } 14205491d2cSKalle Valo 14305491d2cSKalle Valo static enum nvram_parser_state 14405491d2cSKalle Valo brcmf_nvram_handle_value(struct nvram_parser *nvp) 14505491d2cSKalle Valo { 14605491d2cSKalle Valo char c; 14705491d2cSKalle Valo char *skv; 14805491d2cSKalle Valo char *ekv; 14905491d2cSKalle Valo u32 cplen; 15005491d2cSKalle Valo 15105491d2cSKalle Valo c = nvp->data[nvp->pos]; 15205491d2cSKalle Valo if (!is_nvram_char(c)) { 15305491d2cSKalle Valo /* key,value pair complete */ 15405491d2cSKalle Valo ekv = (u8 *)&nvp->data[nvp->pos]; 15505491d2cSKalle Valo skv = (u8 *)&nvp->data[nvp->entry]; 15605491d2cSKalle Valo cplen = ekv - skv; 15705491d2cSKalle Valo if (nvp->nvram_len + cplen + 1 >= BRCMF_FW_MAX_NVRAM_SIZE) 15805491d2cSKalle Valo return END; 15905491d2cSKalle Valo /* copy to output buffer */ 16005491d2cSKalle Valo memcpy(&nvp->nvram[nvp->nvram_len], skv, cplen); 16105491d2cSKalle Valo nvp->nvram_len += cplen; 16205491d2cSKalle Valo nvp->nvram[nvp->nvram_len] = '\0'; 16305491d2cSKalle Valo nvp->nvram_len++; 16405491d2cSKalle Valo return IDLE; 16505491d2cSKalle Valo } 16605491d2cSKalle Valo nvp->pos++; 16705491d2cSKalle Valo nvp->column++; 16805491d2cSKalle Valo return VALUE; 16905491d2cSKalle Valo } 17005491d2cSKalle Valo 17105491d2cSKalle Valo static enum nvram_parser_state 17205491d2cSKalle Valo brcmf_nvram_handle_comment(struct nvram_parser *nvp) 17305491d2cSKalle Valo { 17405491d2cSKalle Valo char *eoc, *sol; 17505491d2cSKalle Valo 17605491d2cSKalle Valo sol = (char *)&nvp->data[nvp->pos]; 17705491d2cSKalle Valo eoc = strchr(sol, '\n'); 17805491d2cSKalle Valo if (!eoc) { 17905491d2cSKalle Valo eoc = strchr(sol, '\0'); 18005491d2cSKalle Valo if (!eoc) 18105491d2cSKalle Valo return END; 18205491d2cSKalle Valo } 18305491d2cSKalle Valo 18405491d2cSKalle Valo /* eat all moving to next line */ 18505491d2cSKalle Valo nvp->line++; 18605491d2cSKalle Valo nvp->column = 1; 18705491d2cSKalle Valo nvp->pos += (eoc - sol) + 1; 18805491d2cSKalle Valo return IDLE; 18905491d2cSKalle Valo } 19005491d2cSKalle Valo 19105491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_end(struct nvram_parser *nvp) 19205491d2cSKalle Valo { 19305491d2cSKalle Valo /* final state */ 19405491d2cSKalle Valo return END; 19505491d2cSKalle Valo } 19605491d2cSKalle Valo 19705491d2cSKalle Valo static enum nvram_parser_state 19805491d2cSKalle Valo (*nv_parser_states[])(struct nvram_parser *nvp) = { 19905491d2cSKalle Valo brcmf_nvram_handle_idle, 20005491d2cSKalle Valo brcmf_nvram_handle_key, 20105491d2cSKalle Valo brcmf_nvram_handle_value, 20205491d2cSKalle Valo brcmf_nvram_handle_comment, 20305491d2cSKalle Valo brcmf_nvram_handle_end 20405491d2cSKalle Valo }; 20505491d2cSKalle Valo 20605491d2cSKalle Valo static int brcmf_init_nvram_parser(struct nvram_parser *nvp, 20705491d2cSKalle Valo const u8 *data, size_t data_len) 20805491d2cSKalle Valo { 20905491d2cSKalle Valo size_t size; 21005491d2cSKalle Valo 21105491d2cSKalle Valo memset(nvp, 0, sizeof(*nvp)); 21205491d2cSKalle Valo nvp->data = data; 21305491d2cSKalle Valo /* Limit size to MAX_NVRAM_SIZE, some files contain lot of comment */ 21405491d2cSKalle Valo if (data_len > BRCMF_FW_MAX_NVRAM_SIZE) 21505491d2cSKalle Valo size = BRCMF_FW_MAX_NVRAM_SIZE; 21605491d2cSKalle Valo else 21705491d2cSKalle Valo size = data_len; 218d19d8e3bSHector Martin /* Add space for properties we may add */ 219d19d8e3bSHector Martin size += strlen(BRCMF_FW_DEFAULT_BOARDREV) + 1; 220*687f767dSHector Martin size += BRCMF_FW_MACADDR_LEN + 1; 22105491d2cSKalle Valo /* Alloc for extra 0 byte + roundup by 4 + length field */ 22205491d2cSKalle Valo size += 1 + 3 + sizeof(u32); 22305491d2cSKalle Valo nvp->nvram = kzalloc(size, GFP_KERNEL); 22405491d2cSKalle Valo if (!nvp->nvram) 22505491d2cSKalle Valo return -ENOMEM; 22605491d2cSKalle Valo 22705491d2cSKalle Valo nvp->line = 1; 22805491d2cSKalle Valo nvp->column = 1; 22905491d2cSKalle Valo return 0; 23005491d2cSKalle Valo } 23105491d2cSKalle Valo 23205491d2cSKalle Valo /* brcmf_fw_strip_multi_v1 :Some nvram files contain settings for multiple 23305491d2cSKalle Valo * devices. Strip it down for one device, use domain_nr/bus_nr to determine 23405491d2cSKalle Valo * which data is to be returned. v1 is the version where nvram is stored 23505491d2cSKalle Valo * compressed and "devpath" maps to index for valid entries. 23605491d2cSKalle Valo */ 23705491d2cSKalle Valo static void brcmf_fw_strip_multi_v1(struct nvram_parser *nvp, u16 domain_nr, 23805491d2cSKalle Valo u16 bus_nr) 23905491d2cSKalle Valo { 24005491d2cSKalle Valo /* Device path with a leading '=' key-value separator */ 24105491d2cSKalle Valo char pci_path[] = "=pci/?/?"; 24205491d2cSKalle Valo size_t pci_len; 24305491d2cSKalle Valo char pcie_path[] = "=pcie/?/?"; 24405491d2cSKalle Valo size_t pcie_len; 24505491d2cSKalle Valo 24605491d2cSKalle Valo u32 i, j; 24705491d2cSKalle Valo bool found; 24805491d2cSKalle Valo u8 *nvram; 24905491d2cSKalle Valo u8 id; 25005491d2cSKalle Valo 25105491d2cSKalle Valo nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL); 25205491d2cSKalle Valo if (!nvram) 25305491d2cSKalle Valo goto fail; 25405491d2cSKalle Valo 25505491d2cSKalle Valo /* min length: devpath0=pcie/1/4/ + 0:x=y */ 25605491d2cSKalle Valo if (nvp->nvram_len < BRCMF_FW_NVRAM_DEVPATH_LEN + 6) 25705491d2cSKalle Valo goto fail; 25805491d2cSKalle Valo 25905491d2cSKalle Valo /* First search for the devpathX and see if it is the configuration 26005491d2cSKalle Valo * for domain_nr/bus_nr. Search complete nvp 26105491d2cSKalle Valo */ 26205491d2cSKalle Valo snprintf(pci_path, sizeof(pci_path), "=pci/%d/%d", domain_nr, 26305491d2cSKalle Valo bus_nr); 26405491d2cSKalle Valo pci_len = strlen(pci_path); 26505491d2cSKalle Valo snprintf(pcie_path, sizeof(pcie_path), "=pcie/%d/%d", domain_nr, 26605491d2cSKalle Valo bus_nr); 26705491d2cSKalle Valo pcie_len = strlen(pcie_path); 26805491d2cSKalle Valo found = false; 26905491d2cSKalle Valo i = 0; 27005491d2cSKalle Valo while (i < nvp->nvram_len - BRCMF_FW_NVRAM_DEVPATH_LEN) { 27105491d2cSKalle Valo /* Format: devpathX=pcie/Y/Z/ 27205491d2cSKalle Valo * Y = domain_nr, Z = bus_nr, X = virtual ID 27305491d2cSKalle Valo */ 27405491d2cSKalle Valo if (strncmp(&nvp->nvram[i], "devpath", 7) == 0 && 27505491d2cSKalle Valo (!strncmp(&nvp->nvram[i + 8], pci_path, pci_len) || 27605491d2cSKalle Valo !strncmp(&nvp->nvram[i + 8], pcie_path, pcie_len))) { 27705491d2cSKalle Valo id = nvp->nvram[i + 7] - '0'; 27805491d2cSKalle Valo found = true; 27905491d2cSKalle Valo break; 28005491d2cSKalle Valo } 28105491d2cSKalle Valo while (nvp->nvram[i] != 0) 28205491d2cSKalle Valo i++; 28305491d2cSKalle Valo i++; 28405491d2cSKalle Valo } 28505491d2cSKalle Valo if (!found) 28605491d2cSKalle Valo goto fail; 28705491d2cSKalle Valo 28805491d2cSKalle Valo /* Now copy all valid entries, release old nvram and assign new one */ 28905491d2cSKalle Valo i = 0; 29005491d2cSKalle Valo j = 0; 29105491d2cSKalle Valo while (i < nvp->nvram_len) { 29205491d2cSKalle Valo if ((nvp->nvram[i] - '0' == id) && (nvp->nvram[i + 1] == ':')) { 29305491d2cSKalle Valo i += 2; 29446f2b38aSHante Meuleman if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0) 29546f2b38aSHante Meuleman nvp->boardrev_found = true; 29605491d2cSKalle Valo while (nvp->nvram[i] != 0) { 29705491d2cSKalle Valo nvram[j] = nvp->nvram[i]; 29805491d2cSKalle Valo i++; 29905491d2cSKalle Valo j++; 30005491d2cSKalle Valo } 30105491d2cSKalle Valo nvram[j] = 0; 30205491d2cSKalle Valo j++; 30305491d2cSKalle Valo } 30405491d2cSKalle Valo while (nvp->nvram[i] != 0) 30505491d2cSKalle Valo i++; 30605491d2cSKalle Valo i++; 30705491d2cSKalle Valo } 30805491d2cSKalle Valo kfree(nvp->nvram); 30905491d2cSKalle Valo nvp->nvram = nvram; 31005491d2cSKalle Valo nvp->nvram_len = j; 31105491d2cSKalle Valo return; 31205491d2cSKalle Valo 31305491d2cSKalle Valo fail: 31405491d2cSKalle Valo kfree(nvram); 31505491d2cSKalle Valo nvp->nvram_len = 0; 31605491d2cSKalle Valo } 31705491d2cSKalle Valo 31805491d2cSKalle Valo /* brcmf_fw_strip_multi_v2 :Some nvram files contain settings for multiple 31905491d2cSKalle Valo * devices. Strip it down for one device, use domain_nr/bus_nr to determine 32005491d2cSKalle Valo * which data is to be returned. v2 is the version where nvram is stored 32105491d2cSKalle Valo * uncompressed, all relevant valid entries are identified by 32205491d2cSKalle Valo * pcie/domain_nr/bus_nr: 32305491d2cSKalle Valo */ 32405491d2cSKalle Valo static void brcmf_fw_strip_multi_v2(struct nvram_parser *nvp, u16 domain_nr, 32505491d2cSKalle Valo u16 bus_nr) 32605491d2cSKalle Valo { 32705491d2cSKalle Valo char prefix[BRCMF_FW_NVRAM_PCIEDEV_LEN]; 32805491d2cSKalle Valo size_t len; 32905491d2cSKalle Valo u32 i, j; 33005491d2cSKalle Valo u8 *nvram; 33105491d2cSKalle Valo 33205491d2cSKalle Valo nvram = kzalloc(nvp->nvram_len + 1 + 3 + sizeof(u32), GFP_KERNEL); 33373c65541SZheng Yongjun if (!nvram) { 33473c65541SZheng Yongjun nvp->nvram_len = 0; 33573c65541SZheng Yongjun return; 33673c65541SZheng Yongjun } 33705491d2cSKalle Valo 33805491d2cSKalle Valo /* Copy all valid entries, release old nvram and assign new one. 33905491d2cSKalle Valo * Valid entries are of type pcie/X/Y/ where X = domain_nr and 34005491d2cSKalle Valo * Y = bus_nr. 34105491d2cSKalle Valo */ 34205491d2cSKalle Valo snprintf(prefix, sizeof(prefix), "pcie/%d/%d/", domain_nr, bus_nr); 34305491d2cSKalle Valo len = strlen(prefix); 34405491d2cSKalle Valo i = 0; 34505491d2cSKalle Valo j = 0; 34605491d2cSKalle Valo while (i < nvp->nvram_len - len) { 34705491d2cSKalle Valo if (strncmp(&nvp->nvram[i], prefix, len) == 0) { 34805491d2cSKalle Valo i += len; 34946f2b38aSHante Meuleman if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0) 35046f2b38aSHante Meuleman nvp->boardrev_found = true; 35105491d2cSKalle Valo while (nvp->nvram[i] != 0) { 35205491d2cSKalle Valo nvram[j] = nvp->nvram[i]; 35305491d2cSKalle Valo i++; 35405491d2cSKalle Valo j++; 35505491d2cSKalle Valo } 35605491d2cSKalle Valo nvram[j] = 0; 35705491d2cSKalle Valo j++; 35805491d2cSKalle Valo } 35905491d2cSKalle Valo while (nvp->nvram[i] != 0) 36005491d2cSKalle Valo i++; 36105491d2cSKalle Valo i++; 36205491d2cSKalle Valo } 36305491d2cSKalle Valo kfree(nvp->nvram); 36405491d2cSKalle Valo nvp->nvram = nvram; 36505491d2cSKalle Valo nvp->nvram_len = j; 36605491d2cSKalle Valo } 36705491d2cSKalle Valo 36846f2b38aSHante Meuleman static void brcmf_fw_add_defaults(struct nvram_parser *nvp) 36946f2b38aSHante Meuleman { 37046f2b38aSHante Meuleman if (nvp->boardrev_found) 37146f2b38aSHante Meuleman return; 37246f2b38aSHante Meuleman 37346f2b38aSHante Meuleman memcpy(&nvp->nvram[nvp->nvram_len], &BRCMF_FW_DEFAULT_BOARDREV, 37446f2b38aSHante Meuleman strlen(BRCMF_FW_DEFAULT_BOARDREV)); 37546f2b38aSHante Meuleman nvp->nvram_len += strlen(BRCMF_FW_DEFAULT_BOARDREV); 37646f2b38aSHante Meuleman nvp->nvram[nvp->nvram_len] = '\0'; 37746f2b38aSHante Meuleman nvp->nvram_len++; 37846f2b38aSHante Meuleman } 37946f2b38aSHante Meuleman 380*687f767dSHector Martin static void brcmf_fw_add_macaddr(struct nvram_parser *nvp, u8 *mac) 381*687f767dSHector Martin { 382*687f767dSHector Martin int len; 383*687f767dSHector Martin 384*687f767dSHector Martin len = scnprintf(&nvp->nvram[nvp->nvram_len], BRCMF_FW_MACADDR_LEN + 1, 385*687f767dSHector Martin BRCMF_FW_MACADDR_FMT, mac); 386*687f767dSHector Martin WARN_ON(len != BRCMF_FW_MACADDR_LEN); 387*687f767dSHector Martin nvp->nvram_len += len + 1; 388*687f767dSHector Martin } 389*687f767dSHector Martin 39005491d2cSKalle Valo /* brcmf_nvram_strip :Takes a buffer of "<var>=<value>\n" lines read from a fil 39105491d2cSKalle Valo * and ending in a NUL. Removes carriage returns, empty lines, comment lines, 39205491d2cSKalle Valo * and converts newlines to NULs. Shortens buffer as needed and pads with NULs. 39305491d2cSKalle Valo * End of buffer is completed with token identifying length of buffer. 39405491d2cSKalle Valo */ 39505491d2cSKalle Valo static void *brcmf_fw_nvram_strip(const u8 *data, size_t data_len, 396*687f767dSHector Martin u32 *new_length, u16 domain_nr, u16 bus_nr, 397*687f767dSHector Martin struct device *dev) 39805491d2cSKalle Valo { 39905491d2cSKalle Valo struct nvram_parser nvp; 40005491d2cSKalle Valo u32 pad; 40105491d2cSKalle Valo u32 token; 40205491d2cSKalle Valo __le32 token_le; 403*687f767dSHector Martin u8 mac[ETH_ALEN]; 40405491d2cSKalle Valo 40505491d2cSKalle Valo if (brcmf_init_nvram_parser(&nvp, data, data_len) < 0) 40605491d2cSKalle Valo return NULL; 40705491d2cSKalle Valo 408*687f767dSHector Martin if (eth_platform_get_mac_address(dev, mac) == 0) 409*687f767dSHector Martin nvp.strip_mac = true; 410*687f767dSHector Martin 41105491d2cSKalle Valo while (nvp.pos < data_len) { 41205491d2cSKalle Valo nvp.state = nv_parser_states[nvp.state](&nvp); 41305491d2cSKalle Valo if (nvp.state == END) 41405491d2cSKalle Valo break; 41505491d2cSKalle Valo } 41646f2b38aSHante Meuleman if (nvp.multi_dev_v1) { 41746f2b38aSHante Meuleman nvp.boardrev_found = false; 41805491d2cSKalle Valo brcmf_fw_strip_multi_v1(&nvp, domain_nr, bus_nr); 41946f2b38aSHante Meuleman } else if (nvp.multi_dev_v2) { 42046f2b38aSHante Meuleman nvp.boardrev_found = false; 42105491d2cSKalle Valo brcmf_fw_strip_multi_v2(&nvp, domain_nr, bus_nr); 42246f2b38aSHante Meuleman } 42305491d2cSKalle Valo 42405491d2cSKalle Valo if (nvp.nvram_len == 0) { 42505491d2cSKalle Valo kfree(nvp.nvram); 42605491d2cSKalle Valo return NULL; 42705491d2cSKalle Valo } 42805491d2cSKalle Valo 42946f2b38aSHante Meuleman brcmf_fw_add_defaults(&nvp); 43046f2b38aSHante Meuleman 431*687f767dSHector Martin if (nvp.strip_mac) 432*687f767dSHector Martin brcmf_fw_add_macaddr(&nvp, mac); 433*687f767dSHector Martin 43405491d2cSKalle Valo pad = nvp.nvram_len; 43505491d2cSKalle Valo *new_length = roundup(nvp.nvram_len + 1, 4); 43605491d2cSKalle Valo while (pad != *new_length) { 43705491d2cSKalle Valo nvp.nvram[pad] = 0; 43805491d2cSKalle Valo pad++; 43905491d2cSKalle Valo } 44005491d2cSKalle Valo 44105491d2cSKalle Valo token = *new_length / 4; 44205491d2cSKalle Valo token = (~token << 16) | (token & 0x0000FFFF); 44305491d2cSKalle Valo token_le = cpu_to_le32(token); 44405491d2cSKalle Valo 44505491d2cSKalle Valo memcpy(&nvp.nvram[*new_length], &token_le, sizeof(token_le)); 44605491d2cSKalle Valo *new_length += sizeof(token_le); 44705491d2cSKalle Valo 44805491d2cSKalle Valo return nvp.nvram; 44905491d2cSKalle Valo } 45005491d2cSKalle Valo 45105491d2cSKalle Valo void brcmf_fw_nvram_free(void *nvram) 45205491d2cSKalle Valo { 45305491d2cSKalle Valo kfree(nvram); 45405491d2cSKalle Valo } 45505491d2cSKalle Valo 45605491d2cSKalle Valo struct brcmf_fw { 45705491d2cSKalle Valo struct device *dev; 458d09ae51aSArend Van Spriel struct brcmf_fw_request *req; 459d09ae51aSArend Van Spriel u32 curpos; 4607cb46e72SHector Martin unsigned int board_index; 461d09ae51aSArend Van Spriel void (*done)(struct device *dev, int err, struct brcmf_fw_request *req); 46205491d2cSKalle Valo }; 46305491d2cSKalle Valo 464ce2e6db5SHans de Goede #ifdef CONFIG_EFI 46529ec3394SHans de Goede /* In some cases the EFI-var stored nvram contains "ccode=ALL" or "ccode=XV" 46629ec3394SHans de Goede * to specify "worldwide" compatible settings, but these 2 ccode-s do not work 46729ec3394SHans de Goede * properly. "ccode=ALL" causes channels 12 and 13 to not be available, 46829ec3394SHans de Goede * "ccode=XV" causes all 5GHz channels to not be available. So we replace both 46929ec3394SHans de Goede * with "ccode=X2" which allows channels 12+13 and 5Ghz channels in 47029ec3394SHans de Goede * no-Initiate-Radiation mode. This means that we will never send on these 47129ec3394SHans de Goede * channels without first having received valid wifi traffic on the channel. 47229ec3394SHans de Goede */ 47329ec3394SHans de Goede static void brcmf_fw_fix_efi_nvram_ccode(char *data, unsigned long data_len) 47429ec3394SHans de Goede { 47529ec3394SHans de Goede char *ccode; 47629ec3394SHans de Goede 47729ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=ALL", data_len); 47829ec3394SHans de Goede if (!ccode) 47929ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=XV\r", data_len); 48029ec3394SHans de Goede if (!ccode) 48129ec3394SHans de Goede return; 48229ec3394SHans de Goede 48329ec3394SHans de Goede ccode[6] = 'X'; 48429ec3394SHans de Goede ccode[7] = '2'; 48529ec3394SHans de Goede ccode[8] = '\r'; 48629ec3394SHans de Goede } 48729ec3394SHans de Goede 488ce2e6db5SHans de Goede static u8 *brcmf_fw_nvram_from_efi(size_t *data_len_ret) 489ce2e6db5SHans de Goede { 49098e152c1SArd Biesheuvel efi_guid_t guid = EFI_GUID(0x74b00bd9, 0x805a, 0x4d61, 0xb5, 0x1f, 49198e152c1SArd Biesheuvel 0x43, 0x26, 0x81, 0x23, 0xd1, 0x13); 492ce2e6db5SHans de Goede unsigned long data_len = 0; 49398e152c1SArd Biesheuvel efi_status_t status; 494ce2e6db5SHans de Goede u8 *data = NULL; 495ce2e6db5SHans de Goede 49698e152c1SArd Biesheuvel if (!efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE)) 497ce2e6db5SHans de Goede return NULL; 498ce2e6db5SHans de Goede 49998e152c1SArd Biesheuvel status = efi.get_variable(L"nvram", &guid, NULL, &data_len, NULL); 50098e152c1SArd Biesheuvel if (status != EFI_BUFFER_TOO_SMALL) 501ce2e6db5SHans de Goede goto fail; 502ce2e6db5SHans de Goede 503ce2e6db5SHans de Goede data = kmalloc(data_len, GFP_KERNEL); 504ce2e6db5SHans de Goede if (!data) 505ce2e6db5SHans de Goede goto fail; 506ce2e6db5SHans de Goede 50798e152c1SArd Biesheuvel status = efi.get_variable(L"nvram", &guid, NULL, &data_len, data); 50898e152c1SArd Biesheuvel if (status != EFI_SUCCESS) 509ce2e6db5SHans de Goede goto fail; 510ce2e6db5SHans de Goede 51129ec3394SHans de Goede brcmf_fw_fix_efi_nvram_ccode(data, data_len); 512ce2e6db5SHans de Goede brcmf_info("Using nvram EFI variable\n"); 513ce2e6db5SHans de Goede 514ce2e6db5SHans de Goede *data_len_ret = data_len; 515ce2e6db5SHans de Goede return data; 516ce2e6db5SHans de Goede fail: 517ce2e6db5SHans de Goede kfree(data); 518ce2e6db5SHans de Goede return NULL; 519ce2e6db5SHans de Goede } 520ce2e6db5SHans de Goede #else 521412dd15cSArnd Bergmann static inline u8 *brcmf_fw_nvram_from_efi(size_t *data_len) { return NULL; } 522ce2e6db5SHans de Goede #endif 523ce2e6db5SHans de Goede 524d09ae51aSArend Van Spriel static void brcmf_fw_free_request(struct brcmf_fw_request *req) 525d09ae51aSArend Van Spriel { 526d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 527d09ae51aSArend Van Spriel int i; 528d09ae51aSArend Van Spriel 529d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 530d09ae51aSArend Van Spriel if (item->type == BRCMF_FW_TYPE_BINARY) 531d09ae51aSArend Van Spriel release_firmware(item->binary); 532d09ae51aSArend Van Spriel else if (item->type == BRCMF_FW_TYPE_NVRAM) 533d09ae51aSArend Van Spriel brcmf_fw_nvram_free(item->nv_data.data); 534d09ae51aSArend Van Spriel } 535d09ae51aSArend Van Spriel kfree(req); 536d09ae51aSArend Van Spriel } 537d09ae51aSArend Van Spriel 5380b5c0305SArend Van Spriel static int brcmf_fw_request_nvram_done(const struct firmware *fw, void *ctx) 53905491d2cSKalle Valo { 54005491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 541d09ae51aSArend Van Spriel struct brcmf_fw_item *cur; 542ce2e6db5SHans de Goede bool free_bcm47xx_nvram = false; 543ce2e6db5SHans de Goede bool kfree_nvram = false; 54405491d2cSKalle Valo u32 nvram_length = 0; 54505491d2cSKalle Valo void *nvram = NULL; 54605491d2cSKalle Valo u8 *data = NULL; 54705491d2cSKalle Valo size_t data_len; 54805491d2cSKalle Valo 54905491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev)); 550d09ae51aSArend Van Spriel 551d09ae51aSArend Van Spriel cur = &fwctx->req->items[fwctx->curpos]; 552d09ae51aSArend Van Spriel 55305491d2cSKalle Valo if (fw && fw->data) { 55405491d2cSKalle Valo data = (u8 *)fw->data; 55505491d2cSKalle Valo data_len = fw->size; 55605491d2cSKalle Valo } else { 557ce2e6db5SHans de Goede if ((data = bcm47xx_nvram_get_contents(&data_len))) 558ce2e6db5SHans de Goede free_bcm47xx_nvram = true; 559ce2e6db5SHans de Goede else if ((data = brcmf_fw_nvram_from_efi(&data_len))) 560ce2e6db5SHans de Goede kfree_nvram = true; 561ce2e6db5SHans de Goede else if (!(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 56205491d2cSKalle Valo goto fail; 56305491d2cSKalle Valo } 56405491d2cSKalle Valo 56505491d2cSKalle Valo if (data) 56605491d2cSKalle Valo nvram = brcmf_fw_nvram_strip(data, data_len, &nvram_length, 567d09ae51aSArend Van Spriel fwctx->req->domain_nr, 568*687f767dSHector Martin fwctx->req->bus_nr, 569*687f767dSHector Martin fwctx->dev); 57005491d2cSKalle Valo 571ce2e6db5SHans de Goede if (free_bcm47xx_nvram) 57205491d2cSKalle Valo bcm47xx_nvram_release_contents(data); 573ce2e6db5SHans de Goede if (kfree_nvram) 574ce2e6db5SHans de Goede kfree(data); 575ce2e6db5SHans de Goede 57605491d2cSKalle Valo release_firmware(fw); 577d09ae51aSArend Van Spriel if (!nvram && !(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 57805491d2cSKalle Valo goto fail; 57905491d2cSKalle Valo 580d09ae51aSArend Van Spriel brcmf_dbg(TRACE, "nvram %p len %d\n", nvram, nvram_length); 581d09ae51aSArend Van Spriel cur->nv_data.data = nvram; 582d09ae51aSArend Van Spriel cur->nv_data.len = nvram_length; 5830b5c0305SArend Van Spriel return 0; 58405491d2cSKalle Valo 58505491d2cSKalle Valo fail: 5860b5c0305SArend Van Spriel return -ENOENT; 58705491d2cSKalle Valo } 58805491d2cSKalle Valo 589a1a3b762SHans de Goede static int brcmf_fw_complete_request(const struct firmware *fw, 590a1a3b762SHans de Goede struct brcmf_fw *fwctx) 591a1a3b762SHans de Goede { 592a1a3b762SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 593a1a3b762SHans de Goede int ret = 0; 594a1a3b762SHans de Goede 595a1a3b762SHans de Goede brcmf_dbg(TRACE, "firmware %s %sfound\n", cur->path, fw ? "" : "not "); 596a1a3b762SHans de Goede 597a1a3b762SHans de Goede switch (cur->type) { 598a1a3b762SHans de Goede case BRCMF_FW_TYPE_NVRAM: 599a1a3b762SHans de Goede ret = brcmf_fw_request_nvram_done(fw, fwctx); 600a1a3b762SHans de Goede break; 601a1a3b762SHans de Goede case BRCMF_FW_TYPE_BINARY: 602a1a3b762SHans de Goede if (fw) 603a1a3b762SHans de Goede cur->binary = fw; 604a1a3b762SHans de Goede else 605a1a3b762SHans de Goede ret = -ENOENT; 606a1a3b762SHans de Goede break; 607a1a3b762SHans de Goede default: 608a1a3b762SHans de Goede /* something fishy here so bail out early */ 609a1a3b762SHans de Goede brcmf_err("unknown fw type: %d\n", cur->type); 610a1a3b762SHans de Goede release_firmware(fw); 611a1a3b762SHans de Goede ret = -EINVAL; 612a1a3b762SHans de Goede } 613a1a3b762SHans de Goede 614a1a3b762SHans de Goede return (cur->flags & BRCMF_FW_REQF_OPTIONAL) ? 0 : ret; 615a1a3b762SHans de Goede } 616a1a3b762SHans de Goede 6175ff01391SLinus Walleij static char *brcm_alt_fw_path(const char *path, const char *board_type) 6185ff01391SLinus Walleij { 619e263d722SHector Martin char base[BRCMF_FW_NAME_LEN]; 620e263d722SHector Martin const char *suffix; 621e263d722SHector Martin char *ret; 6225ff01391SLinus Walleij 623e263d722SHector Martin if (!board_type) 6245ff01391SLinus Walleij return NULL; 6255ff01391SLinus Walleij 626e263d722SHector Martin suffix = strrchr(path, '.'); 627e263d722SHector Martin if (!suffix || suffix == path) 628e263d722SHector Martin return NULL; 6295ff01391SLinus Walleij 630e263d722SHector Martin /* strip extension at the end */ 631e263d722SHector Martin strscpy(base, path, BRCMF_FW_NAME_LEN); 632e263d722SHector Martin base[suffix - path] = 0; 633e263d722SHector Martin 634e263d722SHector Martin ret = kasprintf(GFP_KERNEL, "%s.%s%s", base, board_type, suffix); 635e263d722SHector Martin if (!ret) 636e263d722SHector Martin brcmf_err("out of memory allocating firmware path for '%s'\n", 637e263d722SHector Martin path); 638e263d722SHector Martin 639e263d722SHector Martin brcmf_dbg(TRACE, "FW alt path: %s\n", ret); 640e263d722SHector Martin 641e263d722SHector Martin return ret; 6425ff01391SLinus Walleij } 6435ff01391SLinus Walleij 644eae8e506SHans de Goede static int brcmf_fw_request_firmware(const struct firmware **fw, 645eae8e506SHans de Goede struct brcmf_fw *fwctx) 646eae8e506SHans de Goede { 647eae8e506SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 6487cb46e72SHector Martin unsigned int i; 649eae8e506SHans de Goede int ret; 650eae8e506SHans de Goede 6517cb46e72SHector Martin /* Files can be board-specific, first try board-specific paths */ 6527cb46e72SHector Martin for (i = 0; i < ARRAY_SIZE(fwctx->req->board_types); i++) { 6535ff01391SLinus Walleij char *alt_path; 654eae8e506SHans de Goede 6557cb46e72SHector Martin if (!fwctx->req->board_types[i]) 6567cb46e72SHector Martin goto fallback; 6577cb46e72SHector Martin alt_path = brcm_alt_fw_path(cur->path, 6587cb46e72SHector Martin fwctx->req->board_types[i]); 6595ff01391SLinus Walleij if (!alt_path) 6605ff01391SLinus Walleij goto fallback; 661eae8e506SHans de Goede 6627cb46e72SHector Martin ret = firmware_request_nowarn(fw, alt_path, fwctx->dev); 6635ff01391SLinus Walleij kfree(alt_path); 664eae8e506SHans de Goede if (ret == 0) 665eae8e506SHans de Goede return ret; 666eae8e506SHans de Goede } 667eae8e506SHans de Goede 6685ff01391SLinus Walleij fallback: 669eae8e506SHans de Goede return request_firmware(fw, cur->path, fwctx->dev); 670eae8e506SHans de Goede } 671eae8e506SHans de Goede 672d09ae51aSArend Van Spriel static void brcmf_fw_request_done(const struct firmware *fw, void *ctx) 67305491d2cSKalle Valo { 67405491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 67555e491edSHans de Goede int ret; 676d09ae51aSArend Van Spriel 677a1a3b762SHans de Goede ret = brcmf_fw_complete_request(fw, fwctx); 6780b5c0305SArend Van Spriel 6795b587496SHans de Goede while (ret == 0 && ++fwctx->curpos < fwctx->req->n_items) { 680eae8e506SHans de Goede brcmf_fw_request_firmware(&fw, fwctx); 6815b587496SHans de Goede ret = brcmf_fw_complete_request(fw, ctx); 682d09ae51aSArend Van Spriel } 68303fb0e83SArend Van Spriel 6845b587496SHans de Goede if (ret) { 685d09ae51aSArend Van Spriel brcmf_fw_free_request(fwctx->req); 686d09ae51aSArend Van Spriel fwctx->req = NULL; 6875b587496SHans de Goede } 688d09ae51aSArend Van Spriel fwctx->done(fwctx->dev, ret, fwctx->req); 68905491d2cSKalle Valo kfree(fwctx); 69005491d2cSKalle Valo } 69105491d2cSKalle Valo 692c2dac3d2SLinus Walleij static void brcmf_fw_request_done_alt_path(const struct firmware *fw, void *ctx) 693c2dac3d2SLinus Walleij { 694c2dac3d2SLinus Walleij struct brcmf_fw *fwctx = ctx; 695c2dac3d2SLinus Walleij struct brcmf_fw_item *first = &fwctx->req->items[0]; 6967cb46e72SHector Martin const char *board_type, *alt_path; 697c2dac3d2SLinus Walleij int ret = 0; 698c2dac3d2SLinus Walleij 6997cb46e72SHector Martin if (fw) { 7007cb46e72SHector Martin brcmf_fw_request_done(fw, ctx); 7017cb46e72SHector Martin return; 7027cb46e72SHector Martin } 7037cb46e72SHector Martin 7047cb46e72SHector Martin /* Try next board firmware */ 7057cb46e72SHector Martin if (fwctx->board_index < ARRAY_SIZE(fwctx->req->board_types)) { 7067cb46e72SHector Martin board_type = fwctx->req->board_types[fwctx->board_index++]; 7077cb46e72SHector Martin if (!board_type) 7087cb46e72SHector Martin goto fallback; 7097cb46e72SHector Martin alt_path = brcm_alt_fw_path(first->path, board_type); 7107cb46e72SHector Martin if (!alt_path) 7117cb46e72SHector Martin goto fallback; 7127cb46e72SHector Martin 7137cb46e72SHector Martin ret = request_firmware_nowait(THIS_MODULE, true, alt_path, 7147cb46e72SHector Martin fwctx->dev, GFP_KERNEL, fwctx, 7157cb46e72SHector Martin brcmf_fw_request_done_alt_path); 7167cb46e72SHector Martin kfree(alt_path); 7177cb46e72SHector Martin 7187cb46e72SHector Martin if (ret < 0) 7197cb46e72SHector Martin brcmf_fw_request_done(fw, ctx); 7207cb46e72SHector Martin return; 7217cb46e72SHector Martin } 7227cb46e72SHector Martin 7237cb46e72SHector Martin fallback: 724c2dac3d2SLinus Walleij /* Fall back to canonical path if board firmware not found */ 725c2dac3d2SLinus Walleij ret = request_firmware_nowait(THIS_MODULE, true, first->path, 726c2dac3d2SLinus Walleij fwctx->dev, GFP_KERNEL, fwctx, 727c2dac3d2SLinus Walleij brcmf_fw_request_done); 728c2dac3d2SLinus Walleij 7297cb46e72SHector Martin if (ret < 0) 730c2dac3d2SLinus Walleij brcmf_fw_request_done(fw, ctx); 731c2dac3d2SLinus Walleij } 732c2dac3d2SLinus Walleij 733d09ae51aSArend Van Spriel static bool brcmf_fw_request_is_valid(struct brcmf_fw_request *req) 734d09ae51aSArend Van Spriel { 735d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 736d09ae51aSArend Van Spriel int i; 737d09ae51aSArend Van Spriel 738d09ae51aSArend Van Spriel if (!req->n_items) 739d09ae51aSArend Van Spriel return false; 740d09ae51aSArend Van Spriel 741d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 742d09ae51aSArend Van Spriel if (!item->path) 743d09ae51aSArend Van Spriel return false; 744d09ae51aSArend Van Spriel } 745d09ae51aSArend Van Spriel return true; 746d09ae51aSArend Van Spriel } 747d09ae51aSArend Van Spriel 748d09ae51aSArend Van Spriel int brcmf_fw_get_firmwares(struct device *dev, struct brcmf_fw_request *req, 7496d0507a7SArend Van Spriel void (*fw_cb)(struct device *dev, int err, 750d09ae51aSArend Van Spriel struct brcmf_fw_request *req)) 75105491d2cSKalle Valo { 7525b587496SHans de Goede struct brcmf_fw_item *first = &req->items[0]; 75305491d2cSKalle Valo struct brcmf_fw *fwctx; 754665408f4SPhil Elwell char *alt_path = NULL; 7555b587496SHans de Goede int ret; 75605491d2cSKalle Valo 75705491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(dev)); 758d09ae51aSArend Van Spriel if (!fw_cb) 75905491d2cSKalle Valo return -EINVAL; 76005491d2cSKalle Valo 761d09ae51aSArend Van Spriel if (!brcmf_fw_request_is_valid(req)) 76205491d2cSKalle Valo return -EINVAL; 76305491d2cSKalle Valo 76405491d2cSKalle Valo fwctx = kzalloc(sizeof(*fwctx), GFP_KERNEL); 76505491d2cSKalle Valo if (!fwctx) 76605491d2cSKalle Valo return -ENOMEM; 76705491d2cSKalle Valo 76805491d2cSKalle Valo fwctx->dev = dev; 769d09ae51aSArend Van Spriel fwctx->req = req; 77005491d2cSKalle Valo fwctx->done = fw_cb; 77105491d2cSKalle Valo 7725ff01391SLinus Walleij /* First try alternative board-specific path if any */ 7737cb46e72SHector Martin if (fwctx->req->board_types[0]) 774665408f4SPhil Elwell alt_path = brcm_alt_fw_path(first->path, 7757cb46e72SHector Martin fwctx->req->board_types[0]); 7765ff01391SLinus Walleij if (alt_path) { 7777cb46e72SHector Martin fwctx->board_index++; 7785ff01391SLinus Walleij ret = request_firmware_nowait(THIS_MODULE, true, alt_path, 7795ff01391SLinus Walleij fwctx->dev, GFP_KERNEL, fwctx, 780c2dac3d2SLinus Walleij brcmf_fw_request_done_alt_path); 7815ff01391SLinus Walleij kfree(alt_path); 782c2dac3d2SLinus Walleij } else { 7835b587496SHans de Goede ret = request_firmware_nowait(THIS_MODULE, true, first->path, 7845b587496SHans de Goede fwctx->dev, GFP_KERNEL, fwctx, 7855b587496SHans de Goede brcmf_fw_request_done); 7865ff01391SLinus Walleij } 7875b587496SHans de Goede if (ret < 0) 7885b587496SHans de Goede brcmf_fw_request_done(NULL, fwctx); 7895b587496SHans de Goede 790d09ae51aSArend Van Spriel return 0; 79105491d2cSKalle Valo } 79205491d2cSKalle Valo 7932baa3aaeSArend Van Spriel struct brcmf_fw_request * 7942baa3aaeSArend Van Spriel brcmf_fw_alloc_request(u32 chip, u32 chiprev, 795ff68c9f9SArend Van Spriel const struct brcmf_firmware_mapping mapping_table[], 7962baa3aaeSArend Van Spriel u32 table_size, struct brcmf_fw_name *fwnames, 7972baa3aaeSArend Van Spriel u32 n_fwnames) 7982baa3aaeSArend Van Spriel { 7992baa3aaeSArend Van Spriel struct brcmf_fw_request *fwreq; 8002baa3aaeSArend Van Spriel char chipname[12]; 8012baa3aaeSArend Van Spriel const char *mp_path; 802b72c51a5SLyude Paul size_t mp_path_len; 8032baa3aaeSArend Van Spriel u32 i, j; 804b72c51a5SLyude Paul char end = '\0'; 8052baa3aaeSArend Van Spriel 8062baa3aaeSArend Van Spriel for (i = 0; i < table_size; i++) { 8072baa3aaeSArend Van Spriel if (mapping_table[i].chipid == chip && 8082baa3aaeSArend Van Spriel mapping_table[i].revmask & BIT(chiprev)) 8092baa3aaeSArend Van Spriel break; 8102baa3aaeSArend Van Spriel } 8112baa3aaeSArend Van Spriel 812a250c91cSArend van Spriel brcmf_chip_name(chip, chiprev, chipname, sizeof(chipname)); 813a250c91cSArend van Spriel 8142baa3aaeSArend Van Spriel if (i == table_size) { 815a250c91cSArend van Spriel brcmf_err("Unknown chip %s\n", chipname); 8162baa3aaeSArend Van Spriel return NULL; 8172baa3aaeSArend Van Spriel } 8182baa3aaeSArend Van Spriel 8190cf83903SGustavo A. R. Silva fwreq = kzalloc(struct_size(fwreq, items, n_fwnames), GFP_KERNEL); 8202baa3aaeSArend Van Spriel if (!fwreq) 8212baa3aaeSArend Van Spriel return NULL; 8222baa3aaeSArend Van Spriel 8232baa3aaeSArend Van Spriel brcmf_info("using %s for chip %s\n", 8242baa3aaeSArend Van Spriel mapping_table[i].fw_base, chipname); 8252baa3aaeSArend Van Spriel 8262baa3aaeSArend Van Spriel mp_path = brcmf_mp_global.firmware_path; 827b72c51a5SLyude Paul mp_path_len = strnlen(mp_path, BRCMF_FW_ALTPATH_LEN); 828b72c51a5SLyude Paul if (mp_path_len) 829b72c51a5SLyude Paul end = mp_path[mp_path_len - 1]; 830b72c51a5SLyude Paul 8312baa3aaeSArend Van Spriel fwreq->n_items = n_fwnames; 8322baa3aaeSArend Van Spriel 8332baa3aaeSArend Van Spriel for (j = 0; j < n_fwnames; j++) { 8342baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 835c9692820SRafał Miłecki fwnames[j].path[0] = '\0'; 8362baa3aaeSArend Van Spriel /* check if firmware path is provided by module parameter */ 8372baa3aaeSArend Van Spriel if (brcmf_mp_global.firmware_path[0] != '\0') { 838bf99f11dSWolfram Sang strscpy(fwnames[j].path, mp_path, 8392baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 8402baa3aaeSArend Van Spriel 8412baa3aaeSArend Van Spriel if (end != '/') { 8422baa3aaeSArend Van Spriel strlcat(fwnames[j].path, "/", 8432baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 8442baa3aaeSArend Van Spriel } 8452baa3aaeSArend Van Spriel } 846bf291b72SArend Van Spriel strlcat(fwnames[j].path, mapping_table[i].fw_base, 847bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 848bf291b72SArend Van Spriel strlcat(fwnames[j].path, fwnames[j].extension, 849bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 8502baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 8512baa3aaeSArend Van Spriel } 8522baa3aaeSArend Van Spriel 8532baa3aaeSArend Van Spriel return fwreq; 8542baa3aaeSArend Van Spriel } 855