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