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 
24 MODULE_AUTHOR("Broadcom Corporation");
25 MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver.");
26 MODULE_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 
36 static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE;
37 module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0);
38 MODULE_PARM_DESC(txglomsz, "Maximum tx packet chain size [SDIO]");
39 
40 /* Debug level configuration. See debug.h for bits, sysfs modifiable */
41 int brcmf_msg_level;
42 module_param_named(debug, brcmf_msg_level, int, 0600);
43 MODULE_PARM_DESC(debug, "Level of debug output");
44 
45 static int brcmf_p2p_enable;
46 module_param_named(p2pon, brcmf_p2p_enable, int, 0);
47 MODULE_PARM_DESC(p2pon, "Enable legacy p2p management functionality");
48 
49 static int brcmf_feature_disable;
50 module_param_named(feature_disable, brcmf_feature_disable, int, 0);
51 MODULE_PARM_DESC(feature_disable, "Disable features");
52 
53 static char brcmf_firmware_path[BRCMF_FW_ALTPATH_LEN];
54 module_param_string(alternative_fw_path, brcmf_firmware_path,
55 		    BRCMF_FW_ALTPATH_LEN, 0400);
56 MODULE_PARM_DESC(alternative_fw_path, "Alternative firmware path");
57 
58 static int brcmf_fcmode;
59 module_param_named(fcmode, brcmf_fcmode, int, 0);
60 MODULE_PARM_DESC(fcmode, "Mode of firmware signalled flow control");
61 
62 static int brcmf_roamoff;
63 module_param_named(roamoff, brcmf_roamoff, int, 0400);
64 MODULE_PARM_DESC(roamoff, "Do not use internal roaming engine");
65 
66 static int brcmf_iapp_enable;
67 module_param_named(iapp, brcmf_iapp_enable, int, 0);
68 MODULE_PARM_DESC(iapp, "Enable partial support for the obsoleted Inter-Access Point Protocol");
69 
70 #ifdef DEBUG
71 /* always succeed brcmf_bus_started() */
72 static int brcmf_ignore_probe_fail;
73 module_param_named(ignore_probe_fail, brcmf_ignore_probe_fail, int, 0);
74 MODULE_PARM_DESC(ignore_probe_fail, "always succeed probe for debugging");
75 #endif
76 
77 static struct brcmfmac_platform_data *brcmfmac_pdata;
78 struct brcmf_mp_global_t brcmf_mp_global;
79 
80 void 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 
102 static 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 
120 static 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);
188 done:
189 	release_firmware(clm);
190 	return err;
191 }
192 
193 int brcmf_c_set_cur_etheraddr(struct brcmf_if *ifp, const u8 *addr)
194 {
195 	s32 err;
196 
197 	err = brcmf_fil_iovar_data_set(ifp, "cur_etheraddr", addr, ETH_ALEN);
198 	if (err < 0)
199 		bphy_err(ifp->drvr, "Setting cur_etheraddr failed, %d\n", err);
200 
201 	return err;
202 }
203 
204 /* On some boards there is no eeprom to hold the nvram, in this case instead
205  * a board specific nvram is loaded from /lib/firmware. On most boards the
206  * macaddr setting in the /lib/firmware nvram file is ignored because the
207  * wifibt chip has a unique MAC programmed into the chip itself.
208  * But in some cases the actual MAC from the /lib/firmware nvram file gets
209  * used, leading to MAC conflicts.
210  * The MAC addresses in the troublesome nvram files seem to all come from
211  * the same nvram file template, so we only need to check for 1 known
212  * address to detect this.
213  */
214 static const u8 brcmf_default_mac_address[ETH_ALEN] = {
215 	0x00, 0x90, 0x4c, 0xc5, 0x12, 0x38
216 };
217 
218 int brcmf_c_preinit_dcmds(struct brcmf_if *ifp)
219 {
220 	struct brcmf_pub *drvr = ifp->drvr;
221 	s8 eventmask[BRCMF_EVENTING_MASK_LEN];
222 	u8 buf[BRCMF_DCMD_SMLEN];
223 	struct brcmf_bus *bus;
224 	struct brcmf_rev_info_le revinfo;
225 	struct brcmf_rev_info *ri;
226 	char *clmver;
227 	char *ptr;
228 	s32 err;
229 
230 	if (is_valid_ether_addr(ifp->mac_addr)) {
231 		/* set mac address */
232 		err = brcmf_c_set_cur_etheraddr(ifp, ifp->mac_addr);
233 		if (err < 0)
234 			goto done;
235 	} else {
236 		/* retrieve mac address */
237 		err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr,
238 					       sizeof(ifp->mac_addr));
239 		if (err < 0) {
240 			bphy_err(drvr, "Retrieving cur_etheraddr failed, %d\n", err);
241 			goto done;
242 		}
243 
244 		if (ether_addr_equal_unaligned(ifp->mac_addr, brcmf_default_mac_address)) {
245 			bphy_err(drvr, "Default MAC is used, replacing with random MAC to avoid conflicts\n");
246 			eth_random_addr(ifp->mac_addr);
247 			ifp->ndev->addr_assign_type = NET_ADDR_RANDOM;
248 			err = brcmf_c_set_cur_etheraddr(ifp, ifp->mac_addr);
249 			if (err < 0)
250 				goto done;
251 		}
252 	}
253 
254 	memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac));
255 	memcpy(ifp->drvr->wiphy->perm_addr, ifp->drvr->mac, ETH_ALEN);
256 
257 	bus = ifp->drvr->bus_if;
258 	ri = &ifp->drvr->revinfo;
259 
260 	err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO,
261 				     &revinfo, sizeof(revinfo));
262 	if (err < 0) {
263 		bphy_err(drvr, "retrieving revision info failed, %d\n", err);
264 		strlcpy(ri->chipname, "UNKNOWN", sizeof(ri->chipname));
265 	} else {
266 		ri->vendorid = le32_to_cpu(revinfo.vendorid);
267 		ri->deviceid = le32_to_cpu(revinfo.deviceid);
268 		ri->radiorev = le32_to_cpu(revinfo.radiorev);
269 		ri->corerev = le32_to_cpu(revinfo.corerev);
270 		ri->boardid = le32_to_cpu(revinfo.boardid);
271 		ri->boardvendor = le32_to_cpu(revinfo.boardvendor);
272 		ri->boardrev = le32_to_cpu(revinfo.boardrev);
273 		ri->driverrev = le32_to_cpu(revinfo.driverrev);
274 		ri->ucoderev = le32_to_cpu(revinfo.ucoderev);
275 		ri->bus = le32_to_cpu(revinfo.bus);
276 		ri->phytype = le32_to_cpu(revinfo.phytype);
277 		ri->phyrev = le32_to_cpu(revinfo.phyrev);
278 		ri->anarev = le32_to_cpu(revinfo.anarev);
279 		ri->chippkg = le32_to_cpu(revinfo.chippkg);
280 		ri->nvramrev = le32_to_cpu(revinfo.nvramrev);
281 
282 		/* use revinfo if not known yet */
283 		if (!bus->chip) {
284 			bus->chip = le32_to_cpu(revinfo.chipnum);
285 			bus->chiprev = le32_to_cpu(revinfo.chiprev);
286 		}
287 	}
288 	ri->result = err;
289 
290 	if (bus->chip)
291 		brcmf_chip_name(bus->chip, bus->chiprev,
292 				ri->chipname, sizeof(ri->chipname));
293 
294 	/* Do any CLM downloading */
295 	err = brcmf_c_process_clm_blob(ifp);
296 	if (err < 0) {
297 		bphy_err(drvr, "download CLM blob file failed, %d\n", err);
298 		goto done;
299 	}
300 
301 	/* query for 'ver' to get version info from firmware */
302 	memset(buf, 0, sizeof(buf));
303 	err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf));
304 	if (err < 0) {
305 		bphy_err(drvr, "Retrieving version information failed, %d\n",
306 			 err);
307 		goto done;
308 	}
309 	ptr = (char *)buf;
310 	strsep(&ptr, "\n");
311 
312 	/* Print fw version info */
313 	brcmf_info("Firmware: %s %s\n", ri->chipname, buf);
314 
315 	/* locate firmware version number for ethtool */
316 	ptr = strrchr(buf, ' ') + 1;
317 	strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));
318 
319 	/* Query for 'clmver' to get CLM version info from firmware */
320 	memset(buf, 0, sizeof(buf));
321 	err = brcmf_fil_iovar_data_get(ifp, "clmver", buf, sizeof(buf));
322 	if (err) {
323 		brcmf_dbg(TRACE, "retrieving clmver failed, %d\n", err);
324 	} else {
325 		clmver = (char *)buf;
326 		/* store CLM version for adding it to revinfo debugfs file */
327 		memcpy(ifp->drvr->clmver, clmver, sizeof(ifp->drvr->clmver));
328 
329 		/* Replace all newline/linefeed characters with space
330 		 * character
331 		 */
332 		strreplace(clmver, '\n', ' ');
333 
334 		brcmf_dbg(INFO, "CLM version = %s\n", clmver);
335 	}
336 
337 	/* set mpc */
338 	err = brcmf_fil_iovar_int_set(ifp, "mpc", 1);
339 	if (err) {
340 		bphy_err(drvr, "failed setting mpc\n");
341 		goto done;
342 	}
343 
344 	brcmf_c_set_joinpref_default(ifp);
345 
346 	/* Setup event_msgs, enable E_IF */
347 	err = brcmf_fil_iovar_data_get(ifp, "event_msgs", eventmask,
348 				       BRCMF_EVENTING_MASK_LEN);
349 	if (err) {
350 		bphy_err(drvr, "Get event_msgs error (%d)\n", err);
351 		goto done;
352 	}
353 	setbit(eventmask, BRCMF_E_IF);
354 	err = brcmf_fil_iovar_data_set(ifp, "event_msgs", eventmask,
355 				       BRCMF_EVENTING_MASK_LEN);
356 	if (err) {
357 		bphy_err(drvr, "Set event_msgs error (%d)\n", err);
358 		goto done;
359 	}
360 
361 	/* Setup default scan channel time */
362 	err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
363 				    BRCMF_DEFAULT_SCAN_CHANNEL_TIME);
364 	if (err) {
365 		bphy_err(drvr, "BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n",
366 			 err);
367 		goto done;
368 	}
369 
370 	/* Setup default scan unassoc time */
371 	err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
372 				    BRCMF_DEFAULT_SCAN_UNASSOC_TIME);
373 	if (err) {
374 		bphy_err(drvr, "BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n",
375 			 err);
376 		goto done;
377 	}
378 
379 	/* Enable tx beamforming, errors can be ignored (not supported) */
380 	(void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);
381 done:
382 	return err;
383 }
384 
385 #ifndef CONFIG_BRCM_TRACING
386 void __brcmf_err(struct brcmf_bus *bus, const char *func, const char *fmt, ...)
387 {
388 	struct va_format vaf;
389 	va_list args;
390 
391 	va_start(args, fmt);
392 
393 	vaf.fmt = fmt;
394 	vaf.va = &args;
395 	if (bus)
396 		dev_err(bus->dev, "%s: %pV", func, &vaf);
397 	else
398 		pr_err("%s: %pV", func, &vaf);
399 
400 	va_end(args);
401 }
402 #endif
403 
404 #if defined(CONFIG_BRCM_TRACING) || defined(CONFIG_BRCMDBG)
405 void __brcmf_dbg(u32 level, const char *func, const char *fmt, ...)
406 {
407 	struct va_format vaf = {
408 		.fmt = fmt,
409 	};
410 	va_list args;
411 
412 	va_start(args, fmt);
413 	vaf.va = &args;
414 	if (brcmf_msg_level & level)
415 		pr_debug("%s %pV", func, &vaf);
416 	trace_brcmf_dbg(level, func, &vaf);
417 	va_end(args);
418 }
419 #endif
420 
421 static void brcmf_mp_attach(void)
422 {
423 	/* If module param firmware path is set then this will always be used,
424 	 * if not set then if available use the platform data version. To make
425 	 * sure it gets initialized at all, always copy the module param version
426 	 */
427 	strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
428 		BRCMF_FW_ALTPATH_LEN);
429 	if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&
430 	    (brcmf_mp_global.firmware_path[0] == '\0')) {
431 		strlcpy(brcmf_mp_global.firmware_path,
432 			brcmfmac_pdata->fw_alternative_path,
433 			BRCMF_FW_ALTPATH_LEN);
434 	}
435 }
436 
437 struct brcmf_mp_device *brcmf_get_module_param(struct device *dev,
438 					       enum brcmf_bus_type bus_type,
439 					       u32 chip, u32 chiprev)
440 {
441 	struct brcmf_mp_device *settings;
442 	struct brcmfmac_pd_device *device_pd;
443 	bool found;
444 	int i;
445 
446 	brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip,
447 		  chiprev);
448 	settings = kzalloc(sizeof(*settings), GFP_ATOMIC);
449 	if (!settings)
450 		return NULL;
451 
452 	/* start by using the module paramaters */
453 	settings->p2p_enable = !!brcmf_p2p_enable;
454 	settings->feature_disable = brcmf_feature_disable;
455 	settings->fcmode = brcmf_fcmode;
456 	settings->roamoff = !!brcmf_roamoff;
457 	settings->iapp = !!brcmf_iapp_enable;
458 #ifdef DEBUG
459 	settings->ignore_probe_fail = !!brcmf_ignore_probe_fail;
460 #endif
461 
462 	if (bus_type == BRCMF_BUSTYPE_SDIO)
463 		settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz;
464 
465 	/* See if there is any device specific platform data configured */
466 	found = false;
467 	if (brcmfmac_pdata) {
468 		for (i = 0; i < brcmfmac_pdata->device_count; i++) {
469 			device_pd = &brcmfmac_pdata->devices[i];
470 			if ((device_pd->bus_type == bus_type) &&
471 			    (device_pd->id == chip) &&
472 			    ((device_pd->rev == chiprev) ||
473 			     (device_pd->rev == -1))) {
474 				brcmf_dbg(INFO, "Platform data for device found\n");
475 				settings->country_codes =
476 						device_pd->country_codes;
477 				if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO)
478 					memcpy(&settings->bus.sdio,
479 					       &device_pd->bus.sdio,
480 					       sizeof(settings->bus.sdio));
481 				found = true;
482 				break;
483 			}
484 		}
485 	}
486 	if (!found) {
487 		/* No platform data for this device, try OF and DMI data */
488 		brcmf_dmi_probe(settings, chip, chiprev);
489 		brcmf_of_probe(dev, bus_type, settings);
490 	}
491 	return settings;
492 }
493 
494 void brcmf_release_module_param(struct brcmf_mp_device *module_param)
495 {
496 	kfree(module_param);
497 }
498 
499 static int __init brcmf_common_pd_probe(struct platform_device *pdev)
500 {
501 	brcmf_dbg(INFO, "Enter\n");
502 
503 	brcmfmac_pdata = dev_get_platdata(&pdev->dev);
504 
505 	if (brcmfmac_pdata->power_on)
506 		brcmfmac_pdata->power_on();
507 
508 	return 0;
509 }
510 
511 static int brcmf_common_pd_remove(struct platform_device *pdev)
512 {
513 	brcmf_dbg(INFO, "Enter\n");
514 
515 	if (brcmfmac_pdata->power_off)
516 		brcmfmac_pdata->power_off();
517 
518 	return 0;
519 }
520 
521 static struct platform_driver brcmf_pd = {
522 	.remove		= brcmf_common_pd_remove,
523 	.driver		= {
524 		.name	= BRCMFMAC_PDATA_NAME,
525 	}
526 };
527 
528 static int __init brcmfmac_module_init(void)
529 {
530 	int err;
531 
532 	/* Get the platform data (if available) for our devices */
533 	err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe);
534 	if (err == -ENODEV)
535 		brcmf_dbg(INFO, "No platform data available.\n");
536 
537 	/* Initialize global module paramaters */
538 	brcmf_mp_attach();
539 
540 	/* Continue the initialization by registering the different busses */
541 	err = brcmf_core_init();
542 	if (err) {
543 		if (brcmfmac_pdata)
544 			platform_driver_unregister(&brcmf_pd);
545 	}
546 
547 	return err;
548 }
549 
550 static void __exit brcmfmac_module_exit(void)
551 {
552 	brcmf_core_exit();
553 	if (brcmfmac_pdata)
554 		platform_driver_unregister(&brcmf_pd);
555 }
556 
557 module_init(brcmfmac_module_init);
558 module_exit(brcmfmac_module_exit);
559 
560