1
2
3
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
32#define BRCMF_JOIN_PREF_RSSI_BOOST 8
33
34#define BRCMF_DEFAULT_TXGLOM_SIZE 32
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
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
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
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
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
206 err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr,
207 sizeof(ifp->mac_addr));
208 if (err < 0) {
209 bphy_err(drvr, "Retrieving cur_etheraddr failed, %d\n", err);
210 goto done;
211 }
212 memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac));
213 memcpy(ifp->drvr->wiphy->perm_addr, ifp->drvr->mac, ETH_ALEN);
214
215 bus = ifp->drvr->bus_if;
216 ri = &ifp->drvr->revinfo;
217
218 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO,
219 &revinfo, sizeof(revinfo));
220 if (err < 0) {
221 bphy_err(drvr, "retrieving revision info failed, %d\n", err);
222 strlcpy(ri->chipname, "UNKNOWN", sizeof(ri->chipname));
223 } else {
224 ri->vendorid = le32_to_cpu(revinfo.vendorid);
225 ri->deviceid = le32_to_cpu(revinfo.deviceid);
226 ri->radiorev = le32_to_cpu(revinfo.radiorev);
227 ri->corerev = le32_to_cpu(revinfo.corerev);
228 ri->boardid = le32_to_cpu(revinfo.boardid);
229 ri->boardvendor = le32_to_cpu(revinfo.boardvendor);
230 ri->boardrev = le32_to_cpu(revinfo.boardrev);
231 ri->driverrev = le32_to_cpu(revinfo.driverrev);
232 ri->ucoderev = le32_to_cpu(revinfo.ucoderev);
233 ri->bus = le32_to_cpu(revinfo.bus);
234 ri->phytype = le32_to_cpu(revinfo.phytype);
235 ri->phyrev = le32_to_cpu(revinfo.phyrev);
236 ri->anarev = le32_to_cpu(revinfo.anarev);
237 ri->chippkg = le32_to_cpu(revinfo.chippkg);
238 ri->nvramrev = le32_to_cpu(revinfo.nvramrev);
239
240
241 if (!bus->chip) {
242 bus->chip = le32_to_cpu(revinfo.chipnum);
243 bus->chiprev = le32_to_cpu(revinfo.chiprev);
244 }
245 }
246 ri->result = err;
247
248 if (bus->chip)
249 brcmf_chip_name(bus->chip, bus->chiprev,
250 ri->chipname, sizeof(ri->chipname));
251
252
253 err = brcmf_c_process_clm_blob(ifp);
254 if (err < 0) {
255 bphy_err(drvr, "download CLM blob file failed, %d\n", err);
256 goto done;
257 }
258
259
260 memset(buf, 0, sizeof(buf));
261 err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf));
262 if (err < 0) {
263 bphy_err(drvr, "Retrieving version information failed, %d\n",
264 err);
265 goto done;
266 }
267 ptr = (char *)buf;
268 strsep(&ptr, "\n");
269
270
271 brcmf_info("Firmware: %s %s\n", ri->chipname, buf);
272
273
274 ptr = strrchr(buf, ' ') + 1;
275 strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));
276
277
278 memset(buf, 0, sizeof(buf));
279 err = brcmf_fil_iovar_data_get(ifp, "clmver", buf, sizeof(buf));
280 if (err) {
281 brcmf_dbg(TRACE, "retrieving clmver failed, %d\n", err);
282 } else {
283 clmver = (char *)buf;
284
285 memcpy(ifp->drvr->clmver, clmver, sizeof(ifp->drvr->clmver));
286
287
288
289
290 strreplace(clmver, '\n', ' ');
291
292 brcmf_dbg(INFO, "CLM version = %s\n", clmver);
293 }
294
295
296 err = brcmf_fil_iovar_int_set(ifp, "mpc", 1);
297 if (err) {
298 bphy_err(drvr, "failed setting mpc\n");
299 goto done;
300 }
301
302 brcmf_c_set_joinpref_default(ifp);
303
304
305 err = brcmf_fil_iovar_data_get(ifp, "event_msgs", eventmask,
306 BRCMF_EVENTING_MASK_LEN);
307 if (err) {
308 bphy_err(drvr, "Get event_msgs error (%d)\n", err);
309 goto done;
310 }
311 setbit(eventmask, BRCMF_E_IF);
312 err = brcmf_fil_iovar_data_set(ifp, "event_msgs", eventmask,
313 BRCMF_EVENTING_MASK_LEN);
314 if (err) {
315 bphy_err(drvr, "Set event_msgs error (%d)\n", err);
316 goto done;
317 }
318
319
320 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
321 BRCMF_DEFAULT_SCAN_CHANNEL_TIME);
322 if (err) {
323 bphy_err(drvr, "BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n",
324 err);
325 goto done;
326 }
327
328
329 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
330 BRCMF_DEFAULT_SCAN_UNASSOC_TIME);
331 if (err) {
332 bphy_err(drvr, "BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n",
333 err);
334 goto done;
335 }
336
337
338 (void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);
339done:
340 return err;
341}
342
343#ifndef CONFIG_BRCM_TRACING
344void __brcmf_err(struct brcmf_bus *bus, const char *func, const char *fmt, ...)
345{
346 struct va_format vaf;
347 va_list args;
348
349 va_start(args, fmt);
350
351 vaf.fmt = fmt;
352 vaf.va = &args;
353 if (bus)
354 dev_err(bus->dev, "%s: %pV", func, &vaf);
355 else
356 pr_err("%s: %pV", func, &vaf);
357
358 va_end(args);
359}
360#endif
361
362#if defined(CONFIG_BRCM_TRACING) || defined(CONFIG_BRCMDBG)
363void __brcmf_dbg(u32 level, const char *func, const char *fmt, ...)
364{
365 struct va_format vaf = {
366 .fmt = fmt,
367 };
368 va_list args;
369
370 va_start(args, fmt);
371 vaf.va = &args;
372 if (brcmf_msg_level & level)
373 pr_debug("%s %pV", func, &vaf);
374 trace_brcmf_dbg(level, func, &vaf);
375 va_end(args);
376}
377#endif
378
379static void brcmf_mp_attach(void)
380{
381
382
383
384
385 strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
386 BRCMF_FW_ALTPATH_LEN);
387 if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&
388 (brcmf_mp_global.firmware_path[0] == '\0')) {
389 strlcpy(brcmf_mp_global.firmware_path,
390 brcmfmac_pdata->fw_alternative_path,
391 BRCMF_FW_ALTPATH_LEN);
392 }
393}
394
395struct brcmf_mp_device *brcmf_get_module_param(struct device *dev,
396 enum brcmf_bus_type bus_type,
397 u32 chip, u32 chiprev)
398{
399 struct brcmf_mp_device *settings;
400 struct brcmfmac_pd_device *device_pd;
401 bool found;
402 int i;
403
404 brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip,
405 chiprev);
406 settings = kzalloc(sizeof(*settings), GFP_ATOMIC);
407 if (!settings)
408 return NULL;
409
410
411 settings->p2p_enable = !!brcmf_p2p_enable;
412 settings->feature_disable = brcmf_feature_disable;
413 settings->fcmode = brcmf_fcmode;
414 settings->roamoff = !!brcmf_roamoff;
415 settings->iapp = !!brcmf_iapp_enable;
416#ifdef DEBUG
417 settings->ignore_probe_fail = !!brcmf_ignore_probe_fail;
418#endif
419
420 if (bus_type == BRCMF_BUSTYPE_SDIO)
421 settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz;
422
423
424 found = false;
425 if (brcmfmac_pdata) {
426 for (i = 0; i < brcmfmac_pdata->device_count; i++) {
427 device_pd = &brcmfmac_pdata->devices[i];
428 if ((device_pd->bus_type == bus_type) &&
429 (device_pd->id == chip) &&
430 ((device_pd->rev == chiprev) ||
431 (device_pd->rev == -1))) {
432 brcmf_dbg(INFO, "Platform data for device found\n");
433 settings->country_codes =
434 device_pd->country_codes;
435 if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO)
436 memcpy(&settings->bus.sdio,
437 &device_pd->bus.sdio,
438 sizeof(settings->bus.sdio));
439 found = true;
440 break;
441 }
442 }
443 }
444 if (!found) {
445
446 brcmf_dmi_probe(settings, chip, chiprev);
447 brcmf_of_probe(dev, bus_type, settings);
448 }
449 return settings;
450}
451
452void brcmf_release_module_param(struct brcmf_mp_device *module_param)
453{
454 kfree(module_param);
455}
456
457static int __init brcmf_common_pd_probe(struct platform_device *pdev)
458{
459 brcmf_dbg(INFO, "Enter\n");
460
461 brcmfmac_pdata = dev_get_platdata(&pdev->dev);
462
463 if (brcmfmac_pdata->power_on)
464 brcmfmac_pdata->power_on();
465
466 return 0;
467}
468
469static int brcmf_common_pd_remove(struct platform_device *pdev)
470{
471 brcmf_dbg(INFO, "Enter\n");
472
473 if (brcmfmac_pdata->power_off)
474 brcmfmac_pdata->power_off();
475
476 return 0;
477}
478
479static struct platform_driver brcmf_pd = {
480 .remove = brcmf_common_pd_remove,
481 .driver = {
482 .name = BRCMFMAC_PDATA_NAME,
483 }
484};
485
486static int __init brcmfmac_module_init(void)
487{
488 int err;
489
490
491 err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe);
492 if (err == -ENODEV)
493 brcmf_dbg(INFO, "No platform data available.\n");
494
495
496 brcmf_mp_attach();
497
498
499 err = brcmf_core_init();
500 if (err) {
501 if (brcmfmac_pdata)
502 platform_driver_unregister(&brcmf_pd);
503 }
504
505 return err;
506}
507
508static void __exit brcmfmac_module_exit(void)
509{
510 brcmf_core_exit();
511 if (brcmfmac_pdata)
512 platform_driver_unregister(&brcmf_pd);
513}
514
515module_init(brcmfmac_module_init);
516module_exit(brcmfmac_module_exit);
517
518
