105491d2cSKalle Valo /* 205491d2cSKalle Valo * Copyright (c) 2013 Broadcom Corporation 305491d2cSKalle Valo * 405491d2cSKalle Valo * Permission to use, copy, modify, and/or distribute this software for any 505491d2cSKalle Valo * purpose with or without fee is hereby granted, provided that the above 605491d2cSKalle Valo * copyright notice and this permission notice appear in all copies. 705491d2cSKalle Valo * 805491d2cSKalle Valo * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 905491d2cSKalle Valo * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 1005491d2cSKalle Valo * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 1105491d2cSKalle Valo * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 1205491d2cSKalle Valo * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 1305491d2cSKalle Valo * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 1405491d2cSKalle Valo * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 1505491d2cSKalle Valo */ 1605491d2cSKalle Valo 17ce2e6db5SHans de Goede #include <linux/efi.h> 1805491d2cSKalle Valo #include <linux/kernel.h> 1905491d2cSKalle Valo #include <linux/slab.h> 2005491d2cSKalle Valo #include <linux/device.h> 2105491d2cSKalle Valo #include <linux/firmware.h> 2205491d2cSKalle Valo #include <linux/module.h> 2305491d2cSKalle Valo #include <linux/bcm47xx_nvram.h> 2405491d2cSKalle Valo 2505491d2cSKalle Valo #include "debug.h" 2605491d2cSKalle Valo #include "firmware.h" 277d34b056SHante Meuleman #include "core.h" 287d34b056SHante Meuleman #include "common.h" 29c88cfa07SArend Van Spriel #include "chip.h" 3005491d2cSKalle Valo 3105491d2cSKalle Valo #define BRCMF_FW_MAX_NVRAM_SIZE 64000 3205491d2cSKalle Valo #define BRCMF_FW_NVRAM_DEVPATH_LEN 19 /* devpath0=pcie/1/4/ */ 3305491d2cSKalle Valo #define BRCMF_FW_NVRAM_PCIEDEV_LEN 10 /* pcie/1/4/ + \0 */ 3446f2b38aSHante Meuleman #define BRCMF_FW_DEFAULT_BOARDREV "boardrev=0xff" 3505491d2cSKalle Valo 3605491d2cSKalle Valo enum nvram_parser_state { 3705491d2cSKalle Valo IDLE, 3805491d2cSKalle Valo KEY, 3905491d2cSKalle Valo VALUE, 4005491d2cSKalle Valo COMMENT, 4105491d2cSKalle Valo END 4205491d2cSKalle Valo }; 4305491d2cSKalle Valo 4405491d2cSKalle Valo /** 4505491d2cSKalle Valo * struct nvram_parser - internal info for parser. 4605491d2cSKalle Valo * 4705491d2cSKalle Valo * @state: current parser state. 4805491d2cSKalle Valo * @data: input buffer being parsed. 4905491d2cSKalle Valo * @nvram: output buffer with parse result. 5005491d2cSKalle Valo * @nvram_len: lenght of parse result. 5105491d2cSKalle Valo * @line: current line. 5205491d2cSKalle Valo * @column: current column in line. 5305491d2cSKalle Valo * @pos: byte offset in input buffer. 5405491d2cSKalle Valo * @entry: start position of key,value entry. 5505491d2cSKalle Valo * @multi_dev_v1: detect pcie multi device v1 (compressed). 5605491d2cSKalle Valo * @multi_dev_v2: detect pcie multi device v2. 5746f2b38aSHante Meuleman * @boardrev_found: nvram contains boardrev information. 5805491d2cSKalle Valo */ 5905491d2cSKalle Valo struct nvram_parser { 6005491d2cSKalle Valo enum nvram_parser_state state; 6105491d2cSKalle Valo const u8 *data; 6205491d2cSKalle Valo u8 *nvram; 6305491d2cSKalle Valo u32 nvram_len; 6405491d2cSKalle Valo u32 line; 6505491d2cSKalle Valo u32 column; 6605491d2cSKalle Valo u32 pos; 6705491d2cSKalle Valo u32 entry; 6805491d2cSKalle Valo bool multi_dev_v1; 6905491d2cSKalle Valo bool multi_dev_v2; 7046f2b38aSHante Meuleman bool boardrev_found; 7105491d2cSKalle Valo }; 7205491d2cSKalle Valo 7305491d2cSKalle Valo /** 7405491d2cSKalle Valo * is_nvram_char() - check if char is a valid one for NVRAM entry 7505491d2cSKalle Valo * 7605491d2cSKalle Valo * It accepts all printable ASCII chars except for '#' which opens a comment. 7705491d2cSKalle Valo * Please note that ' ' (space) while accepted is not a valid key name char. 7805491d2cSKalle Valo */ 7905491d2cSKalle Valo static bool is_nvram_char(char c) 8005491d2cSKalle Valo { 8105491d2cSKalle Valo /* comment marker excluded */ 8205491d2cSKalle Valo if (c == '#') 8305491d2cSKalle Valo return false; 8405491d2cSKalle Valo 8505491d2cSKalle Valo /* key and value may have any other readable character */ 8605491d2cSKalle Valo return (c >= 0x20 && c < 0x7f); 8705491d2cSKalle Valo } 8805491d2cSKalle Valo 8905491d2cSKalle Valo static bool is_whitespace(char c) 9005491d2cSKalle Valo { 9105491d2cSKalle Valo return (c == ' ' || c == '\r' || c == '\n' || c == '\t'); 9205491d2cSKalle Valo } 9305491d2cSKalle Valo 9405491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_idle(struct nvram_parser *nvp) 9505491d2cSKalle Valo { 9605491d2cSKalle Valo char c; 9705491d2cSKalle Valo 9805491d2cSKalle Valo c = nvp->data[nvp->pos]; 9905491d2cSKalle Valo if (c == '\n') 10005491d2cSKalle Valo return COMMENT; 101d1e61b86SRafał Miłecki if (is_whitespace(c) || c == '\0') 10205491d2cSKalle Valo goto proceed; 10305491d2cSKalle Valo if (c == '#') 10405491d2cSKalle Valo return COMMENT; 10505491d2cSKalle Valo if (is_nvram_char(c)) { 10605491d2cSKalle Valo nvp->entry = nvp->pos; 10705491d2cSKalle Valo return KEY; 10805491d2cSKalle Valo } 10905491d2cSKalle Valo brcmf_dbg(INFO, "warning: ln=%d:col=%d: ignoring invalid character\n", 11005491d2cSKalle Valo nvp->line, nvp->column); 11105491d2cSKalle Valo proceed: 11205491d2cSKalle Valo nvp->column++; 11305491d2cSKalle Valo nvp->pos++; 11405491d2cSKalle Valo return IDLE; 11505491d2cSKalle Valo } 11605491d2cSKalle Valo 11705491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_key(struct nvram_parser *nvp) 11805491d2cSKalle Valo { 11905491d2cSKalle Valo enum nvram_parser_state st = nvp->state; 12005491d2cSKalle Valo char c; 12105491d2cSKalle Valo 12205491d2cSKalle Valo c = nvp->data[nvp->pos]; 12305491d2cSKalle Valo if (c == '=') { 12405491d2cSKalle Valo /* ignore RAW1 by treating as comment */ 12505491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "RAW1", 4) == 0) 12605491d2cSKalle Valo st = COMMENT; 12705491d2cSKalle Valo else 12805491d2cSKalle Valo st = VALUE; 12905491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "devpath", 7) == 0) 13005491d2cSKalle Valo nvp->multi_dev_v1 = true; 13105491d2cSKalle Valo if (strncmp(&nvp->data[nvp->entry], "pcie/", 5) == 0) 13205491d2cSKalle Valo nvp->multi_dev_v2 = true; 13346f2b38aSHante Meuleman if (strncmp(&nvp->data[nvp->entry], "boardrev", 8) == 0) 13446f2b38aSHante Meuleman nvp->boardrev_found = true; 13505491d2cSKalle Valo } else if (!is_nvram_char(c) || c == ' ') { 13605491d2cSKalle Valo brcmf_dbg(INFO, "warning: ln=%d:col=%d: '=' expected, skip invalid key entry\n", 13705491d2cSKalle Valo nvp->line, nvp->column); 13805491d2cSKalle Valo return COMMENT; 13905491d2cSKalle Valo } 14005491d2cSKalle Valo 14105491d2cSKalle Valo nvp->column++; 14205491d2cSKalle Valo nvp->pos++; 14305491d2cSKalle Valo return st; 14405491d2cSKalle Valo } 14505491d2cSKalle Valo 14605491d2cSKalle Valo static enum nvram_parser_state 14705491d2cSKalle Valo brcmf_nvram_handle_value(struct nvram_parser *nvp) 14805491d2cSKalle Valo { 14905491d2cSKalle Valo char c; 15005491d2cSKalle Valo char *skv; 15105491d2cSKalle Valo char *ekv; 15205491d2cSKalle Valo u32 cplen; 15305491d2cSKalle Valo 15405491d2cSKalle Valo c = nvp->data[nvp->pos]; 15505491d2cSKalle Valo if (!is_nvram_char(c)) { 15605491d2cSKalle Valo /* key,value pair complete */ 15705491d2cSKalle Valo ekv = (u8 *)&nvp->data[nvp->pos]; 15805491d2cSKalle Valo skv = (u8 *)&nvp->data[nvp->entry]; 15905491d2cSKalle Valo cplen = ekv - skv; 16005491d2cSKalle Valo if (nvp->nvram_len + cplen + 1 >= BRCMF_FW_MAX_NVRAM_SIZE) 16105491d2cSKalle Valo return END; 16205491d2cSKalle Valo /* copy to output buffer */ 16305491d2cSKalle Valo memcpy(&nvp->nvram[nvp->nvram_len], skv, cplen); 16405491d2cSKalle Valo nvp->nvram_len += cplen; 16505491d2cSKalle Valo nvp->nvram[nvp->nvram_len] = '\0'; 16605491d2cSKalle Valo nvp->nvram_len++; 16705491d2cSKalle Valo return IDLE; 16805491d2cSKalle Valo } 16905491d2cSKalle Valo nvp->pos++; 17005491d2cSKalle Valo nvp->column++; 17105491d2cSKalle Valo return VALUE; 17205491d2cSKalle Valo } 17305491d2cSKalle Valo 17405491d2cSKalle Valo static enum nvram_parser_state 17505491d2cSKalle Valo brcmf_nvram_handle_comment(struct nvram_parser *nvp) 17605491d2cSKalle Valo { 17705491d2cSKalle Valo char *eoc, *sol; 17805491d2cSKalle Valo 17905491d2cSKalle Valo sol = (char *)&nvp->data[nvp->pos]; 18005491d2cSKalle Valo eoc = strchr(sol, '\n'); 18105491d2cSKalle Valo if (!eoc) { 18205491d2cSKalle Valo eoc = strchr(sol, '\0'); 18305491d2cSKalle Valo if (!eoc) 18405491d2cSKalle Valo return END; 18505491d2cSKalle Valo } 18605491d2cSKalle Valo 18705491d2cSKalle Valo /* eat all moving to next line */ 18805491d2cSKalle Valo nvp->line++; 18905491d2cSKalle Valo nvp->column = 1; 19005491d2cSKalle Valo nvp->pos += (eoc - sol) + 1; 19105491d2cSKalle Valo return IDLE; 19205491d2cSKalle Valo } 19305491d2cSKalle Valo 19405491d2cSKalle Valo static enum nvram_parser_state brcmf_nvram_handle_end(struct nvram_parser *nvp) 19505491d2cSKalle Valo { 19605491d2cSKalle Valo /* final state */ 19705491d2cSKalle Valo return END; 19805491d2cSKalle Valo } 19905491d2cSKalle Valo 20005491d2cSKalle Valo static enum nvram_parser_state 20105491d2cSKalle Valo (*nv_parser_states[])(struct nvram_parser *nvp) = { 20205491d2cSKalle Valo brcmf_nvram_handle_idle, 20305491d2cSKalle Valo brcmf_nvram_handle_key, 20405491d2cSKalle Valo brcmf_nvram_handle_value, 20505491d2cSKalle Valo brcmf_nvram_handle_comment, 20605491d2cSKalle Valo brcmf_nvram_handle_end 20705491d2cSKalle Valo }; 20805491d2cSKalle Valo 20905491d2cSKalle Valo static int brcmf_init_nvram_parser(struct nvram_parser *nvp, 21005491d2cSKalle Valo const u8 *data, size_t data_len) 21105491d2cSKalle Valo { 21205491d2cSKalle Valo size_t size; 21305491d2cSKalle Valo 21405491d2cSKalle Valo memset(nvp, 0, sizeof(*nvp)); 21505491d2cSKalle Valo nvp->data = data; 21605491d2cSKalle Valo /* Limit size to MAX_NVRAM_SIZE, some files contain lot of comment */ 21705491d2cSKalle Valo if (data_len > BRCMF_FW_MAX_NVRAM_SIZE) 21805491d2cSKalle Valo size = BRCMF_FW_MAX_NVRAM_SIZE; 21905491d2cSKalle Valo else 22005491d2cSKalle Valo size = data_len; 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); 33305491d2cSKalle Valo if (!nvram) 33405491d2cSKalle Valo goto fail; 33505491d2cSKalle Valo 33605491d2cSKalle Valo /* Copy all valid entries, release old nvram and assign new one. 33705491d2cSKalle Valo * Valid entries are of type pcie/X/Y/ where X = domain_nr and 33805491d2cSKalle Valo * Y = bus_nr. 33905491d2cSKalle Valo */ 34005491d2cSKalle Valo snprintf(prefix, sizeof(prefix), "pcie/%d/%d/", domain_nr, bus_nr); 34105491d2cSKalle Valo len = strlen(prefix); 34205491d2cSKalle Valo i = 0; 34305491d2cSKalle Valo j = 0; 34405491d2cSKalle Valo while (i < nvp->nvram_len - len) { 34505491d2cSKalle Valo if (strncmp(&nvp->nvram[i], prefix, len) == 0) { 34605491d2cSKalle Valo i += len; 34746f2b38aSHante Meuleman if (strncmp(&nvp->nvram[i], "boardrev", 8) == 0) 34846f2b38aSHante Meuleman nvp->boardrev_found = true; 34905491d2cSKalle Valo while (nvp->nvram[i] != 0) { 35005491d2cSKalle Valo nvram[j] = nvp->nvram[i]; 35105491d2cSKalle Valo i++; 35205491d2cSKalle Valo j++; 35305491d2cSKalle Valo } 35405491d2cSKalle Valo nvram[j] = 0; 35505491d2cSKalle Valo j++; 35605491d2cSKalle Valo } 35705491d2cSKalle Valo while (nvp->nvram[i] != 0) 35805491d2cSKalle Valo i++; 35905491d2cSKalle Valo i++; 36005491d2cSKalle Valo } 36105491d2cSKalle Valo kfree(nvp->nvram); 36205491d2cSKalle Valo nvp->nvram = nvram; 36305491d2cSKalle Valo nvp->nvram_len = j; 36405491d2cSKalle Valo return; 36505491d2cSKalle Valo fail: 36605491d2cSKalle Valo kfree(nvram); 36705491d2cSKalle Valo nvp->nvram_len = 0; 36805491d2cSKalle Valo } 36905491d2cSKalle Valo 37046f2b38aSHante Meuleman static void brcmf_fw_add_defaults(struct nvram_parser *nvp) 37146f2b38aSHante Meuleman { 37246f2b38aSHante Meuleman if (nvp->boardrev_found) 37346f2b38aSHante Meuleman return; 37446f2b38aSHante Meuleman 37546f2b38aSHante Meuleman memcpy(&nvp->nvram[nvp->nvram_len], &BRCMF_FW_DEFAULT_BOARDREV, 37646f2b38aSHante Meuleman strlen(BRCMF_FW_DEFAULT_BOARDREV)); 37746f2b38aSHante Meuleman nvp->nvram_len += strlen(BRCMF_FW_DEFAULT_BOARDREV); 37846f2b38aSHante Meuleman nvp->nvram[nvp->nvram_len] = '\0'; 37946f2b38aSHante Meuleman nvp->nvram_len++; 38046f2b38aSHante Meuleman } 38146f2b38aSHante Meuleman 38205491d2cSKalle Valo /* brcmf_nvram_strip :Takes a buffer of "<var>=<value>\n" lines read from a fil 38305491d2cSKalle Valo * and ending in a NUL. Removes carriage returns, empty lines, comment lines, 38405491d2cSKalle Valo * and converts newlines to NULs. Shortens buffer as needed and pads with NULs. 38505491d2cSKalle Valo * End of buffer is completed with token identifying length of buffer. 38605491d2cSKalle Valo */ 38705491d2cSKalle Valo static void *brcmf_fw_nvram_strip(const u8 *data, size_t data_len, 38805491d2cSKalle Valo u32 *new_length, u16 domain_nr, u16 bus_nr) 38905491d2cSKalle Valo { 39005491d2cSKalle Valo struct nvram_parser nvp; 39105491d2cSKalle Valo u32 pad; 39205491d2cSKalle Valo u32 token; 39305491d2cSKalle Valo __le32 token_le; 39405491d2cSKalle Valo 39505491d2cSKalle Valo if (brcmf_init_nvram_parser(&nvp, data, data_len) < 0) 39605491d2cSKalle Valo return NULL; 39705491d2cSKalle Valo 39805491d2cSKalle Valo while (nvp.pos < data_len) { 39905491d2cSKalle Valo nvp.state = nv_parser_states[nvp.state](&nvp); 40005491d2cSKalle Valo if (nvp.state == END) 40105491d2cSKalle Valo break; 40205491d2cSKalle Valo } 40346f2b38aSHante Meuleman if (nvp.multi_dev_v1) { 40446f2b38aSHante Meuleman nvp.boardrev_found = false; 40505491d2cSKalle Valo brcmf_fw_strip_multi_v1(&nvp, domain_nr, bus_nr); 40646f2b38aSHante Meuleman } else if (nvp.multi_dev_v2) { 40746f2b38aSHante Meuleman nvp.boardrev_found = false; 40805491d2cSKalle Valo brcmf_fw_strip_multi_v2(&nvp, domain_nr, bus_nr); 40946f2b38aSHante Meuleman } 41005491d2cSKalle Valo 41105491d2cSKalle Valo if (nvp.nvram_len == 0) { 41205491d2cSKalle Valo kfree(nvp.nvram); 41305491d2cSKalle Valo return NULL; 41405491d2cSKalle Valo } 41505491d2cSKalle Valo 41646f2b38aSHante Meuleman brcmf_fw_add_defaults(&nvp); 41746f2b38aSHante Meuleman 41805491d2cSKalle Valo pad = nvp.nvram_len; 41905491d2cSKalle Valo *new_length = roundup(nvp.nvram_len + 1, 4); 42005491d2cSKalle Valo while (pad != *new_length) { 42105491d2cSKalle Valo nvp.nvram[pad] = 0; 42205491d2cSKalle Valo pad++; 42305491d2cSKalle Valo } 42405491d2cSKalle Valo 42505491d2cSKalle Valo token = *new_length / 4; 42605491d2cSKalle Valo token = (~token << 16) | (token & 0x0000FFFF); 42705491d2cSKalle Valo token_le = cpu_to_le32(token); 42805491d2cSKalle Valo 42905491d2cSKalle Valo memcpy(&nvp.nvram[*new_length], &token_le, sizeof(token_le)); 43005491d2cSKalle Valo *new_length += sizeof(token_le); 43105491d2cSKalle Valo 43205491d2cSKalle Valo return nvp.nvram; 43305491d2cSKalle Valo } 43405491d2cSKalle Valo 43505491d2cSKalle Valo void brcmf_fw_nvram_free(void *nvram) 43605491d2cSKalle Valo { 43705491d2cSKalle Valo kfree(nvram); 43805491d2cSKalle Valo } 43905491d2cSKalle Valo 44005491d2cSKalle Valo struct brcmf_fw { 44105491d2cSKalle Valo struct device *dev; 442d09ae51aSArend Van Spriel struct brcmf_fw_request *req; 443d09ae51aSArend Van Spriel u32 curpos; 444d09ae51aSArend Van Spriel void (*done)(struct device *dev, int err, struct brcmf_fw_request *req); 44505491d2cSKalle Valo }; 44605491d2cSKalle Valo 447d09ae51aSArend Van Spriel static void brcmf_fw_request_done(const struct firmware *fw, void *ctx); 448d09ae51aSArend Van Spriel 449ce2e6db5SHans de Goede #ifdef CONFIG_EFI 45029ec3394SHans de Goede /* In some cases the EFI-var stored nvram contains "ccode=ALL" or "ccode=XV" 45129ec3394SHans de Goede * to specify "worldwide" compatible settings, but these 2 ccode-s do not work 45229ec3394SHans de Goede * properly. "ccode=ALL" causes channels 12 and 13 to not be available, 45329ec3394SHans de Goede * "ccode=XV" causes all 5GHz channels to not be available. So we replace both 45429ec3394SHans de Goede * with "ccode=X2" which allows channels 12+13 and 5Ghz channels in 45529ec3394SHans de Goede * no-Initiate-Radiation mode. This means that we will never send on these 45629ec3394SHans de Goede * channels without first having received valid wifi traffic on the channel. 45729ec3394SHans de Goede */ 45829ec3394SHans de Goede static void brcmf_fw_fix_efi_nvram_ccode(char *data, unsigned long data_len) 45929ec3394SHans de Goede { 46029ec3394SHans de Goede char *ccode; 46129ec3394SHans de Goede 46229ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=ALL", data_len); 46329ec3394SHans de Goede if (!ccode) 46429ec3394SHans de Goede ccode = strnstr((char *)data, "ccode=XV\r", data_len); 46529ec3394SHans de Goede if (!ccode) 46629ec3394SHans de Goede return; 46729ec3394SHans de Goede 46829ec3394SHans de Goede ccode[6] = 'X'; 46929ec3394SHans de Goede ccode[7] = '2'; 47029ec3394SHans de Goede ccode[8] = '\r'; 47129ec3394SHans de Goede } 47229ec3394SHans de Goede 473ce2e6db5SHans de Goede static u8 *brcmf_fw_nvram_from_efi(size_t *data_len_ret) 474ce2e6db5SHans de Goede { 475ce2e6db5SHans de Goede const u16 name[] = { 'n', 'v', 'r', 'a', 'm', 0 }; 476ce2e6db5SHans de Goede struct efivar_entry *nvram_efivar; 477ce2e6db5SHans de Goede unsigned long data_len = 0; 478ce2e6db5SHans de Goede u8 *data = NULL; 479ce2e6db5SHans de Goede int err; 480ce2e6db5SHans de Goede 481ce2e6db5SHans de Goede nvram_efivar = kzalloc(sizeof(*nvram_efivar), GFP_KERNEL); 482ce2e6db5SHans de Goede if (!nvram_efivar) 483ce2e6db5SHans de Goede return NULL; 484ce2e6db5SHans de Goede 485ce2e6db5SHans de Goede memcpy(&nvram_efivar->var.VariableName, name, sizeof(name)); 486ce2e6db5SHans de Goede nvram_efivar->var.VendorGuid = EFI_GUID(0x74b00bd9, 0x805a, 0x4d61, 487ce2e6db5SHans de Goede 0xb5, 0x1f, 0x43, 0x26, 488ce2e6db5SHans de Goede 0x81, 0x23, 0xd1, 0x13); 489ce2e6db5SHans de Goede 490ce2e6db5SHans de Goede err = efivar_entry_size(nvram_efivar, &data_len); 491ce2e6db5SHans de Goede if (err) 492ce2e6db5SHans de Goede goto fail; 493ce2e6db5SHans de Goede 494ce2e6db5SHans de Goede data = kmalloc(data_len, GFP_KERNEL); 495ce2e6db5SHans de Goede if (!data) 496ce2e6db5SHans de Goede goto fail; 497ce2e6db5SHans de Goede 498ce2e6db5SHans de Goede err = efivar_entry_get(nvram_efivar, NULL, &data_len, data); 499ce2e6db5SHans de Goede if (err) 500ce2e6db5SHans de Goede goto fail; 501ce2e6db5SHans de Goede 50229ec3394SHans de Goede brcmf_fw_fix_efi_nvram_ccode(data, data_len); 503ce2e6db5SHans de Goede brcmf_info("Using nvram EFI variable\n"); 504ce2e6db5SHans de Goede 505ce2e6db5SHans de Goede kfree(nvram_efivar); 506ce2e6db5SHans de Goede *data_len_ret = data_len; 507ce2e6db5SHans de Goede return data; 508ce2e6db5SHans de Goede 509ce2e6db5SHans de Goede fail: 510ce2e6db5SHans de Goede kfree(data); 511ce2e6db5SHans de Goede kfree(nvram_efivar); 512ce2e6db5SHans de Goede return NULL; 513ce2e6db5SHans de Goede } 514ce2e6db5SHans de Goede #else 515ce2e6db5SHans de Goede static u8 *brcmf_fw_nvram_from_efi(size_t *data_len) { return NULL; } 516ce2e6db5SHans de Goede #endif 517ce2e6db5SHans de Goede 518d09ae51aSArend Van Spriel static void brcmf_fw_free_request(struct brcmf_fw_request *req) 519d09ae51aSArend Van Spriel { 520d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 521d09ae51aSArend Van Spriel int i; 522d09ae51aSArend Van Spriel 523d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 524d09ae51aSArend Van Spriel if (item->type == BRCMF_FW_TYPE_BINARY) 525d09ae51aSArend Van Spriel release_firmware(item->binary); 526d09ae51aSArend Van Spriel else if (item->type == BRCMF_FW_TYPE_NVRAM) 527d09ae51aSArend Van Spriel brcmf_fw_nvram_free(item->nv_data.data); 528d09ae51aSArend Van Spriel } 529d09ae51aSArend Van Spriel kfree(req); 530d09ae51aSArend Van Spriel } 531d09ae51aSArend Van Spriel 5320b5c0305SArend Van Spriel static int brcmf_fw_request_nvram_done(const struct firmware *fw, void *ctx) 53305491d2cSKalle Valo { 53405491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 535d09ae51aSArend Van Spriel struct brcmf_fw_item *cur; 536ce2e6db5SHans de Goede bool free_bcm47xx_nvram = false; 537ce2e6db5SHans de Goede bool kfree_nvram = false; 53805491d2cSKalle Valo u32 nvram_length = 0; 53905491d2cSKalle Valo void *nvram = NULL; 54005491d2cSKalle Valo u8 *data = NULL; 54105491d2cSKalle Valo size_t data_len; 54205491d2cSKalle Valo 54305491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev)); 544d09ae51aSArend Van Spriel 545d09ae51aSArend Van Spriel cur = &fwctx->req->items[fwctx->curpos]; 546d09ae51aSArend Van Spriel 54705491d2cSKalle Valo if (fw && fw->data) { 54805491d2cSKalle Valo data = (u8 *)fw->data; 54905491d2cSKalle Valo data_len = fw->size; 55005491d2cSKalle Valo } else { 551ce2e6db5SHans de Goede if ((data = bcm47xx_nvram_get_contents(&data_len))) 552ce2e6db5SHans de Goede free_bcm47xx_nvram = true; 553ce2e6db5SHans de Goede else if ((data = brcmf_fw_nvram_from_efi(&data_len))) 554ce2e6db5SHans de Goede kfree_nvram = true; 555ce2e6db5SHans de Goede else if (!(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 55605491d2cSKalle Valo goto fail; 55705491d2cSKalle Valo } 55805491d2cSKalle Valo 55905491d2cSKalle Valo if (data) 56005491d2cSKalle Valo nvram = brcmf_fw_nvram_strip(data, data_len, &nvram_length, 561d09ae51aSArend Van Spriel fwctx->req->domain_nr, 562d09ae51aSArend Van Spriel fwctx->req->bus_nr); 56305491d2cSKalle Valo 564ce2e6db5SHans de Goede if (free_bcm47xx_nvram) 56505491d2cSKalle Valo bcm47xx_nvram_release_contents(data); 566ce2e6db5SHans de Goede if (kfree_nvram) 567ce2e6db5SHans de Goede kfree(data); 568ce2e6db5SHans de Goede 56905491d2cSKalle Valo release_firmware(fw); 570d09ae51aSArend Van Spriel if (!nvram && !(cur->flags & BRCMF_FW_REQF_OPTIONAL)) 57105491d2cSKalle Valo goto fail; 57205491d2cSKalle Valo 573d09ae51aSArend Van Spriel brcmf_dbg(TRACE, "nvram %p len %d\n", nvram, nvram_length); 574d09ae51aSArend Van Spriel cur->nv_data.data = nvram; 575d09ae51aSArend Van Spriel cur->nv_data.len = nvram_length; 5760b5c0305SArend Van Spriel return 0; 57705491d2cSKalle Valo 57805491d2cSKalle Valo fail: 5790b5c0305SArend Van Spriel return -ENOENT; 58005491d2cSKalle Valo } 58105491d2cSKalle Valo 582a1a3b762SHans de Goede static int brcmf_fw_complete_request(const struct firmware *fw, 583a1a3b762SHans de Goede struct brcmf_fw *fwctx) 584a1a3b762SHans de Goede { 585a1a3b762SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 586a1a3b762SHans de Goede int ret = 0; 587a1a3b762SHans de Goede 588a1a3b762SHans de Goede brcmf_dbg(TRACE, "firmware %s %sfound\n", cur->path, fw ? "" : "not "); 589a1a3b762SHans de Goede 590a1a3b762SHans de Goede switch (cur->type) { 591a1a3b762SHans de Goede case BRCMF_FW_TYPE_NVRAM: 592a1a3b762SHans de Goede ret = brcmf_fw_request_nvram_done(fw, fwctx); 593a1a3b762SHans de Goede break; 594a1a3b762SHans de Goede case BRCMF_FW_TYPE_BINARY: 595a1a3b762SHans de Goede if (fw) 596a1a3b762SHans de Goede cur->binary = fw; 597a1a3b762SHans de Goede else 598a1a3b762SHans de Goede ret = -ENOENT; 599a1a3b762SHans de Goede break; 600a1a3b762SHans de Goede default: 601a1a3b762SHans de Goede /* something fishy here so bail out early */ 602a1a3b762SHans de Goede brcmf_err("unknown fw type: %d\n", cur->type); 603a1a3b762SHans de Goede release_firmware(fw); 604a1a3b762SHans de Goede ret = -EINVAL; 605a1a3b762SHans de Goede } 606a1a3b762SHans de Goede 607a1a3b762SHans de Goede return (cur->flags & BRCMF_FW_REQF_OPTIONAL) ? 0 : ret; 608a1a3b762SHans de Goede } 609a1a3b762SHans de Goede 610eae8e506SHans de Goede static int brcmf_fw_request_firmware(const struct firmware **fw, 611eae8e506SHans de Goede struct brcmf_fw *fwctx) 612eae8e506SHans de Goede { 613eae8e506SHans de Goede struct brcmf_fw_item *cur = &fwctx->req->items[fwctx->curpos]; 614eae8e506SHans de Goede int ret; 615eae8e506SHans de Goede 616eae8e506SHans de Goede /* nvram files are board-specific, first try a board-specific path */ 617eae8e506SHans de Goede if (cur->type == BRCMF_FW_TYPE_NVRAM && fwctx->req->board_type) { 618eae8e506SHans de Goede char alt_path[BRCMF_FW_NAME_LEN]; 619eae8e506SHans de Goede 620eae8e506SHans de Goede strlcpy(alt_path, cur->path, BRCMF_FW_NAME_LEN); 621eae8e506SHans de Goede /* strip .txt at the end */ 622eae8e506SHans de Goede alt_path[strlen(alt_path) - 4] = 0; 623eae8e506SHans de Goede strlcat(alt_path, ".", BRCMF_FW_NAME_LEN); 624eae8e506SHans de Goede strlcat(alt_path, fwctx->req->board_type, BRCMF_FW_NAME_LEN); 625eae8e506SHans de Goede strlcat(alt_path, ".txt", BRCMF_FW_NAME_LEN); 626eae8e506SHans de Goede 627eae8e506SHans de Goede ret = request_firmware(fw, alt_path, fwctx->dev); 628eae8e506SHans de Goede if (ret == 0) 629eae8e506SHans de Goede return ret; 630eae8e506SHans de Goede } 631eae8e506SHans de Goede 632eae8e506SHans de Goede return request_firmware(fw, cur->path, fwctx->dev); 633eae8e506SHans de Goede } 634eae8e506SHans de Goede 635d09ae51aSArend Van Spriel static void brcmf_fw_request_done(const struct firmware *fw, void *ctx) 63605491d2cSKalle Valo { 63705491d2cSKalle Valo struct brcmf_fw *fwctx = ctx; 63855e491edSHans de Goede int ret; 639d09ae51aSArend Van Spriel 640a1a3b762SHans de Goede ret = brcmf_fw_complete_request(fw, fwctx); 6410b5c0305SArend Van Spriel 6425b587496SHans de Goede while (ret == 0 && ++fwctx->curpos < fwctx->req->n_items) { 643eae8e506SHans de Goede brcmf_fw_request_firmware(&fw, fwctx); 6445b587496SHans de Goede ret = brcmf_fw_complete_request(fw, ctx); 645d09ae51aSArend Van Spriel } 64603fb0e83SArend Van Spriel 6475b587496SHans de Goede if (ret) { 648d09ae51aSArend Van Spriel brcmf_fw_free_request(fwctx->req); 649d09ae51aSArend Van Spriel fwctx->req = NULL; 6505b587496SHans de Goede } 651d09ae51aSArend Van Spriel fwctx->done(fwctx->dev, ret, fwctx->req); 65205491d2cSKalle Valo kfree(fwctx); 65305491d2cSKalle Valo } 65405491d2cSKalle Valo 655d09ae51aSArend Van Spriel static bool brcmf_fw_request_is_valid(struct brcmf_fw_request *req) 656d09ae51aSArend Van Spriel { 657d09ae51aSArend Van Spriel struct brcmf_fw_item *item; 658d09ae51aSArend Van Spriel int i; 659d09ae51aSArend Van Spriel 660d09ae51aSArend Van Spriel if (!req->n_items) 661d09ae51aSArend Van Spriel return false; 662d09ae51aSArend Van Spriel 663d09ae51aSArend Van Spriel for (i = 0, item = &req->items[0]; i < req->n_items; i++, item++) { 664d09ae51aSArend Van Spriel if (!item->path) 665d09ae51aSArend Van Spriel return false; 666d09ae51aSArend Van Spriel } 667d09ae51aSArend Van Spriel return true; 668d09ae51aSArend Van Spriel } 669d09ae51aSArend Van Spriel 670d09ae51aSArend Van Spriel int brcmf_fw_get_firmwares(struct device *dev, struct brcmf_fw_request *req, 6716d0507a7SArend Van Spriel void (*fw_cb)(struct device *dev, int err, 672d09ae51aSArend Van Spriel struct brcmf_fw_request *req)) 67305491d2cSKalle Valo { 6745b587496SHans de Goede struct brcmf_fw_item *first = &req->items[0]; 67505491d2cSKalle Valo struct brcmf_fw *fwctx; 6765b587496SHans de Goede int ret; 67705491d2cSKalle Valo 67805491d2cSKalle Valo brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(dev)); 679d09ae51aSArend Van Spriel if (!fw_cb) 68005491d2cSKalle Valo return -EINVAL; 68105491d2cSKalle Valo 682d09ae51aSArend Van Spriel if (!brcmf_fw_request_is_valid(req)) 68305491d2cSKalle Valo return -EINVAL; 68405491d2cSKalle Valo 68505491d2cSKalle Valo fwctx = kzalloc(sizeof(*fwctx), GFP_KERNEL); 68605491d2cSKalle Valo if (!fwctx) 68705491d2cSKalle Valo return -ENOMEM; 68805491d2cSKalle Valo 68905491d2cSKalle Valo fwctx->dev = dev; 690d09ae51aSArend Van Spriel fwctx->req = req; 69105491d2cSKalle Valo fwctx->done = fw_cb; 69205491d2cSKalle Valo 6935b587496SHans de Goede ret = request_firmware_nowait(THIS_MODULE, true, first->path, 6945b587496SHans de Goede fwctx->dev, GFP_KERNEL, fwctx, 6955b587496SHans de Goede brcmf_fw_request_done); 6965b587496SHans de Goede if (ret < 0) 6975b587496SHans de Goede brcmf_fw_request_done(NULL, fwctx); 6985b587496SHans de Goede 699d09ae51aSArend Van Spriel return 0; 70005491d2cSKalle Valo } 70105491d2cSKalle Valo 7022baa3aaeSArend Van Spriel struct brcmf_fw_request * 7032baa3aaeSArend Van Spriel brcmf_fw_alloc_request(u32 chip, u32 chiprev, 704ff68c9f9SArend Van Spriel const struct brcmf_firmware_mapping mapping_table[], 7052baa3aaeSArend Van Spriel u32 table_size, struct brcmf_fw_name *fwnames, 7062baa3aaeSArend Van Spriel u32 n_fwnames) 7072baa3aaeSArend Van Spriel { 7082baa3aaeSArend Van Spriel struct brcmf_fw_request *fwreq; 7092baa3aaeSArend Van Spriel char chipname[12]; 7102baa3aaeSArend Van Spriel const char *mp_path; 7112baa3aaeSArend Van Spriel u32 i, j; 7122baa3aaeSArend Van Spriel char end; 7132baa3aaeSArend Van Spriel size_t reqsz; 7142baa3aaeSArend Van Spriel 7152baa3aaeSArend Van Spriel for (i = 0; i < table_size; i++) { 7162baa3aaeSArend Van Spriel if (mapping_table[i].chipid == chip && 7172baa3aaeSArend Van Spriel mapping_table[i].revmask & BIT(chiprev)) 7182baa3aaeSArend Van Spriel break; 7192baa3aaeSArend Van Spriel } 7202baa3aaeSArend Van Spriel 7212baa3aaeSArend Van Spriel if (i == table_size) { 7222baa3aaeSArend Van Spriel brcmf_err("Unknown chipid %d [%d]\n", chip, chiprev); 7232baa3aaeSArend Van Spriel return NULL; 7242baa3aaeSArend Van Spriel } 7252baa3aaeSArend Van Spriel 7262baa3aaeSArend Van Spriel reqsz = sizeof(*fwreq) + n_fwnames * sizeof(struct brcmf_fw_item); 7272baa3aaeSArend Van Spriel fwreq = kzalloc(reqsz, GFP_KERNEL); 7282baa3aaeSArend Van Spriel if (!fwreq) 7292baa3aaeSArend Van Spriel return NULL; 7302baa3aaeSArend Van Spriel 7312baa3aaeSArend Van Spriel brcmf_chip_name(chip, chiprev, chipname, sizeof(chipname)); 7322baa3aaeSArend Van Spriel 7332baa3aaeSArend Van Spriel brcmf_info("using %s for chip %s\n", 7342baa3aaeSArend Van Spriel mapping_table[i].fw_base, chipname); 7352baa3aaeSArend Van Spriel 7362baa3aaeSArend Van Spriel mp_path = brcmf_mp_global.firmware_path; 7372baa3aaeSArend Van Spriel end = mp_path[strlen(mp_path) - 1]; 7382baa3aaeSArend Van Spriel fwreq->n_items = n_fwnames; 7392baa3aaeSArend Van Spriel 7402baa3aaeSArend Van Spriel for (j = 0; j < n_fwnames; j++) { 7412baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 7422baa3aaeSArend Van Spriel /* check if firmware path is provided by module parameter */ 7432baa3aaeSArend Van Spriel if (brcmf_mp_global.firmware_path[0] != '\0') { 7442baa3aaeSArend Van Spriel strlcpy(fwnames[j].path, mp_path, 7452baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 7462baa3aaeSArend Van Spriel 7472baa3aaeSArend Van Spriel if (end != '/') { 7482baa3aaeSArend Van Spriel strlcat(fwnames[j].path, "/", 7492baa3aaeSArend Van Spriel BRCMF_FW_NAME_LEN); 7502baa3aaeSArend Van Spriel } 7512baa3aaeSArend Van Spriel } 752bf291b72SArend Van Spriel strlcat(fwnames[j].path, mapping_table[i].fw_base, 753bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 754bf291b72SArend Van Spriel strlcat(fwnames[j].path, fwnames[j].extension, 755bf291b72SArend Van Spriel BRCMF_FW_NAME_LEN); 7562baa3aaeSArend Van Spriel fwreq->items[j].path = fwnames[j].path; 7572baa3aaeSArend Van Spriel } 7582baa3aaeSArend Van Spriel 7592baa3aaeSArend Van Spriel return fwreq; 7602baa3aaeSArend Van Spriel } 761