drivers/net/wireless/broadcom/brcm80211/brcmfmac/common.c - hafnium/third_party/linux - Git at Google

 // SPDX-License-Identifier: ISC
 /*
  * Copyright (c) 2010 Broadcom Corporation
  */

 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/netdevice.h>
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <brcmu_wifi.h>
 #include <brcmu_utils.h>
 #include "core.h"
 #include "bus.h"
 #include "debug.h"
 #include "fwil.h"
 #include "fwil_types.h"
 #include "tracepoint.h"
 #include "common.h"
 #include "of.h"
 #include "firmware.h"
 #include "chip.h"

 MODULE_AUTHOR("Broadcom Corporation");
 MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver.");
 MODULE_LICENSE("Dual BSD/GPL");

 #define BRCMF_DEFAULT_SCAN_CHANNEL_TIME	40
 #define BRCMF_DEFAULT_SCAN_UNASSOC_TIME	40

 /* default boost value for RSSI_DELTA in preferred join selection */
 #define BRCMF_JOIN_PREF_RSSI_BOOST	8

 #define BRCMF_DEFAULT_TXGLOM_SIZE	32  /* max tx frames in glom chain */

 static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE;
 module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0);
 MODULE_PARM_DESC(txglomsz, "Maximum tx packet chain size [SDIO]");

 /* Debug level configuration. See debug.h for bits, sysfs modifiable */
 int brcmf_msg_level;
 module_param_named(debug, brcmf_msg_level, int, 0600);
 MODULE_PARM_DESC(debug, "Level of debug output");

 static int brcmf_p2p_enable;
 module_param_named(p2pon, brcmf_p2p_enable, int, 0);
 MODULE_PARM_DESC(p2pon, "Enable legacy p2p management functionality");

 static int brcmf_feature_disable;
 module_param_named(feature_disable, brcmf_feature_disable, int, 0);
 MODULE_PARM_DESC(feature_disable, "Disable features");

 static char brcmf_firmware_path[BRCMF_FW_ALTPATH_LEN];
 module_param_string(alternative_fw_path, brcmf_firmware_path,
 		    BRCMF_FW_ALTPATH_LEN, 0400);
 MODULE_PARM_DESC(alternative_fw_path, "Alternative firmware path");

 static int brcmf_fcmode;
 module_param_named(fcmode, brcmf_fcmode, int, 0);
 MODULE_PARM_DESC(fcmode, "Mode of firmware signalled flow control");

 static int brcmf_roamoff;
 module_param_named(roamoff, brcmf_roamoff, int, 0400);
 MODULE_PARM_DESC(roamoff, "Do not use internal roaming engine");

 static int brcmf_iapp_enable;
 module_param_named(iapp, brcmf_iapp_enable, int, 0);
 MODULE_PARM_DESC(iapp, "Enable partial support for the obsoleted Inter-Access Point Protocol");

 #ifdef DEBUG
 /* always succeed brcmf_bus_started() */
 static int brcmf_ignore_probe_fail;
 module_param_named(ignore_probe_fail, brcmf_ignore_probe_fail, int, 0);
 MODULE_PARM_DESC(ignore_probe_fail, "always succeed probe for debugging");
 #endif

 static struct brcmfmac_platform_data *brcmfmac_pdata;
 struct brcmf_mp_global_t brcmf_mp_global;

 void brcmf_c_set_joinpref_default(struct brcmf_if *ifp)
 {
 	struct brcmf_pub *drvr = ifp->drvr;
 	struct brcmf_join_pref_params join_pref_params[2];
 	int err;

 	/* Setup join_pref to select target by RSSI (boost on 5GHz) */
 	join_pref_params[0].type = BRCMF_JOIN_PREF_RSSI_DELTA;
 	join_pref_params[0].len = 2;
 	join_pref_params[0].rssi_gain = BRCMF_JOIN_PREF_RSSI_BOOST;
 	join_pref_params[0].band = WLC_BAND_5G;

 	join_pref_params[1].type = BRCMF_JOIN_PREF_RSSI;
 	join_pref_params[1].len = 2;
 	join_pref_params[1].rssi_gain = 0;
 	join_pref_params[1].band = 0;
 	err = brcmf_fil_iovar_data_set(ifp, "join_pref", join_pref_params,
 				       sizeof(join_pref_params));
 	if (err)
 		bphy_err(drvr, "Set join_pref error (%d)\n", err);
 }

 static int brcmf_c_download(struct brcmf_if *ifp, u16 flag,
 			    struct brcmf_dload_data_le *dload_buf,
 			    u32 len)
 {
 	s32 err;

 	flag |= (DLOAD_HANDLER_VER << DLOAD_FLAG_VER_SHIFT);
 	dload_buf->flag = cpu_to_le16(flag);
 	dload_buf->dload_type = cpu_to_le16(DL_TYPE_CLM);
 	dload_buf->len = cpu_to_le32(len);
 	dload_buf->crc = cpu_to_le32(0);
 	len = sizeof(*dload_buf) + len - 1;

 	err = brcmf_fil_iovar_data_set(ifp, "clmload", dload_buf, len);

 	return err;
 }

 static int brcmf_c_process_clm_blob(struct brcmf_if *ifp)
 {
 	struct brcmf_pub *drvr = ifp->drvr;
 	struct brcmf_bus *bus = drvr->bus_if;
 	struct brcmf_dload_data_le *chunk_buf;
 	const struct firmware *clm = NULL;
 	u8 clm_name[BRCMF_FW_NAME_LEN];
 	u32 chunk_len;
 	u32 datalen;
 	u32 cumulative_len;
 	u16 dl_flag = DL_BEGIN;
 	u32 status;
 	s32 err;

 	brcmf_dbg(TRACE, "Enter\n");

 	memset(clm_name, 0, sizeof(clm_name));
 	err = brcmf_bus_get_fwname(bus, ".clm_blob", clm_name);
 	if (err) {
 		bphy_err(drvr, "get CLM blob file name failed (%d)\n", err);
 		return err;
 	}

 	err = firmware_request_nowarn(&clm, clm_name, bus->dev);
 	if (err) {
 		brcmf_info("no clm_blob available (err=%d), device may have limited channels available\n",
 			   err);
 		return 0;
 	}

 	chunk_buf = kzalloc(sizeof(*chunk_buf) + MAX_CHUNK_LEN - 1, GFP_KERNEL);
 	if (!chunk_buf) {
 		err = -ENOMEM;
 		goto done;
 	}

 	datalen = clm->size;
 	cumulative_len = 0;
 	do {
 		if (datalen > MAX_CHUNK_LEN) {
 			chunk_len = MAX_CHUNK_LEN;
 		} else {
 			chunk_len = datalen;
 			dl_flag |= DL_END;
 		}
 		memcpy(chunk_buf->data, clm->data + cumulative_len, chunk_len);

 		err = brcmf_c_download(ifp, dl_flag, chunk_buf, chunk_len);

 		dl_flag &= ~DL_BEGIN;

 		cumulative_len += chunk_len;
 		datalen -= chunk_len;
 	} while ((datalen > 0) && (err == 0));

 	if (err) {
 		bphy_err(drvr, "clmload (%zu byte file) failed (%d)\n",
 			 clm->size, err);
 		/* Retrieve clmload_status and print */
 		err = brcmf_fil_iovar_int_get(ifp, "clmload_status", &status);
 		if (err)
 			bphy_err(drvr, "get clmload_status failed (%d)\n", err);
 		else
 			brcmf_dbg(INFO, "clmload_status=%d\n", status);
 		err = -EIO;
 	}

 	kfree(chunk_buf);
 done:
 	release_firmware(clm);
 	return err;
 }

 int brcmf_c_preinit_dcmds(struct brcmf_if *ifp)
 {
 	struct brcmf_pub *drvr = ifp->drvr;
 	s8 eventmask[BRCMF_EVENTING_MASK_LEN];
 	u8 buf[BRCMF_DCMD_SMLEN];
 	struct brcmf_bus *bus;
 	struct brcmf_rev_info_le revinfo;
 	struct brcmf_rev_info *ri;
 	char *clmver;
 	char *ptr;
 	s32 err;

 	/* retreive mac address */
 	err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr,
 				       sizeof(ifp->mac_addr));
 	if (err < 0) {
 		bphy_err(drvr, "Retrieving cur_etheraddr failed, %d\n", err);
 		goto done;
 	}
 	memcpy(ifp->drvr->wiphy->perm_addr, ifp->drvr->mac, ETH_ALEN);
 	memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac));

 	bus = ifp->drvr->bus_if;
 	ri = &ifp->drvr->revinfo;

 	err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO,
 				     &revinfo, sizeof(revinfo));
 	if (err < 0) {
 		bphy_err(drvr, "retrieving revision info failed, %d\n", err);
 		strlcpy(ri->chipname, "UNKNOWN", sizeof(ri->chipname));
 	} else {
 		ri->vendorid = le32_to_cpu(revinfo.vendorid);
 		ri->deviceid = le32_to_cpu(revinfo.deviceid);
 		ri->radiorev = le32_to_cpu(revinfo.radiorev);
 		ri->corerev = le32_to_cpu(revinfo.corerev);
 		ri->boardid = le32_to_cpu(revinfo.boardid);
 		ri->boardvendor = le32_to_cpu(revinfo.boardvendor);
 		ri->boardrev = le32_to_cpu(revinfo.boardrev);
 		ri->driverrev = le32_to_cpu(revinfo.driverrev);
 		ri->ucoderev = le32_to_cpu(revinfo.ucoderev);
 		ri->bus = le32_to_cpu(revinfo.bus);
 		ri->phytype = le32_to_cpu(revinfo.phytype);
 		ri->phyrev = le32_to_cpu(revinfo.phyrev);
 		ri->anarev = le32_to_cpu(revinfo.anarev);
 		ri->chippkg = le32_to_cpu(revinfo.chippkg);
 		ri->nvramrev = le32_to_cpu(revinfo.nvramrev);

 		/* use revinfo if not known yet */
 		if (!bus->chip) {
 			bus->chip = le32_to_cpu(revinfo.chipnum);
 			bus->chiprev = le32_to_cpu(revinfo.chiprev);
 		}
 	}
 	ri->result = err;

 	if (bus->chip)
 		brcmf_chip_name(bus->chip, bus->chiprev,
 				ri->chipname, sizeof(ri->chipname));

 	/* Do any CLM downloading */
 	err = brcmf_c_process_clm_blob(ifp);
 	if (err < 0) {
 		bphy_err(drvr, "download CLM blob file failed, %d\n", err);
 		goto done;
 	}

 	/* query for 'ver' to get version info from firmware */
 	memset(buf, 0, sizeof(buf));
 	err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf));
 	if (err < 0) {
 		bphy_err(drvr, "Retrieving version information failed, %d\n",
 			 err);
 		goto done;
 	}
 	ptr = (char *)buf;
 	strsep(&ptr, "\n");

 	/* Print fw version info */
 	brcmf_info("Firmware: %s %s\n", ri->chipname, buf);

 	/* locate firmware version number for ethtool */
 	ptr = strrchr(buf, ' ') + 1;
 	strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));

 	/* Query for 'clmver' to get CLM version info from firmware */
 	memset(buf, 0, sizeof(buf));
 	err = brcmf_fil_iovar_data_get(ifp, "clmver", buf, sizeof(buf));
 	if (err) {
 		brcmf_dbg(TRACE, "retrieving clmver failed, %d\n", err);
 	} else {
 		clmver = (char *)buf;
 		/* store CLM version for adding it to revinfo debugfs file */
 		memcpy(ifp->drvr->clmver, clmver, sizeof(ifp->drvr->clmver));

 		/* Replace all newline/linefeed characters with space
 		 * character
 		 */
 		strreplace(clmver, '\n', ' ');

 		brcmf_dbg(INFO, "CLM version = %s\n", clmver);
 	}

 	/* set mpc */
 	err = brcmf_fil_iovar_int_set(ifp, "mpc", 1);
 	if (err) {
 		bphy_err(drvr, "failed setting mpc\n");
 		goto done;
 	}

 	brcmf_c_set_joinpref_default(ifp);

 	/* Setup event_msgs, enable E_IF */
 	err = brcmf_fil_iovar_data_get(ifp, "event_msgs", eventmask,
 				       BRCMF_EVENTING_MASK_LEN);
 	if (err) {
 		bphy_err(drvr, "Get event_msgs error (%d)\n", err);
 		goto done;
 	}
 	setbit(eventmask, BRCMF_E_IF);
 	err = brcmf_fil_iovar_data_set(ifp, "event_msgs", eventmask,
 				       BRCMF_EVENTING_MASK_LEN);
 	if (err) {
 		bphy_err(drvr, "Set event_msgs error (%d)\n", err);
 		goto done;
 	}

 	/* Setup default scan channel time */
 	err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
 				    BRCMF_DEFAULT_SCAN_CHANNEL_TIME);
 	if (err) {
 		bphy_err(drvr, "BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n",
 			 err);
 		goto done;
 	}

 	/* Setup default scan unassoc time */
 	err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
 				    BRCMF_DEFAULT_SCAN_UNASSOC_TIME);
 	if (err) {
 		bphy_err(drvr, "BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n",
 			 err);
 		goto done;
 	}

 	/* Enable tx beamforming, errors can be ignored (not supported) */
 	(void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);
 done:
 	return err;
 }

 #ifndef CONFIG_BRCM_TRACING
 void __brcmf_err(struct brcmf_bus *bus, const char *func, const char *fmt, ...)
 {
 	struct va_format vaf;
 	va_list args;

 	va_start(args, fmt);

 	vaf.fmt = fmt;
 	vaf.va = &args;
 	if (bus)
 		dev_err(bus->dev, "%s: %pV", func, &vaf);
 	else
 		pr_err("%s: %pV", func, &vaf);

 	va_end(args);
 }
 #endif

 #if defined(CONFIG_BRCM_TRACING) || defined(CONFIG_BRCMDBG)
 void __brcmf_dbg(u32 level, const char *func, const char *fmt, ...)
 {
 	struct va_format vaf = {
 		.fmt = fmt,
 	};
 	va_list args;

 	va_start(args, fmt);
 	vaf.va = &args;
 	if (brcmf_msg_level & level)
 		pr_debug("%s %pV", func, &vaf);
 	trace_brcmf_dbg(level, func, &vaf);
 	va_end(args);
 }
 #endif

 static void brcmf_mp_attach(void)
 {
 	/* If module param firmware path is set then this will always be used,
 	 * if not set then if available use the platform data version. To make
 	 * sure it gets initialized at all, always copy the module param version
 	 */
 	strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
 		BRCMF_FW_ALTPATH_LEN);
 	if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&
 	    (brcmf_mp_global.firmware_path[0] == '\0')) {
 		strlcpy(brcmf_mp_global.firmware_path,
 			brcmfmac_pdata->fw_alternative_path,
 			BRCMF_FW_ALTPATH_LEN);
 	}
 }

 struct brcmf_mp_device *brcmf_get_module_param(struct device *dev,
 					       enum brcmf_bus_type bus_type,
 					       u32 chip, u32 chiprev)
 {
 	struct brcmf_mp_device *settings;
 	struct brcmfmac_pd_device *device_pd;
 	bool found;
 	int i;

 	brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip,
 		  chiprev);
 	settings = kzalloc(sizeof(*settings), GFP_ATOMIC);
 	if (!settings)
 		return NULL;

 	/* start by using the module paramaters */
 	settings->p2p_enable = !!brcmf_p2p_enable;
 	settings->feature_disable = brcmf_feature_disable;
 	settings->fcmode = brcmf_fcmode;
 	settings->roamoff = !!brcmf_roamoff;
 	settings->iapp = !!brcmf_iapp_enable;
 #ifdef DEBUG
 	settings->ignore_probe_fail = !!brcmf_ignore_probe_fail;
 #endif

 	if (bus_type == BRCMF_BUSTYPE_SDIO)
 		settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz;

 	/* See if there is any device specific platform data configured */
 	found = false;
 	if (brcmfmac_pdata) {
 		for (i = 0; i < brcmfmac_pdata->device_count; i++) {
 			device_pd = &brcmfmac_pdata->devices[i];
 			if ((device_pd->bus_type == bus_type) &&
 			    (device_pd->id == chip) &&
 			    ((device_pd->rev == chiprev) ||
 			     (device_pd->rev == -1))) {
 				brcmf_dbg(INFO, "Platform data for device found\n");
 				settings->country_codes =
 						device_pd->country_codes;
 				if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO)
 					memcpy(&settings->bus.sdio,
 					       &device_pd->bus.sdio,
 					       sizeof(settings->bus.sdio));
 				found = true;
 				break;
 			}
 		}
 	}
 	if (!found) {
 		/* No platform data for this device, try OF and DMI data */
 		brcmf_dmi_probe(settings, chip, chiprev);
 		brcmf_of_probe(dev, bus_type, settings);
 	}
 	return settings;
 }

 void brcmf_release_module_param(struct brcmf_mp_device *module_param)
 {
 	kfree(module_param);
 }

 static int __init brcmf_common_pd_probe(struct platform_device *pdev)
 {
 	brcmf_dbg(INFO, "Enter\n");

 	brcmfmac_pdata = dev_get_platdata(&pdev->dev);

 	if (brcmfmac_pdata->power_on)
 		brcmfmac_pdata->power_on();

 	return 0;
 }

 static int brcmf_common_pd_remove(struct platform_device *pdev)
 {
 	brcmf_dbg(INFO, "Enter\n");

 	if (brcmfmac_pdata->power_off)
 		brcmfmac_pdata->power_off();

 	return 0;
 }

 static struct platform_driver brcmf_pd = {
 	.remove		= brcmf_common_pd_remove,
 	.driver		= {
 		.name	= BRCMFMAC_PDATA_NAME,
 	}
 };

 static int __init brcmfmac_module_init(void)
 {
 	int err;

 	/* Get the platform data (if available) for our devices */
 	err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe);
 	if (err == -ENODEV)
 		brcmf_dbg(INFO, "No platform data available.\n");

 	/* Initialize global module paramaters */
 	brcmf_mp_attach();

 	/* Continue the initialization by registering the different busses */
 	err = brcmf_core_init();
 	if (err) {
 		if (brcmfmac_pdata)
 			platform_driver_unregister(&brcmf_pd);
 	}

 	return err;
 }

 static void __exit brcmfmac_module_exit(void)
 {
 	brcmf_core_exit();
 	if (brcmfmac_pdata)
 		platform_driver_unregister(&brcmf_pd);
 }

 module_init(brcmfmac_module_init);
 module_exit(brcmfmac_module_exit);
	// SPDX-License-Identifier: ISC
	/*
	* Copyright (c) 2010 Broadcom Corporation
	*/

	#include <linux/kernel.h>
	#include <linux/string.h>
	#include <linux/netdevice.h>
	#include <linux/module.h>
	#include <linux/firmware.h>
	#include <brcmu_wifi.h>
	#include <brcmu_utils.h>
	#include "core.h"
	#include "bus.h"
	#include "debug.h"
	#include "fwil.h"
	#include "fwil_types.h"
	#include "tracepoint.h"
	#include "common.h"
	#include "of.h"
	#include "firmware.h"
	#include "chip.h"

	MODULE_AUTHOR("Broadcom Corporation");
	MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver.");
	MODULE_LICENSE("Dual BSD/GPL");

	#define BRCMF_DEFAULT_SCAN_CHANNEL_TIME 40
	#define BRCMF_DEFAULT_SCAN_UNASSOC_TIME 40

	/* default boost value for RSSI_DELTA in preferred join selection */
	#define BRCMF_JOIN_PREF_RSSI_BOOST 8

	#define BRCMF_DEFAULT_TXGLOM_SIZE 32 /* max tx frames in glom chain */

	static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE;
	module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0);
	MODULE_PARM_DESC(txglomsz, "Maximum tx packet chain size [SDIO]");

	/* Debug level configuration. See debug.h for bits, sysfs modifiable */
	int brcmf_msg_level;
	module_param_named(debug, brcmf_msg_level, int, 0600);
	MODULE_PARM_DESC(debug, "Level of debug output");

	static int brcmf_p2p_enable;
	module_param_named(p2pon, brcmf_p2p_enable, int, 0);
	MODULE_PARM_DESC(p2pon, "Enable legacy p2p management functionality");

	static int brcmf_feature_disable;
	module_param_named(feature_disable, brcmf_feature_disable, int, 0);
	MODULE_PARM_DESC(feature_disable, "Disable features");

	static char brcmf_firmware_path[BRCMF_FW_ALTPATH_LEN];
	module_param_string(alternative_fw_path, brcmf_firmware_path,
	BRCMF_FW_ALTPATH_LEN, 0400);
	MODULE_PARM_DESC(alternative_fw_path, "Alternative firmware path");

	static int brcmf_fcmode;
	module_param_named(fcmode, brcmf_fcmode, int, 0);
	MODULE_PARM_DESC(fcmode, "Mode of firmware signalled flow control");

	static int brcmf_roamoff;
	module_param_named(roamoff, brcmf_roamoff, int, 0400);
	MODULE_PARM_DESC(roamoff, "Do not use internal roaming engine");

	static int brcmf_iapp_enable;
	module_param_named(iapp, brcmf_iapp_enable, int, 0);
	MODULE_PARM_DESC(iapp, "Enable partial support for the obsoleted Inter-Access Point Protocol");

	#ifdef DEBUG
	/* always succeed brcmf_bus_started() */
	static int brcmf_ignore_probe_fail;
	module_param_named(ignore_probe_fail, brcmf_ignore_probe_fail, int, 0);
	MODULE_PARM_DESC(ignore_probe_fail, "always succeed probe for debugging");
	#endif

	static struct brcmfmac_platform_data *brcmfmac_pdata;
	struct brcmf_mp_global_t brcmf_mp_global;

	void brcmf_c_set_joinpref_default(struct brcmf_if *ifp)
	{
	struct brcmf_pub *drvr = ifp->drvr;
	struct brcmf_join_pref_params join_pref_params[2];
	int err;

	/* Setup join_pref to select target by RSSI (boost on 5GHz) */
	join_pref_params[0].type = BRCMF_JOIN_PREF_RSSI_DELTA;
	join_pref_params[0].len = 2;
	join_pref_params[0].rssi_gain = BRCMF_JOIN_PREF_RSSI_BOOST;
	join_pref_params[0].band = WLC_BAND_5G;

	join_pref_params[1].type = BRCMF_JOIN_PREF_RSSI;
	join_pref_params[1].len = 2;
	join_pref_params[1].rssi_gain = 0;
	join_pref_params[1].band = 0;
	err = brcmf_fil_iovar_data_set(ifp, "join_pref", join_pref_params,
	sizeof(join_pref_params));
	if (err)
	bphy_err(drvr, "Set join_pref error (%d)\n", err);
	}

	static int brcmf_c_download(struct brcmf_if *ifp, u16 flag,
	struct brcmf_dload_data_le *dload_buf,
	u32 len)
	{
	s32 err;

	flag \|= (DLOAD_HANDLER_VER << DLOAD_FLAG_VER_SHIFT);
	dload_buf->flag = cpu_to_le16(flag);
	dload_buf->dload_type = cpu_to_le16(DL_TYPE_CLM);
	dload_buf->len = cpu_to_le32(len);
	dload_buf->crc = cpu_to_le32(0);
	len = sizeof(*dload_buf) + len - 1;

	err = brcmf_fil_iovar_data_set(ifp, "clmload", dload_buf, len);

	return err;
	}

	static int brcmf_c_process_clm_blob(struct brcmf_if *ifp)
	{
	struct brcmf_pub *drvr = ifp->drvr;
	struct brcmf_bus *bus = drvr->bus_if;
	struct brcmf_dload_data_le *chunk_buf;
	const struct firmware *clm = NULL;
	u8 clm_name[BRCMF_FW_NAME_LEN];
	u32 chunk_len;
	u32 datalen;
	u32 cumulative_len;
	u16 dl_flag = DL_BEGIN;
	u32 status;
	s32 err;

	brcmf_dbg(TRACE, "Enter\n");

	memset(clm_name, 0, sizeof(clm_name));
	err = brcmf_bus_get_fwname(bus, ".clm_blob", clm_name);
	if (err) {
	bphy_err(drvr, "get CLM blob file name failed (%d)\n", err);
	return err;
	}

	err = firmware_request_nowarn(&clm, clm_name, bus->dev);
	if (err) {
	brcmf_info("no clm_blob available (err=%d), device may have limited channels available\n",
	err);
	return 0;
	}

	chunk_buf = kzalloc(sizeof(*chunk_buf) + MAX_CHUNK_LEN - 1, GFP_KERNEL);
	if (!chunk_buf) {
	err = -ENOMEM;
	goto done;
	}

	datalen = clm->size;
	cumulative_len = 0;
	do {
	if (datalen > MAX_CHUNK_LEN) {
	chunk_len = MAX_CHUNK_LEN;
	} else {
	chunk_len = datalen;
	dl_flag \|= DL_END;
	}
	memcpy(chunk_buf->data, clm->data + cumulative_len, chunk_len);

	err = brcmf_c_download(ifp, dl_flag, chunk_buf, chunk_len);

	dl_flag &= ~DL_BEGIN;

	cumulative_len += chunk_len;
	datalen -= chunk_len;
	} while ((datalen > 0) && (err == 0));

	if (err) {
	bphy_err(drvr, "clmload (%zu byte file) failed (%d)\n",
	clm->size, err);
	/* Retrieve clmload_status and print */
	err = brcmf_fil_iovar_int_get(ifp, "clmload_status", &status);
	if (err)
	bphy_err(drvr, "get clmload_status failed (%d)\n", err);
	else
	brcmf_dbg(INFO, "clmload_status=%d\n", status);
	err = -EIO;
	}

	kfree(chunk_buf);
	done:
	release_firmware(clm);
	return err;
	}

	int brcmf_c_preinit_dcmds(struct brcmf_if *ifp)
	{
	struct brcmf_pub *drvr = ifp->drvr;
	s8 eventmask[BRCMF_EVENTING_MASK_LEN];
	u8 buf[BRCMF_DCMD_SMLEN];
	struct brcmf_bus *bus;
	struct brcmf_rev_info_le revinfo;
	struct brcmf_rev_info *ri;
	char *clmver;
	char *ptr;
	s32 err;

	/* retreive mac address */
	err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr,
	sizeof(ifp->mac_addr));
	if (err < 0) {
	bphy_err(drvr, "Retrieving cur_etheraddr failed, %d\n", err);
	goto done;
	}
	memcpy(ifp->drvr->wiphy->perm_addr, ifp->drvr->mac, ETH_ALEN);
	memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac));

	bus = ifp->drvr->bus_if;
	ri = &ifp->drvr->revinfo;

	err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO,
	&revinfo, sizeof(revinfo));
	if (err < 0) {
	bphy_err(drvr, "retrieving revision info failed, %d\n", err);
	strlcpy(ri->chipname, "UNKNOWN", sizeof(ri->chipname));
	} else {
	ri->vendorid = le32_to_cpu(revinfo.vendorid);
	ri->deviceid = le32_to_cpu(revinfo.deviceid);
	ri->radiorev = le32_to_cpu(revinfo.radiorev);
	ri->corerev = le32_to_cpu(revinfo.corerev);
	ri->boardid = le32_to_cpu(revinfo.boardid);
	ri->boardvendor = le32_to_cpu(revinfo.boardvendor);
	ri->boardrev = le32_to_cpu(revinfo.boardrev);
	ri->driverrev = le32_to_cpu(revinfo.driverrev);
	ri->ucoderev = le32_to_cpu(revinfo.ucoderev);
	ri->bus = le32_to_cpu(revinfo.bus);
	ri->phytype = le32_to_cpu(revinfo.phytype);
	ri->phyrev = le32_to_cpu(revinfo.phyrev);
	ri->anarev = le32_to_cpu(revinfo.anarev);
	ri->chippkg = le32_to_cpu(revinfo.chippkg);
	ri->nvramrev = le32_to_cpu(revinfo.nvramrev);

	/* use revinfo if not known yet */
	if (!bus->chip) {
	bus->chip = le32_to_cpu(revinfo.chipnum);
	bus->chiprev = le32_to_cpu(revinfo.chiprev);
	}
	}
	ri->result = err;

	if (bus->chip)
	brcmf_chip_name(bus->chip, bus->chiprev,
	ri->chipname, sizeof(ri->chipname));

	/* Do any CLM downloading */
	err = brcmf_c_process_clm_blob(ifp);
	if (err < 0) {
	bphy_err(drvr, "download CLM blob file failed, %d\n", err);
	goto done;
	}

	/* query for 'ver' to get version info from firmware */
	memset(buf, 0, sizeof(buf));
	err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf));
	if (err < 0) {
	bphy_err(drvr, "Retrieving version information failed, %d\n",
	err);
	goto done;
	}
	ptr = (char *)buf;
	strsep(&ptr, "\n");

	/* Print fw version info */
	brcmf_info("Firmware: %s %s\n", ri->chipname, buf);

	/* locate firmware version number for ethtool */
	ptr = strrchr(buf, ' ') + 1;
	strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));

	/* Query for 'clmver' to get CLM version info from firmware */
	memset(buf, 0, sizeof(buf));
	err = brcmf_fil_iovar_data_get(ifp, "clmver", buf, sizeof(buf));
	if (err) {
	brcmf_dbg(TRACE, "retrieving clmver failed, %d\n", err);
	} else {
	clmver = (char *)buf;
	/* store CLM version for adding it to revinfo debugfs file */
	memcpy(ifp->drvr->clmver, clmver, sizeof(ifp->drvr->clmver));

	/* Replace all newline/linefeed characters with space
	* character
	*/
	strreplace(clmver, '\n', ' ');

	brcmf_dbg(INFO, "CLM version = %s\n", clmver);
	}

	/* set mpc */
	err = brcmf_fil_iovar_int_set(ifp, "mpc", 1);
	if (err) {
	bphy_err(drvr, "failed setting mpc\n");
	goto done;
	}

	brcmf_c_set_joinpref_default(ifp);

	/* Setup event_msgs, enable E_IF */
	err = brcmf_fil_iovar_data_get(ifp, "event_msgs", eventmask,
	BRCMF_EVENTING_MASK_LEN);
	if (err) {
	bphy_err(drvr, "Get event_msgs error (%d)\n", err);
	goto done;
	}
	setbit(eventmask, BRCMF_E_IF);
	err = brcmf_fil_iovar_data_set(ifp, "event_msgs", eventmask,
	BRCMF_EVENTING_MASK_LEN);
	if (err) {
	bphy_err(drvr, "Set event_msgs error (%d)\n", err);
	goto done;
	}

	/* Setup default scan channel time */
	err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
	BRCMF_DEFAULT_SCAN_CHANNEL_TIME);
	if (err) {
	bphy_err(drvr, "BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n",
	err);
	goto done;
	}

	/* Setup default scan unassoc time */
	err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
	BRCMF_DEFAULT_SCAN_UNASSOC_TIME);
	if (err) {
	bphy_err(drvr, "BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n",
	err);
	goto done;
	}

	/* Enable tx beamforming, errors can be ignored (not supported) */
	(void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);
	done:
	return err;
	}

	#ifndef CONFIG_BRCM_TRACING
	void __brcmf_err(struct brcmf_bus bus, const char func, const char *fmt, ...)
	{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;
	if (bus)
	dev_err(bus->dev, "%s: %pV", func, &vaf);
	else
	pr_err("%s: %pV", func, &vaf);

	va_end(args);
	}
	#endif

	#if defined(CONFIG_BRCM_TRACING) \|\| defined(CONFIG_BRCMDBG)
	void __brcmf_dbg(u32 level, const char func, const char fmt, ...)
	{
	struct va_format vaf = {
	.fmt = fmt,
	};
	va_list args;

	va_start(args, fmt);
	vaf.va = &args;
	if (brcmf_msg_level & level)
	pr_debug("%s %pV", func, &vaf);
	trace_brcmf_dbg(level, func, &vaf);
	va_end(args);
	}
	#endif

	static void brcmf_mp_attach(void)
	{
	/* If module param firmware path is set then this will always be used,
	* if not set then if available use the platform data version. To make
	* sure it gets initialized at all, always copy the module param version
	*/
	strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
	BRCMF_FW_ALTPATH_LEN);
	if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&
	(brcmf_mp_global.firmware_path[0] == '\0')) {
	strlcpy(brcmf_mp_global.firmware_path,
	brcmfmac_pdata->fw_alternative_path,
	BRCMF_FW_ALTPATH_LEN);
	}
	}

	struct brcmf_mp_device brcmf_get_module_param(struct device dev,
	enum brcmf_bus_type bus_type,
	u32 chip, u32 chiprev)
	{
	struct brcmf_mp_device *settings;
	struct brcmfmac_pd_device *device_pd;
	bool found;
	int i;

	brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip,
	chiprev);
	settings = kzalloc(sizeof(*settings), GFP_ATOMIC);
	if (!settings)
	return NULL;

	/* start by using the module paramaters */
	settings->p2p_enable = !!brcmf_p2p_enable;
	settings->feature_disable = brcmf_feature_disable;
	settings->fcmode = brcmf_fcmode;
	settings->roamoff = !!brcmf_roamoff;
	settings->iapp = !!brcmf_iapp_enable;
	#ifdef DEBUG
	settings->ignore_probe_fail = !!brcmf_ignore_probe_fail;
	#endif

	if (bus_type == BRCMF_BUSTYPE_SDIO)
	settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz;

	/* See if there is any device specific platform data configured */
	found = false;
	if (brcmfmac_pdata) {
	for (i = 0; i < brcmfmac_pdata->device_count; i++) {
	device_pd = &brcmfmac_pdata->devices[i];
	if ((device_pd->bus_type == bus_type) &&
	(device_pd->id == chip) &&
	((device_pd->rev == chiprev) \|\|
	(device_pd->rev == -1))) {
	brcmf_dbg(INFO, "Platform data for device found\n");
	settings->country_codes =
	device_pd->country_codes;
	if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO)
	memcpy(&settings->bus.sdio,
	&device_pd->bus.sdio,
	sizeof(settings->bus.sdio));
	found = true;
	break;
	}
	}
	}
	if (!found) {
	/* No platform data for this device, try OF and DMI data */
	brcmf_dmi_probe(settings, chip, chiprev);
	brcmf_of_probe(dev, bus_type, settings);
	}
	return settings;
	}

	void brcmf_release_module_param(struct brcmf_mp_device *module_param)
	{
	kfree(module_param);
	}

	static int __init brcmf_common_pd_probe(struct platform_device *pdev)
	{
	brcmf_dbg(INFO, "Enter\n");

	brcmfmac_pdata = dev_get_platdata(&pdev->dev);

	if (brcmfmac_pdata->power_on)
	brcmfmac_pdata->power_on();

	return 0;
	}

	static int brcmf_common_pd_remove(struct platform_device *pdev)
	{
	brcmf_dbg(INFO, "Enter\n");

	if (brcmfmac_pdata->power_off)
	brcmfmac_pdata->power_off();

	return 0;
	}

	static struct platform_driver brcmf_pd = {
	.remove = brcmf_common_pd_remove,
	.driver = {
	.name = BRCMFMAC_PDATA_NAME,
	}
	};

	static int __init brcmfmac_module_init(void)
	{
	int err;

	/* Get the platform data (if available) for our devices */
	err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe);
	if (err == -ENODEV)
	brcmf_dbg(INFO, "No platform data available.\n");

	/* Initialize global module paramaters */
	brcmf_mp_attach();

	/* Continue the initialization by registering the different busses */
	err = brcmf_core_init();
	if (err) {
	if (brcmfmac_pdata)
	platform_driver_unregister(&brcmf_pd);
	}

	return err;
	}

	static void __exit brcmfmac_module_exit(void)
	{
	brcmf_core_exit();
	if (brcmfmac_pdata)
	platform_driver_unregister(&brcmf_pd);
	}

	module_init(brcmfmac_module_init);
	module_exit(brcmfmac_module_exit);