1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/kernel.h>
18#include <linux/string.h>
19#include <linux/netdevice.h>
20#include <linux/module.h>
21#include <brcmu_wifi.h>
22#include <brcmu_utils.h>
23#include "core.h"
24#include "bus.h"
25#include "debug.h"
26#include "fwil.h"
27#include "fwil_types.h"
28#include "tracepoint.h"
29#include "common.h"
30#include "of.h"
31
32MODULE_AUTHOR("Broadcom Corporation");
33MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver.");
34MODULE_LICENSE("Dual BSD/GPL");
35
36const u8 ALLFFMAC[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
37
38#define BRCMF_DEFAULT_SCAN_CHANNEL_TIME 40
39#define BRCMF_DEFAULT_SCAN_UNASSOC_TIME 40
40
41
42#define BRCMF_JOIN_PREF_RSSI_BOOST 8
43
44#define BRCMF_DEFAULT_TXGLOM_SIZE 32
45
46static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE;
47module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0);
48MODULE_PARM_DESC(txglomsz, "Maximum tx packet chain size [SDIO]");
49
50
51int brcmf_msg_level;
52module_param_named(debug, brcmf_msg_level, int, S_IRUSR | S_IWUSR);
53MODULE_PARM_DESC(debug, "Level of debug output");
54
55static int brcmf_p2p_enable;
56module_param_named(p2pon, brcmf_p2p_enable, int, 0);
57MODULE_PARM_DESC(p2pon, "Enable legacy p2p management functionality");
58
59static int brcmf_feature_disable;
60module_param_named(feature_disable, brcmf_feature_disable, int, 0);
61MODULE_PARM_DESC(feature_disable, "Disable features");
62
63static char brcmf_firmware_path[BRCMF_FW_ALTPATH_LEN];
64module_param_string(alternative_fw_path, brcmf_firmware_path,
65 BRCMF_FW_ALTPATH_LEN, S_IRUSR);
66MODULE_PARM_DESC(alternative_fw_path, "Alternative firmware path");
67
68static int brcmf_fcmode;
69module_param_named(fcmode, brcmf_fcmode, int, 0);
70MODULE_PARM_DESC(fcmode, "Mode of firmware signalled flow control");
71
72static int brcmf_roamoff;
73module_param_named(roamoff, brcmf_roamoff, int, S_IRUSR);
74MODULE_PARM_DESC(roamoff, "Do not use internal roaming engine");
75
76#ifdef DEBUG
77
78static int brcmf_ignore_probe_fail;
79module_param_named(ignore_probe_fail, brcmf_ignore_probe_fail, int, 0);
80MODULE_PARM_DESC(ignore_probe_fail, "always succeed probe for debugging");
81#endif
82
83static struct brcmfmac_platform_data *brcmfmac_pdata;
84struct brcmf_mp_global_t brcmf_mp_global;
85
86int brcmf_c_preinit_dcmds(struct brcmf_if *ifp)
87{
88 s8 eventmask[BRCMF_EVENTING_MASK_LEN];
89 u8 buf[BRCMF_DCMD_SMLEN];
90 struct brcmf_join_pref_params join_pref_params[2];
91 struct brcmf_rev_info_le revinfo;
92 struct brcmf_rev_info *ri;
93 char *ptr;
94 s32 err;
95
96
97 err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr,
98 sizeof(ifp->mac_addr));
99 if (err < 0) {
100 brcmf_err("Retreiving cur_etheraddr failed, %d\n", err);
101 goto done;
102 }
103 memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac));
104
105 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO,
106 &revinfo, sizeof(revinfo));
107 ri = &ifp->drvr->revinfo;
108 if (err < 0) {
109 brcmf_err("retrieving revision info failed, %d\n", err);
110 } else {
111 ri->vendorid = le32_to_cpu(revinfo.vendorid);
112 ri->deviceid = le32_to_cpu(revinfo.deviceid);
113 ri->radiorev = le32_to_cpu(revinfo.radiorev);
114 ri->chiprev = le32_to_cpu(revinfo.chiprev);
115 ri->corerev = le32_to_cpu(revinfo.corerev);
116 ri->boardid = le32_to_cpu(revinfo.boardid);
117 ri->boardvendor = le32_to_cpu(revinfo.boardvendor);
118 ri->boardrev = le32_to_cpu(revinfo.boardrev);
119 ri->driverrev = le32_to_cpu(revinfo.driverrev);
120 ri->ucoderev = le32_to_cpu(revinfo.ucoderev);
121 ri->bus = le32_to_cpu(revinfo.bus);
122 ri->chipnum = le32_to_cpu(revinfo.chipnum);
123 ri->phytype = le32_to_cpu(revinfo.phytype);
124 ri->phyrev = le32_to_cpu(revinfo.phyrev);
125 ri->anarev = le32_to_cpu(revinfo.anarev);
126 ri->chippkg = le32_to_cpu(revinfo.chippkg);
127 ri->nvramrev = le32_to_cpu(revinfo.nvramrev);
128 }
129 ri->result = err;
130
131
132 memset(buf, 0, sizeof(buf));
133 strcpy(buf, "ver");
134 err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf));
135 if (err < 0) {
136 brcmf_err("Retreiving version information failed, %d\n",
137 err);
138 goto done;
139 }
140 ptr = (char *)buf;
141 strsep(&ptr, "\n");
142
143
144 brcmf_err("Firmware version = %s\n", buf);
145
146
147 ptr = strrchr(buf, ' ') + 1;
148 strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));
149
150
151 err = brcmf_fil_iovar_int_set(ifp, "mpc", 1);
152 if (err) {
153 brcmf_err("failed setting mpc\n");
154 goto done;
155 }
156
157
158 join_pref_params[0].type = BRCMF_JOIN_PREF_RSSI_DELTA;
159 join_pref_params[0].len = 2;
160 join_pref_params[0].rssi_gain = BRCMF_JOIN_PREF_RSSI_BOOST;
161 join_pref_params[0].band = WLC_BAND_5G;
162 join_pref_params[1].type = BRCMF_JOIN_PREF_RSSI;
163 join_pref_params[1].len = 2;
164 join_pref_params[1].rssi_gain = 0;
165 join_pref_params[1].band = 0;
166 err = brcmf_fil_iovar_data_set(ifp, "join_pref", join_pref_params,
167 sizeof(join_pref_params));
168 if (err)
169 brcmf_err("Set join_pref error (%d)\n", err);
170
171
172 err = brcmf_fil_iovar_data_get(ifp, "event_msgs", eventmask,
173 BRCMF_EVENTING_MASK_LEN);
174 if (err) {
175 brcmf_err("Get event_msgs error (%d)\n", err);
176 goto done;
177 }
178 setbit(eventmask, BRCMF_E_IF);
179 err = brcmf_fil_iovar_data_set(ifp, "event_msgs", eventmask,
180 BRCMF_EVENTING_MASK_LEN);
181 if (err) {
182 brcmf_err("Set event_msgs error (%d)\n", err);
183 goto done;
184 }
185
186
187 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
188 BRCMF_DEFAULT_SCAN_CHANNEL_TIME);
189 if (err) {
190 brcmf_err("BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n",
191 err);
192 goto done;
193 }
194
195
196 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
197 BRCMF_DEFAULT_SCAN_UNASSOC_TIME);
198 if (err) {
199 brcmf_err("BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n",
200 err);
201 goto done;
202 }
203
204
205 (void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);
206
207
208 err = brcmf_bus_preinit(ifp->drvr->bus_if);
209done:
210 return err;
211}
212
213#if defined(CONFIG_BRCM_TRACING) || defined(CONFIG_BRCMDBG)
214void __brcmf_dbg(u32 level, const char *func, const char *fmt, ...)
215{
216 struct va_format vaf = {
217 .fmt = fmt,
218 };
219 va_list args;
220
221 va_start(args, fmt);
222 vaf.va = &args;
223 if (brcmf_msg_level & level)
224 pr_debug("%s %pV", func, &vaf);
225 trace_brcmf_dbg(level, func, &vaf);
226 va_end(args);
227}
228#endif
229
230static void brcmf_mp_attach(void)
231{
232
233
234
235
236 strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
237 BRCMF_FW_ALTPATH_LEN);
238 if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&
239 (brcmf_mp_global.firmware_path[0] == '\0')) {
240 strlcpy(brcmf_mp_global.firmware_path,
241 brcmfmac_pdata->fw_alternative_path,
242 BRCMF_FW_ALTPATH_LEN);
243 }
244}
245
246struct brcmf_mp_device *brcmf_get_module_param(struct device *dev,
247 enum brcmf_bus_type bus_type,
248 u32 chip, u32 chiprev)
249{
250 struct brcmf_mp_device *settings;
251 struct brcmfmac_pd_device *device_pd;
252 bool found;
253 int i;
254
255 brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip,
256 chiprev);
257 settings = kzalloc(sizeof(*settings), GFP_ATOMIC);
258 if (!settings)
259 return NULL;
260
261
262 settings->p2p_enable = !!brcmf_p2p_enable;
263 settings->feature_disable = brcmf_feature_disable;
264 settings->fcmode = brcmf_fcmode;
265 settings->roamoff = !!brcmf_roamoff;
266#ifdef DEBUG
267 settings->ignore_probe_fail = !!brcmf_ignore_probe_fail;
268#endif
269
270 if (bus_type == BRCMF_BUSTYPE_SDIO)
271 settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz;
272
273
274 found = false;
275 if (brcmfmac_pdata) {
276 for (i = 0; i < brcmfmac_pdata->device_count; i++) {
277 device_pd = &brcmfmac_pdata->devices[i];
278 if ((device_pd->bus_type == bus_type) &&
279 (device_pd->id == chip) &&
280 ((device_pd->rev == chiprev) ||
281 (device_pd->rev == -1))) {
282 brcmf_dbg(INFO, "Platform data for device found\n");
283 settings->country_codes =
284 device_pd->country_codes;
285 if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO)
286 memcpy(&settings->bus.sdio,
287 &device_pd->bus.sdio,
288 sizeof(settings->bus.sdio));
289 found = true;
290 break;
291 }
292 }
293 }
294 if ((bus_type == BRCMF_BUSTYPE_SDIO) && (!found)) {
295
296
297
298 brcmf_of_probe(dev, &settings->bus.sdio);
299 }
300 return settings;
301}
302
303void brcmf_release_module_param(struct brcmf_mp_device *module_param)
304{
305 kfree(module_param);
306}
307
308static int __init brcmf_common_pd_probe(struct platform_device *pdev)
309{
310 brcmf_dbg(INFO, "Enter\n");
311
312 brcmfmac_pdata = dev_get_platdata(&pdev->dev);
313
314 if (brcmfmac_pdata->power_on)
315 brcmfmac_pdata->power_on();
316
317 return 0;
318}
319
320static int brcmf_common_pd_remove(struct platform_device *pdev)
321{
322 brcmf_dbg(INFO, "Enter\n");
323
324 if (brcmfmac_pdata->power_off)
325 brcmfmac_pdata->power_off();
326
327 return 0;
328}
329
330static struct platform_driver brcmf_pd = {
331 .remove = brcmf_common_pd_remove,
332 .driver = {
333 .name = BRCMFMAC_PDATA_NAME,
334 }
335};
336
337static int __init brcmfmac_module_init(void)
338{
339 int err;
340
341
342 brcmf_debugfs_init();
343
344
345 err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe);
346 if (err == -ENODEV)
347 brcmf_dbg(INFO, "No platform data available.\n");
348
349
350 brcmf_mp_attach();
351
352
353 err = brcmf_core_init();
354 if (err) {
355 brcmf_debugfs_exit();
356 if (brcmfmac_pdata)
357 platform_driver_unregister(&brcmf_pd);
358 }
359
360 return err;
361}
362
363static void __exit brcmfmac_module_exit(void)
364{
365 brcmf_core_exit();
366 if (brcmfmac_pdata)
367 platform_driver_unregister(&brcmf_pd);
368 brcmf_debugfs_exit();
369}
370
371module_init(brcmfmac_module_init);
372module_exit(brcmfmac_module_exit);
373
374
