cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

common.c (14491B)


      1// SPDX-License-Identifier: ISC
      2/*
      3 * Copyright (c) 2010 Broadcom Corporation
      4 */
      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	40
     29#define BRCMF_DEFAULT_SCAN_UNASSOC_TIME	40
     30
     31/* default boost value for RSSI_DELTA in preferred join selection */
     32#define BRCMF_JOIN_PREF_RSSI_BOOST	8
     33
     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 DEBUG
     71/* 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#endif
     76
     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)
    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	len = sizeof(*dload_buf) + len - 1;
    114
    115	err = brcmf_fil_iovar_data_set(ifp, "clmload", dload_buf, len);
    116
    117	return err;
    118}
    119
    120static int brcmf_c_process_clm_blob(struct brcmf_if *ifp)
    121{
    122	struct brcmf_pub *drvr = ifp->drvr;
    123	struct brcmf_bus *bus = drvr->bus_if;
    124	struct brcmf_dload_data_le *chunk_buf;
    125	const struct firmware *clm = NULL;
    126	u8 clm_name[BRCMF_FW_NAME_LEN];
    127	u32 chunk_len;
    128	u32 datalen;
    129	u32 cumulative_len;
    130	u16 dl_flag = DL_BEGIN;
    131	u32 status;
    132	s32 err;
    133
    134	brcmf_dbg(TRACE, "Enter\n");
    135
    136	memset(clm_name, 0, sizeof(clm_name));
    137	err = brcmf_bus_get_fwname(bus, ".clm_blob", clm_name);
    138	if (err) {
    139		bphy_err(drvr, "get CLM blob file name failed (%d)\n", err);
    140		return err;
    141	}
    142
    143	err = firmware_request_nowarn(&clm, clm_name, bus->dev);
    144	if (err) {
    145		brcmf_info("no clm_blob available (err=%d), device may have limited channels available\n",
    146			   err);
    147		return 0;
    148	}
    149
    150	chunk_buf = kzalloc(sizeof(*chunk_buf) + MAX_CHUNK_LEN - 1, GFP_KERNEL);
    151	if (!chunk_buf) {
    152		err = -ENOMEM;
    153		goto done;
    154	}
    155
    156	datalen = clm->size;
    157	cumulative_len = 0;
    158	do {
    159		if (datalen > MAX_CHUNK_LEN) {
    160			chunk_len = MAX_CHUNK_LEN;
    161		} else {
    162			chunk_len = datalen;
    163			dl_flag |= DL_END;
    164		}
    165		memcpy(chunk_buf->data, clm->data + cumulative_len, chunk_len);
    166
    167		err = brcmf_c_download(ifp, dl_flag, chunk_buf, chunk_len);
    168
    169		dl_flag &= ~DL_BEGIN;
    170
    171		cumulative_len += chunk_len;
    172		datalen -= chunk_len;
    173	} while ((datalen > 0) && (err == 0));
    174
    175	if (err) {
    176		bphy_err(drvr, "clmload (%zu byte file) failed (%d)\n",
    177			 clm->size, err);
    178		/* Retrieve clmload_status and print */
    179		err = brcmf_fil_iovar_int_get(ifp, "clmload_status", &status);
    180		if (err)
    181			bphy_err(drvr, "get clmload_status failed (%d)\n", err);
    182		else
    183			brcmf_dbg(INFO, "clmload_status=%d\n", status);
    184		err = -EIO;
    185	}
    186
    187	kfree(chunk_buf);
    188done:
    189	release_firmware(clm);
    190	return err;
    191}
    192
    193int brcmf_c_preinit_dcmds(struct brcmf_if *ifp)
    194{
    195	struct brcmf_pub *drvr = ifp->drvr;
    196	s8 eventmask[BRCMF_EVENTING_MASK_LEN];
    197	u8 buf[BRCMF_DCMD_SMLEN];
    198	struct brcmf_bus *bus;
    199	struct brcmf_rev_info_le revinfo;
    200	struct brcmf_rev_info *ri;
    201	char *clmver;
    202	char *ptr;
    203	s32 err;
    204
    205	if (is_valid_ether_addr(ifp->mac_addr)) {
    206		/* set mac address */
    207		err = brcmf_fil_iovar_data_set(ifp, "cur_etheraddr", ifp->mac_addr,
    208					       ETH_ALEN);
    209		if (err < 0) {
    210			bphy_err(ifp->drvr, "Setting cur_etheraddr failed, %d\n", err);
    211			goto done;
    212		}
    213	} else {
    214		/* retrieve mac address */
    215		err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr,
    216					       sizeof(ifp->mac_addr));
    217		if (err < 0) {
    218			bphy_err(drvr, "Retrieving cur_etheraddr failed, %d\n", err);
    219			goto done;
    220		}
    221	}
    222
    223	memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac));
    224	memcpy(ifp->drvr->wiphy->perm_addr, ifp->drvr->mac, ETH_ALEN);
    225
    226	bus = ifp->drvr->bus_if;
    227	ri = &ifp->drvr->revinfo;
    228
    229	err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO,
    230				     &revinfo, sizeof(revinfo));
    231	if (err < 0) {
    232		bphy_err(drvr, "retrieving revision info failed, %d\n", err);
    233		strlcpy(ri->chipname, "UNKNOWN", sizeof(ri->chipname));
    234	} else {
    235		ri->vendorid = le32_to_cpu(revinfo.vendorid);
    236		ri->deviceid = le32_to_cpu(revinfo.deviceid);
    237		ri->radiorev = le32_to_cpu(revinfo.radiorev);
    238		ri->corerev = le32_to_cpu(revinfo.corerev);
    239		ri->boardid = le32_to_cpu(revinfo.boardid);
    240		ri->boardvendor = le32_to_cpu(revinfo.boardvendor);
    241		ri->boardrev = le32_to_cpu(revinfo.boardrev);
    242		ri->driverrev = le32_to_cpu(revinfo.driverrev);
    243		ri->ucoderev = le32_to_cpu(revinfo.ucoderev);
    244		ri->bus = le32_to_cpu(revinfo.bus);
    245		ri->phytype = le32_to_cpu(revinfo.phytype);
    246		ri->phyrev = le32_to_cpu(revinfo.phyrev);
    247		ri->anarev = le32_to_cpu(revinfo.anarev);
    248		ri->chippkg = le32_to_cpu(revinfo.chippkg);
    249		ri->nvramrev = le32_to_cpu(revinfo.nvramrev);
    250
    251		/* use revinfo if not known yet */
    252		if (!bus->chip) {
    253			bus->chip = le32_to_cpu(revinfo.chipnum);
    254			bus->chiprev = le32_to_cpu(revinfo.chiprev);
    255		}
    256	}
    257	ri->result = err;
    258
    259	if (bus->chip)
    260		brcmf_chip_name(bus->chip, bus->chiprev,
    261				ri->chipname, sizeof(ri->chipname));
    262
    263	/* Do any CLM downloading */
    264	err = brcmf_c_process_clm_blob(ifp);
    265	if (err < 0) {
    266		bphy_err(drvr, "download CLM blob file failed, %d\n", err);
    267		goto done;
    268	}
    269
    270	/* query for 'ver' to get version info from firmware */
    271	memset(buf, 0, sizeof(buf));
    272	err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf));
    273	if (err < 0) {
    274		bphy_err(drvr, "Retrieving version information failed, %d\n",
    275			 err);
    276		goto done;
    277	}
    278	ptr = (char *)buf;
    279	strsep(&ptr, "\n");
    280
    281	/* Print fw version info */
    282	brcmf_info("Firmware: %s %s\n", ri->chipname, buf);
    283
    284	/* locate firmware version number for ethtool */
    285	ptr = strrchr(buf, ' ') + 1;
    286	strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));
    287
    288	/* Query for 'clmver' to get CLM version info from firmware */
    289	memset(buf, 0, sizeof(buf));
    290	err = brcmf_fil_iovar_data_get(ifp, "clmver", buf, sizeof(buf));
    291	if (err) {
    292		brcmf_dbg(TRACE, "retrieving clmver failed, %d\n", err);
    293	} else {
    294		clmver = (char *)buf;
    295		/* store CLM version for adding it to revinfo debugfs file */
    296		memcpy(ifp->drvr->clmver, clmver, sizeof(ifp->drvr->clmver));
    297
    298		/* Replace all newline/linefeed characters with space
    299		 * character
    300		 */
    301		strreplace(clmver, '\n', ' ');
    302
    303		brcmf_dbg(INFO, "CLM version = %s\n", clmver);
    304	}
    305
    306	/* set mpc */
    307	err = brcmf_fil_iovar_int_set(ifp, "mpc", 1);
    308	if (err) {
    309		bphy_err(drvr, "failed setting mpc\n");
    310		goto done;
    311	}
    312
    313	brcmf_c_set_joinpref_default(ifp);
    314
    315	/* Setup event_msgs, enable E_IF */
    316	err = brcmf_fil_iovar_data_get(ifp, "event_msgs", eventmask,
    317				       BRCMF_EVENTING_MASK_LEN);
    318	if (err) {
    319		bphy_err(drvr, "Get event_msgs error (%d)\n", err);
    320		goto done;
    321	}
    322	setbit(eventmask, BRCMF_E_IF);
    323	err = brcmf_fil_iovar_data_set(ifp, "event_msgs", eventmask,
    324				       BRCMF_EVENTING_MASK_LEN);
    325	if (err) {
    326		bphy_err(drvr, "Set event_msgs error (%d)\n", err);
    327		goto done;
    328	}
    329
    330	/* Setup default scan channel time */
    331	err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
    332				    BRCMF_DEFAULT_SCAN_CHANNEL_TIME);
    333	if (err) {
    334		bphy_err(drvr, "BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n",
    335			 err);
    336		goto done;
    337	}
    338
    339	/* Setup default scan unassoc time */
    340	err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
    341				    BRCMF_DEFAULT_SCAN_UNASSOC_TIME);
    342	if (err) {
    343		bphy_err(drvr, "BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n",
    344			 err);
    345		goto done;
    346	}
    347
    348	/* Enable tx beamforming, errors can be ignored (not supported) */
    349	(void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);
    350done:
    351	return err;
    352}
    353
    354#ifndef CONFIG_BRCM_TRACING
    355void __brcmf_err(struct brcmf_bus *bus, const char *func, const char *fmt, ...)
    356{
    357	struct va_format vaf;
    358	va_list args;
    359
    360	va_start(args, fmt);
    361
    362	vaf.fmt = fmt;
    363	vaf.va = &args;
    364	if (bus)
    365		dev_err(bus->dev, "%s: %pV", func, &vaf);
    366	else
    367		pr_err("%s: %pV", func, &vaf);
    368
    369	va_end(args);
    370}
    371#endif
    372
    373#if defined(CONFIG_BRCM_TRACING) || defined(CONFIG_BRCMDBG)
    374void __brcmf_dbg(u32 level, const char *func, const char *fmt, ...)
    375{
    376	struct va_format vaf = {
    377		.fmt = fmt,
    378	};
    379	va_list args;
    380
    381	va_start(args, fmt);
    382	vaf.va = &args;
    383	if (brcmf_msg_level & level)
    384		pr_debug("%s %pV", func, &vaf);
    385	trace_brcmf_dbg(level, func, &vaf);
    386	va_end(args);
    387}
    388#endif
    389
    390static void brcmf_mp_attach(void)
    391{
    392	/* If module param firmware path is set then this will always be used,
    393	 * if not set then if available use the platform data version. To make
    394	 * sure it gets initialized at all, always copy the module param version
    395	 */
    396	strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
    397		BRCMF_FW_ALTPATH_LEN);
    398	if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&
    399	    (brcmf_mp_global.firmware_path[0] == '\0')) {
    400		strlcpy(brcmf_mp_global.firmware_path,
    401			brcmfmac_pdata->fw_alternative_path,
    402			BRCMF_FW_ALTPATH_LEN);
    403	}
    404}
    405
    406struct brcmf_mp_device *brcmf_get_module_param(struct device *dev,
    407					       enum brcmf_bus_type bus_type,
    408					       u32 chip, u32 chiprev)
    409{
    410	struct brcmf_mp_device *settings;
    411	struct brcmfmac_pd_device *device_pd;
    412	bool found;
    413	int i;
    414
    415	brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip,
    416		  chiprev);
    417	settings = kzalloc(sizeof(*settings), GFP_ATOMIC);
    418	if (!settings)
    419		return NULL;
    420
    421	/* start by using the module paramaters */
    422	settings->p2p_enable = !!brcmf_p2p_enable;
    423	settings->feature_disable = brcmf_feature_disable;
    424	settings->fcmode = brcmf_fcmode;
    425	settings->roamoff = !!brcmf_roamoff;
    426	settings->iapp = !!brcmf_iapp_enable;
    427#ifdef DEBUG
    428	settings->ignore_probe_fail = !!brcmf_ignore_probe_fail;
    429#endif
    430
    431	if (bus_type == BRCMF_BUSTYPE_SDIO)
    432		settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz;
    433
    434	/* See if there is any device specific platform data configured */
    435	found = false;
    436	if (brcmfmac_pdata) {
    437		for (i = 0; i < brcmfmac_pdata->device_count; i++) {
    438			device_pd = &brcmfmac_pdata->devices[i];
    439			if ((device_pd->bus_type == bus_type) &&
    440			    (device_pd->id == chip) &&
    441			    ((device_pd->rev == chiprev) ||
    442			     (device_pd->rev == -1))) {
    443				brcmf_dbg(INFO, "Platform data for device found\n");
    444				settings->country_codes =
    445						device_pd->country_codes;
    446				if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO)
    447					memcpy(&settings->bus.sdio,
    448					       &device_pd->bus.sdio,
    449					       sizeof(settings->bus.sdio));
    450				found = true;
    451				break;
    452			}
    453		}
    454	}
    455	if (!found) {
    456		/* No platform data for this device, try OF and DMI data */
    457		brcmf_dmi_probe(settings, chip, chiprev);
    458		brcmf_of_probe(dev, bus_type, settings);
    459	}
    460	return settings;
    461}
    462
    463void brcmf_release_module_param(struct brcmf_mp_device *module_param)
    464{
    465	kfree(module_param);
    466}
    467
    468static int __init brcmf_common_pd_probe(struct platform_device *pdev)
    469{
    470	brcmf_dbg(INFO, "Enter\n");
    471
    472	brcmfmac_pdata = dev_get_platdata(&pdev->dev);
    473
    474	if (brcmfmac_pdata->power_on)
    475		brcmfmac_pdata->power_on();
    476
    477	return 0;
    478}
    479
    480static int brcmf_common_pd_remove(struct platform_device *pdev)
    481{
    482	brcmf_dbg(INFO, "Enter\n");
    483
    484	if (brcmfmac_pdata->power_off)
    485		brcmfmac_pdata->power_off();
    486
    487	return 0;
    488}
    489
    490static struct platform_driver brcmf_pd = {
    491	.remove		= brcmf_common_pd_remove,
    492	.driver		= {
    493		.name	= BRCMFMAC_PDATA_NAME,
    494	}
    495};
    496
    497static int __init brcmfmac_module_init(void)
    498{
    499	int err;
    500
    501	/* Get the platform data (if available) for our devices */
    502	err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe);
    503	if (err == -ENODEV)
    504		brcmf_dbg(INFO, "No platform data available.\n");
    505
    506	/* Initialize global module paramaters */
    507	brcmf_mp_attach();
    508
    509	/* Continue the initialization by registering the different busses */
    510	err = brcmf_core_init();
    511	if (err) {
    512		if (brcmfmac_pdata)
    513			platform_driver_unregister(&brcmf_pd);
    514	}
    515
    516	return err;
    517}
    518
    519static void __exit brcmfmac_module_exit(void)
    520{
    521	brcmf_core_exit();
    522	if (brcmfmac_pdata)
    523		platform_driver_unregister(&brcmf_pd);
    524}
    525
    526module_init(brcmfmac_module_init);
    527module_exit(brcmfmac_module_exit);
    528