634 lines · c
1// SPDX-License-Identifier: ISC2/*3 * Copyright (c) 2010 Broadcom Corporation4 */5 6#include <linux/kernel.h>7#include <linux/string.h>8#include <linux/netdevice.h>9#include <linux/module.h>10#include <linux/firmware.h>11#include <brcmu_wifi.h>12#include <brcmu_utils.h>13#include "core.h"14#include "bus.h"15#include "debug.h"16#include "fwil.h"17#include "fwil_types.h"18#include "tracepoint.h"19#include "common.h"20#include "of.h"21#include "firmware.h"22#include "chip.h"23 24MODULE_AUTHOR("Broadcom Corporation");25MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver.");26MODULE_LICENSE("Dual BSD/GPL");27 28#define BRCMF_DEFAULT_SCAN_CHANNEL_TIME 4029#define BRCMF_DEFAULT_SCAN_UNASSOC_TIME 4030 31/* default boost value for RSSI_DELTA in preferred join selection */32#define BRCMF_JOIN_PREF_RSSI_BOOST 833 34#define BRCMF_DEFAULT_TXGLOM_SIZE 32 /* max tx frames in glom chain */35 36static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE;37module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0);38MODULE_PARM_DESC(txglomsz, "Maximum tx packet chain size [SDIO]");39 40/* Debug level configuration. See debug.h for bits, sysfs modifiable */41int brcmf_msg_level;42module_param_named(debug, brcmf_msg_level, int, 0600);43MODULE_PARM_DESC(debug, "Level of debug output");44 45static int brcmf_p2p_enable;46module_param_named(p2pon, brcmf_p2p_enable, int, 0);47MODULE_PARM_DESC(p2pon, "Enable legacy p2p management functionality");48 49static int brcmf_feature_disable;50module_param_named(feature_disable, brcmf_feature_disable, int, 0);51MODULE_PARM_DESC(feature_disable, "Disable features");52 53static char brcmf_firmware_path[BRCMF_FW_ALTPATH_LEN];54module_param_string(alternative_fw_path, brcmf_firmware_path,55 BRCMF_FW_ALTPATH_LEN, 0400);56MODULE_PARM_DESC(alternative_fw_path, "Alternative firmware path");57 58static int brcmf_fcmode;59module_param_named(fcmode, brcmf_fcmode, int, 0);60MODULE_PARM_DESC(fcmode, "Mode of firmware signalled flow control");61 62static int brcmf_roamoff;63module_param_named(roamoff, brcmf_roamoff, int, 0400);64MODULE_PARM_DESC(roamoff, "Do not use internal roaming engine");65 66static int brcmf_iapp_enable;67module_param_named(iapp, brcmf_iapp_enable, int, 0);68MODULE_PARM_DESC(iapp, "Enable partial support for the obsoleted Inter-Access Point Protocol");69 70#ifdef DEBUG71/* always succeed brcmf_bus_started() */72static int brcmf_ignore_probe_fail;73module_param_named(ignore_probe_fail, brcmf_ignore_probe_fail, int, 0);74MODULE_PARM_DESC(ignore_probe_fail, "always succeed probe for debugging");75#endif76 77static struct brcmfmac_platform_data *brcmfmac_pdata;78struct brcmf_mp_global_t brcmf_mp_global;79 80void brcmf_c_set_joinpref_default(struct brcmf_if *ifp)81{82 struct brcmf_pub *drvr = ifp->drvr;83 struct brcmf_join_pref_params join_pref_params[2];84 int err;85 86 /* Setup join_pref to select target by RSSI (boost on 5GHz) */87 join_pref_params[0].type = BRCMF_JOIN_PREF_RSSI_DELTA;88 join_pref_params[0].len = 2;89 join_pref_params[0].rssi_gain = BRCMF_JOIN_PREF_RSSI_BOOST;90 join_pref_params[0].band = WLC_BAND_5G;91 92 join_pref_params[1].type = BRCMF_JOIN_PREF_RSSI;93 join_pref_params[1].len = 2;94 join_pref_params[1].rssi_gain = 0;95 join_pref_params[1].band = 0;96 err = brcmf_fil_iovar_data_set(ifp, "join_pref", join_pref_params,97 sizeof(join_pref_params));98 if (err)99 bphy_err(drvr, "Set join_pref error (%d)\n", err);100}101 102static int brcmf_c_download(struct brcmf_if *ifp, u16 flag,103 struct brcmf_dload_data_le *dload_buf,104 u32 len, const char *var)105{106 s32 err;107 108 flag |= (DLOAD_HANDLER_VER << DLOAD_FLAG_VER_SHIFT);109 dload_buf->flag = cpu_to_le16(flag);110 dload_buf->dload_type = cpu_to_le16(DL_TYPE_CLM);111 dload_buf->len = cpu_to_le32(len);112 dload_buf->crc = cpu_to_le32(0);113 114 err = brcmf_fil_iovar_data_set(ifp, var, dload_buf,115 struct_size(dload_buf, data, len));116 117 return err;118}119 120static int brcmf_c_download_blob(struct brcmf_if *ifp,121 const void *data, size_t size,122 const char *loadvar, const char *statvar)123{124 struct brcmf_pub *drvr = ifp->drvr;125 struct brcmf_dload_data_le *chunk_buf;126 u32 chunk_len;127 u32 datalen;128 u32 cumulative_len;129 u16 dl_flag = DL_BEGIN;130 u32 status;131 s32 err;132 133 brcmf_dbg(TRACE, "Enter\n");134 135 chunk_buf = kzalloc(struct_size(chunk_buf, data, MAX_CHUNK_LEN),136 GFP_KERNEL);137 if (!chunk_buf) {138 err = -ENOMEM;139 return -ENOMEM;140 }141 142 datalen = size;143 cumulative_len = 0;144 do {145 if (datalen > MAX_CHUNK_LEN) {146 chunk_len = MAX_CHUNK_LEN;147 } else {148 chunk_len = datalen;149 dl_flag |= DL_END;150 }151 memcpy(chunk_buf->data, data + cumulative_len, chunk_len);152 153 err = brcmf_c_download(ifp, dl_flag, chunk_buf, chunk_len,154 loadvar);155 156 dl_flag &= ~DL_BEGIN;157 158 cumulative_len += chunk_len;159 datalen -= chunk_len;160 } while ((datalen > 0) && (err == 0));161 162 if (err) {163 bphy_err(drvr, "%s (%zu byte file) failed (%d)\n",164 loadvar, size, err);165 /* Retrieve status and print */166 err = brcmf_fil_iovar_int_get(ifp, statvar, &status);167 if (err)168 bphy_err(drvr, "get %s failed (%d)\n", statvar, err);169 else170 brcmf_dbg(INFO, "%s=%d\n", statvar, status);171 err = -EIO;172 }173 174 kfree(chunk_buf);175 return err;176}177 178static int brcmf_c_process_clm_blob(struct brcmf_if *ifp)179{180 struct brcmf_pub *drvr = ifp->drvr;181 struct brcmf_bus *bus = drvr->bus_if;182 const struct firmware *fw = NULL;183 s32 err;184 185 brcmf_dbg(TRACE, "Enter\n");186 187 err = brcmf_bus_get_blob(bus, &fw, BRCMF_BLOB_CLM);188 if (err || !fw) {189 brcmf_info("no clm_blob available (err=%d), device may have limited channels available\n",190 err);191 return 0;192 }193 194 err = brcmf_c_download_blob(ifp, fw->data, fw->size,195 "clmload", "clmload_status");196 197 release_firmware(fw);198 return err;199}200 201static int brcmf_c_process_txcap_blob(struct brcmf_if *ifp)202{203 struct brcmf_pub *drvr = ifp->drvr;204 struct brcmf_bus *bus = drvr->bus_if;205 const struct firmware *fw = NULL;206 s32 err;207 208 brcmf_dbg(TRACE, "Enter\n");209 210 err = brcmf_bus_get_blob(bus, &fw, BRCMF_BLOB_TXCAP);211 if (err || !fw) {212 brcmf_info("no txcap_blob available (err=%d)\n", err);213 return 0;214 }215 216 brcmf_info("TxCap blob found, loading\n");217 err = brcmf_c_download_blob(ifp, fw->data, fw->size,218 "txcapload", "txcapload_status");219 220 release_firmware(fw);221 return err;222}223 224int brcmf_c_set_cur_etheraddr(struct brcmf_if *ifp, const u8 *addr)225{226 s32 err;227 228 err = brcmf_fil_iovar_data_set(ifp, "cur_etheraddr", addr, ETH_ALEN);229 if (err < 0)230 bphy_err(ifp->drvr, "Setting cur_etheraddr failed, %d\n", err);231 232 return err;233}234 235/* On some boards there is no eeprom to hold the nvram, in this case instead236 * a board specific nvram is loaded from /lib/firmware. On most boards the237 * macaddr setting in the /lib/firmware nvram file is ignored because the238 * wifibt chip has a unique MAC programmed into the chip itself.239 * But in some cases the actual MAC from the /lib/firmware nvram file gets240 * used, leading to MAC conflicts.241 * The MAC addresses in the troublesome nvram files seem to all come from242 * the same nvram file template, so we only need to check for 1 known243 * address to detect this.244 */245static const u8 brcmf_default_mac_address[ETH_ALEN] = {246 0x00, 0x90, 0x4c, 0xc5, 0x12, 0x38247};248 249static int brcmf_c_process_cal_blob(struct brcmf_if *ifp)250{251 struct brcmf_pub *drvr = ifp->drvr;252 struct brcmf_mp_device *settings = drvr->settings;253 s32 err;254 255 brcmf_dbg(TRACE, "Enter\n");256 257 if (!settings->cal_blob || !settings->cal_size)258 return 0;259 260 brcmf_info("Calibration blob provided by platform, loading\n");261 err = brcmf_c_download_blob(ifp, settings->cal_blob, settings->cal_size,262 "calload", "calload_status");263 return err;264}265 266int brcmf_c_preinit_dcmds(struct brcmf_if *ifp)267{268 struct brcmf_pub *drvr = ifp->drvr;269 struct brcmf_fweh_info *fweh = drvr->fweh;270 u8 buf[BRCMF_DCMD_SMLEN];271 struct brcmf_bus *bus;272 struct brcmf_rev_info_le revinfo;273 struct brcmf_rev_info *ri;274 char *clmver;275 char *ptr;276 s32 err;277 278 if (is_valid_ether_addr(ifp->mac_addr)) {279 /* set mac address */280 err = brcmf_c_set_cur_etheraddr(ifp, ifp->mac_addr);281 if (err < 0)282 goto done;283 } else {284 /* retrieve mac address */285 err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr,286 sizeof(ifp->mac_addr));287 if (err < 0) {288 bphy_err(drvr, "Retrieving cur_etheraddr failed, %d\n", err);289 goto done;290 }291 292 if (ether_addr_equal_unaligned(ifp->mac_addr, brcmf_default_mac_address)) {293 bphy_err(drvr, "Default MAC is used, replacing with random MAC to avoid conflicts\n");294 eth_random_addr(ifp->mac_addr);295 ifp->ndev->addr_assign_type = NET_ADDR_RANDOM;296 err = brcmf_c_set_cur_etheraddr(ifp, ifp->mac_addr);297 if (err < 0)298 goto done;299 }300 }301 302 memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac));303 memcpy(ifp->drvr->wiphy->perm_addr, ifp->drvr->mac, ETH_ALEN);304 305 bus = ifp->drvr->bus_if;306 ri = &ifp->drvr->revinfo;307 308 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO,309 &revinfo, sizeof(revinfo));310 if (err < 0) {311 bphy_err(drvr, "retrieving revision info failed, %d\n", err);312 strscpy(ri->chipname, "UNKNOWN", sizeof(ri->chipname));313 } else {314 ri->vendorid = le32_to_cpu(revinfo.vendorid);315 ri->deviceid = le32_to_cpu(revinfo.deviceid);316 ri->radiorev = le32_to_cpu(revinfo.radiorev);317 ri->corerev = le32_to_cpu(revinfo.corerev);318 ri->boardid = le32_to_cpu(revinfo.boardid);319 ri->boardvendor = le32_to_cpu(revinfo.boardvendor);320 ri->boardrev = le32_to_cpu(revinfo.boardrev);321 ri->driverrev = le32_to_cpu(revinfo.driverrev);322 ri->ucoderev = le32_to_cpu(revinfo.ucoderev);323 ri->bus = le32_to_cpu(revinfo.bus);324 ri->phytype = le32_to_cpu(revinfo.phytype);325 ri->phyrev = le32_to_cpu(revinfo.phyrev);326 ri->anarev = le32_to_cpu(revinfo.anarev);327 ri->chippkg = le32_to_cpu(revinfo.chippkg);328 ri->nvramrev = le32_to_cpu(revinfo.nvramrev);329 330 /* use revinfo if not known yet */331 if (!bus->chip) {332 bus->chip = le32_to_cpu(revinfo.chipnum);333 bus->chiprev = le32_to_cpu(revinfo.chiprev);334 }335 }336 ri->result = err;337 338 if (bus->chip)339 brcmf_chip_name(bus->chip, bus->chiprev,340 ri->chipname, sizeof(ri->chipname));341 342 /* Do any CLM downloading */343 err = brcmf_c_process_clm_blob(ifp);344 if (err < 0) {345 bphy_err(drvr, "download CLM blob file failed, %d\n", err);346 goto done;347 }348 349 /* Do TxCap downloading, if needed */350 err = brcmf_c_process_txcap_blob(ifp);351 if (err < 0) {352 bphy_err(drvr, "download TxCap blob file failed, %d\n", err);353 goto done;354 }355 356 /* Download external calibration blob, if available */357 err = brcmf_c_process_cal_blob(ifp);358 if (err < 0) {359 bphy_err(drvr, "download calibration blob file failed, %d\n", err);360 goto done;361 }362 363 /* query for 'ver' to get version info from firmware */364 memset(buf, 0, sizeof(buf));365 err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf));366 if (err < 0) {367 bphy_err(drvr, "Retrieving version information failed, %d\n",368 err);369 goto done;370 }371 buf[sizeof(buf) - 1] = '\0';372 ptr = (char *)buf;373 strsep(&ptr, "\n");374 375 /* Print fw version info */376 brcmf_info("Firmware: %s %s\n", ri->chipname, buf);377 378 /* locate firmware version number for ethtool */379 ptr = strrchr(buf, ' ');380 if (!ptr) {381 bphy_err(drvr, "Retrieving version number failed");382 goto done;383 }384 strscpy(ifp->drvr->fwver, ptr + 1, sizeof(ifp->drvr->fwver));385 386 /* Query for 'clmver' to get CLM version info from firmware */387 memset(buf, 0, sizeof(buf));388 err = brcmf_fil_iovar_data_get(ifp, "clmver", buf, sizeof(buf));389 if (err) {390 brcmf_dbg(TRACE, "retrieving clmver failed, %d\n", err);391 } else {392 buf[sizeof(buf) - 1] = '\0';393 clmver = (char *)buf;394 395 /* Replace all newline/linefeed characters with space396 * character397 */398 strreplace(clmver, '\n', ' ');399 400 /* store CLM version for adding it to revinfo debugfs file */401 memcpy(ifp->drvr->clmver, clmver, sizeof(ifp->drvr->clmver));402 403 brcmf_dbg(INFO, "CLM version = %s\n", clmver);404 }405 406 /* set mpc */407 err = brcmf_fil_iovar_int_set(ifp, "mpc", 1);408 if (err) {409 bphy_err(drvr, "failed setting mpc\n");410 goto done;411 }412 413 brcmf_c_set_joinpref_default(ifp);414 415 /* Setup event_msgs, enable E_IF */416 err = brcmf_fil_iovar_data_get(ifp, "event_msgs", fweh->event_mask,417 fweh->event_mask_len);418 if (err) {419 bphy_err(drvr, "Get event_msgs error (%d)\n", err);420 goto done;421 }422 /*423 * BRCMF_E_IF can safely be used to set the appropriate bit424 * in the event_mask as the firmware event code is guaranteed425 * to match the value of BRCMF_E_IF because it is old cruft426 * that all vendors have.427 */428 setbit(fweh->event_mask, BRCMF_E_IF);429 err = brcmf_fil_iovar_data_set(ifp, "event_msgs", fweh->event_mask,430 fweh->event_mask_len);431 if (err) {432 bphy_err(drvr, "Set event_msgs error (%d)\n", err);433 goto done;434 }435 436 /* Setup default scan channel time */437 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,438 BRCMF_DEFAULT_SCAN_CHANNEL_TIME);439 if (err) {440 bphy_err(drvr, "BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n",441 err);442 goto done;443 }444 445 /* Setup default scan unassoc time */446 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,447 BRCMF_DEFAULT_SCAN_UNASSOC_TIME);448 if (err) {449 bphy_err(drvr, "BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n",450 err);451 goto done;452 }453 454 /* Enable tx beamforming, errors can be ignored (not supported) */455 (void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);456done:457 return err;458}459 460#ifndef CONFIG_BRCM_TRACING461void __brcmf_err(struct brcmf_bus *bus, const char *func, const char *fmt, ...)462{463 struct va_format vaf;464 va_list args;465 466 va_start(args, fmt);467 468 vaf.fmt = fmt;469 vaf.va = &args;470 if (bus)471 dev_err(bus->dev, "%s: %pV", func, &vaf);472 else473 pr_err("%s: %pV", func, &vaf);474 475 va_end(args);476}477#endif478 479#if defined(CONFIG_BRCM_TRACING) || defined(CONFIG_BRCMDBG)480void __brcmf_dbg(u32 level, const char *func, const char *fmt, ...)481{482 struct va_format vaf = {483 .fmt = fmt,484 };485 va_list args;486 487 va_start(args, fmt);488 vaf.va = &args;489 if (brcmf_msg_level & level)490 pr_debug("%s %pV", func, &vaf);491 trace_brcmf_dbg(level, func, &vaf);492 va_end(args);493}494#endif495 496static void brcmf_mp_attach(void)497{498 /* If module param firmware path is set then this will always be used,499 * if not set then if available use the platform data version. To make500 * sure it gets initialized at all, always copy the module param version501 */502 strscpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,503 BRCMF_FW_ALTPATH_LEN);504 if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&505 (brcmf_mp_global.firmware_path[0] == '\0')) {506 strscpy(brcmf_mp_global.firmware_path,507 brcmfmac_pdata->fw_alternative_path,508 BRCMF_FW_ALTPATH_LEN);509 }510}511 512struct brcmf_mp_device *brcmf_get_module_param(struct device *dev,513 enum brcmf_bus_type bus_type,514 u32 chip, u32 chiprev)515{516 struct brcmf_mp_device *settings;517 struct brcmfmac_pd_device *device_pd;518 bool found;519 int i;520 521 brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip,522 chiprev);523 settings = kzalloc(sizeof(*settings), GFP_ATOMIC);524 if (!settings)525 return NULL;526 527 /* start by using the module paramaters */528 settings->p2p_enable = !!brcmf_p2p_enable;529 settings->feature_disable = brcmf_feature_disable;530 settings->fcmode = brcmf_fcmode;531 settings->roamoff = !!brcmf_roamoff;532 settings->iapp = !!brcmf_iapp_enable;533#ifdef DEBUG534 settings->ignore_probe_fail = !!brcmf_ignore_probe_fail;535#endif536 537 if (bus_type == BRCMF_BUSTYPE_SDIO)538 settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz;539 540 /* See if there is any device specific platform data configured */541 found = false;542 if (brcmfmac_pdata) {543 for (i = 0; i < brcmfmac_pdata->device_count; i++) {544 device_pd = &brcmfmac_pdata->devices[i];545 if ((device_pd->bus_type == bus_type) &&546 (device_pd->id == chip) &&547 ((device_pd->rev == chiprev) ||548 (device_pd->rev == -1))) {549 brcmf_dbg(INFO, "Platform data for device found\n");550 settings->country_codes =551 device_pd->country_codes;552 if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO)553 memcpy(&settings->bus.sdio,554 &device_pd->bus.sdio,555 sizeof(settings->bus.sdio));556 found = true;557 break;558 }559 }560 }561 if (!found) {562 /* No platform data for this device, try OF and DMI data */563 brcmf_dmi_probe(settings, chip, chiprev);564 brcmf_of_probe(dev, bus_type, settings);565 brcmf_acpi_probe(dev, bus_type, settings);566 }567 return settings;568}569 570void brcmf_release_module_param(struct brcmf_mp_device *module_param)571{572 kfree(module_param);573}574 575static int __init brcmf_common_pd_probe(struct platform_device *pdev)576{577 brcmf_dbg(INFO, "Enter\n");578 579 brcmfmac_pdata = dev_get_platdata(&pdev->dev);580 581 if (brcmfmac_pdata->power_on)582 brcmfmac_pdata->power_on();583 584 return 0;585}586 587static void brcmf_common_pd_remove(struct platform_device *pdev)588{589 brcmf_dbg(INFO, "Enter\n");590 591 if (brcmfmac_pdata->power_off)592 brcmfmac_pdata->power_off();593}594 595static struct platform_driver brcmf_pd = {596 .remove_new = brcmf_common_pd_remove,597 .driver = {598 .name = BRCMFMAC_PDATA_NAME,599 }600};601 602static int __init brcmfmac_module_init(void)603{604 int err;605 606 /* Get the platform data (if available) for our devices */607 err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe);608 if (err == -ENODEV)609 brcmf_dbg(INFO, "No platform data available.\n");610 611 /* Initialize global module paramaters */612 brcmf_mp_attach();613 614 /* Continue the initialization by registering the different busses */615 err = brcmf_core_init();616 if (err) {617 if (brcmfmac_pdata)618 platform_driver_unregister(&brcmf_pd);619 }620 621 return err;622}623 624static void __exit brcmfmac_module_exit(void)625{626 brcmf_core_exit();627 if (brcmfmac_pdata)628 platform_driver_unregister(&brcmf_pd);629}630 631module_init(brcmfmac_module_init);632module_exit(brcmfmac_module_exit);633 634