1 /* 2 * Copyright (c) 2010 Broadcom Corporation 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 #include <linux/kernel.h> 18 #include <linux/string.h> 19 #include <linux/netdevice.h> 20 #include <linux/module.h> 21 #include <linux/firmware.h> 22 #include <brcmu_wifi.h> 23 #include <brcmu_utils.h> 24 #include "core.h" 25 #include "bus.h" 26 #include "debug.h" 27 #include "fwil.h" 28 #include "fwil_types.h" 29 #include "tracepoint.h" 30 #include "common.h" 31 #include "of.h" 32 #include "firmware.h" 33 34 MODULE_AUTHOR("Broadcom Corporation"); 35 MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver."); 36 MODULE_LICENSE("Dual BSD/GPL"); 37 38 const u8 ALLFFMAC[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 39 40 #define BRCMF_DEFAULT_SCAN_CHANNEL_TIME 40 41 #define BRCMF_DEFAULT_SCAN_UNASSOC_TIME 40 42 43 /* default boost value for RSSI_DELTA in preferred join selection */ 44 #define BRCMF_JOIN_PREF_RSSI_BOOST 8 45 46 #define BRCMF_DEFAULT_TXGLOM_SIZE 32 /* max tx frames in glom chain */ 47 48 static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE; 49 module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0); 50 MODULE_PARM_DESC(txglomsz, "Maximum tx packet chain size [SDIO]"); 51 52 /* Debug level configuration. See debug.h for bits, sysfs modifiable */ 53 int brcmf_msg_level; 54 module_param_named(debug, brcmf_msg_level, int, S_IRUSR | S_IWUSR); 55 MODULE_PARM_DESC(debug, "Level of debug output"); 56 57 static int brcmf_p2p_enable; 58 module_param_named(p2pon, brcmf_p2p_enable, int, 0); 59 MODULE_PARM_DESC(p2pon, "Enable legacy p2p management functionality"); 60 61 static int brcmf_feature_disable; 62 module_param_named(feature_disable, brcmf_feature_disable, int, 0); 63 MODULE_PARM_DESC(feature_disable, "Disable features"); 64 65 static char brcmf_firmware_path[BRCMF_FW_ALTPATH_LEN]; 66 module_param_string(alternative_fw_path, brcmf_firmware_path, 67 BRCMF_FW_ALTPATH_LEN, S_IRUSR); 68 MODULE_PARM_DESC(alternative_fw_path, "Alternative firmware path"); 69 70 static int brcmf_fcmode; 71 module_param_named(fcmode, brcmf_fcmode, int, 0); 72 MODULE_PARM_DESC(fcmode, "Mode of firmware signalled flow control"); 73 74 static int brcmf_roamoff; 75 module_param_named(roamoff, brcmf_roamoff, int, S_IRUSR); 76 MODULE_PARM_DESC(roamoff, "Do not use internal roaming engine"); 77 78 static int brcmf_iapp_enable; 79 module_param_named(iapp, brcmf_iapp_enable, int, 0); 80 MODULE_PARM_DESC(iapp, "Enable partial support for the obsoleted Inter-Access Point Protocol"); 81 82 #ifdef DEBUG 83 /* always succeed brcmf_bus_started() */ 84 static int brcmf_ignore_probe_fail; 85 module_param_named(ignore_probe_fail, brcmf_ignore_probe_fail, int, 0); 86 MODULE_PARM_DESC(ignore_probe_fail, "always succeed probe for debugging"); 87 #endif 88 89 static struct brcmfmac_platform_data *brcmfmac_pdata; 90 struct brcmf_mp_global_t brcmf_mp_global; 91 92 void brcmf_c_set_joinpref_default(struct brcmf_if *ifp) 93 { 94 struct brcmf_join_pref_params join_pref_params[2]; 95 int err; 96 97 /* Setup join_pref to select target by RSSI (boost on 5GHz) */ 98 join_pref_params[0].type = BRCMF_JOIN_PREF_RSSI_DELTA; 99 join_pref_params[0].len = 2; 100 join_pref_params[0].rssi_gain = BRCMF_JOIN_PREF_RSSI_BOOST; 101 join_pref_params[0].band = WLC_BAND_5G; 102 103 join_pref_params[1].type = BRCMF_JOIN_PREF_RSSI; 104 join_pref_params[1].len = 2; 105 join_pref_params[1].rssi_gain = 0; 106 join_pref_params[1].band = 0; 107 err = brcmf_fil_iovar_data_set(ifp, "join_pref", join_pref_params, 108 sizeof(join_pref_params)); 109 if (err) 110 brcmf_err("Set join_pref error (%d)\n", err); 111 } 112 113 static int brcmf_c_download(struct brcmf_if *ifp, u16 flag, 114 struct brcmf_dload_data_le *dload_buf, 115 u32 len) 116 { 117 s32 err; 118 119 flag |= (DLOAD_HANDLER_VER << DLOAD_FLAG_VER_SHIFT); 120 dload_buf->flag = cpu_to_le16(flag); 121 dload_buf->dload_type = cpu_to_le16(DL_TYPE_CLM); 122 dload_buf->len = cpu_to_le32(len); 123 dload_buf->crc = cpu_to_le32(0); 124 len = sizeof(*dload_buf) + len - 1; 125 126 err = brcmf_fil_iovar_data_set(ifp, "clmload", dload_buf, len); 127 128 return err; 129 } 130 131 static int brcmf_c_get_clm_name(struct brcmf_if *ifp, u8 *clm_name) 132 { 133 struct brcmf_bus *bus = ifp->drvr->bus_if; 134 struct brcmf_rev_info *ri = &ifp->drvr->revinfo; 135 u8 fw_name[BRCMF_FW_NAME_LEN]; 136 u8 *ptr; 137 size_t len; 138 s32 err; 139 140 memset(fw_name, 0, BRCMF_FW_NAME_LEN); 141 err = brcmf_bus_get_fwname(bus, ri->chipnum, ri->chiprev, fw_name); 142 if (err) { 143 brcmf_err("get firmware name failed (%d)\n", err); 144 goto done; 145 } 146 147 /* generate CLM blob file name */ 148 ptr = strrchr(fw_name, '.'); 149 if (!ptr) { 150 err = -ENOENT; 151 goto done; 152 } 153 154 len = ptr - fw_name + 1; 155 if (len + strlen(".clm_blob") > BRCMF_FW_NAME_LEN) { 156 err = -E2BIG; 157 } else { 158 strlcpy(clm_name, fw_name, len); 159 strlcat(clm_name, ".clm_blob", BRCMF_FW_NAME_LEN); 160 } 161 done: 162 return err; 163 } 164 165 static int brcmf_c_process_clm_blob(struct brcmf_if *ifp) 166 { 167 struct device *dev = ifp->drvr->bus_if->dev; 168 struct brcmf_dload_data_le *chunk_buf; 169 const struct firmware *clm = NULL; 170 u8 clm_name[BRCMF_FW_NAME_LEN]; 171 u32 chunk_len; 172 u32 datalen; 173 u32 cumulative_len; 174 u16 dl_flag = DL_BEGIN; 175 u32 status; 176 s32 err; 177 178 brcmf_dbg(TRACE, "Enter\n"); 179 180 memset(clm_name, 0, BRCMF_FW_NAME_LEN); 181 err = brcmf_c_get_clm_name(ifp, clm_name); 182 if (err) { 183 brcmf_err("get CLM blob file name failed (%d)\n", err); 184 return err; 185 } 186 187 err = request_firmware(&clm, clm_name, dev); 188 if (err) { 189 brcmf_info("no clm_blob available(err=%d), device may have limited channels available\n", 190 err); 191 return 0; 192 } 193 194 chunk_buf = kzalloc(sizeof(*chunk_buf) + MAX_CHUNK_LEN - 1, GFP_KERNEL); 195 if (!chunk_buf) { 196 err = -ENOMEM; 197 goto done; 198 } 199 200 datalen = clm->size; 201 cumulative_len = 0; 202 do { 203 if (datalen > MAX_CHUNK_LEN) { 204 chunk_len = MAX_CHUNK_LEN; 205 } else { 206 chunk_len = datalen; 207 dl_flag |= DL_END; 208 } 209 memcpy(chunk_buf->data, clm->data + cumulative_len, chunk_len); 210 211 err = brcmf_c_download(ifp, dl_flag, chunk_buf, chunk_len); 212 213 dl_flag &= ~DL_BEGIN; 214 215 cumulative_len += chunk_len; 216 datalen -= chunk_len; 217 } while ((datalen > 0) && (err == 0)); 218 219 if (err) { 220 brcmf_err("clmload (%zu byte file) failed (%d); ", 221 clm->size, err); 222 /* Retrieve clmload_status and print */ 223 err = brcmf_fil_iovar_int_get(ifp, "clmload_status", &status); 224 if (err) 225 brcmf_err("get clmload_status failed (%d)\n", err); 226 else 227 brcmf_dbg(INFO, "clmload_status=%d\n", status); 228 err = -EIO; 229 } 230 231 kfree(chunk_buf); 232 done: 233 release_firmware(clm); 234 return err; 235 } 236 237 int brcmf_c_preinit_dcmds(struct brcmf_if *ifp) 238 { 239 s8 eventmask[BRCMF_EVENTING_MASK_LEN]; 240 u8 buf[BRCMF_DCMD_SMLEN]; 241 struct brcmf_rev_info_le revinfo; 242 struct brcmf_rev_info *ri; 243 char *clmver; 244 char *ptr; 245 s32 err; 246 247 /* retreive mac address */ 248 err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr, 249 sizeof(ifp->mac_addr)); 250 if (err < 0) { 251 brcmf_err("Retreiving cur_etheraddr failed, %d\n", err); 252 goto done; 253 } 254 memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac)); 255 256 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO, 257 &revinfo, sizeof(revinfo)); 258 ri = &ifp->drvr->revinfo; 259 if (err < 0) { 260 brcmf_err("retrieving revision info failed, %d\n", err); 261 } else { 262 ri->vendorid = le32_to_cpu(revinfo.vendorid); 263 ri->deviceid = le32_to_cpu(revinfo.deviceid); 264 ri->radiorev = le32_to_cpu(revinfo.radiorev); 265 ri->chiprev = le32_to_cpu(revinfo.chiprev); 266 ri->corerev = le32_to_cpu(revinfo.corerev); 267 ri->boardid = le32_to_cpu(revinfo.boardid); 268 ri->boardvendor = le32_to_cpu(revinfo.boardvendor); 269 ri->boardrev = le32_to_cpu(revinfo.boardrev); 270 ri->driverrev = le32_to_cpu(revinfo.driverrev); 271 ri->ucoderev = le32_to_cpu(revinfo.ucoderev); 272 ri->bus = le32_to_cpu(revinfo.bus); 273 ri->chipnum = le32_to_cpu(revinfo.chipnum); 274 ri->phytype = le32_to_cpu(revinfo.phytype); 275 ri->phyrev = le32_to_cpu(revinfo.phyrev); 276 ri->anarev = le32_to_cpu(revinfo.anarev); 277 ri->chippkg = le32_to_cpu(revinfo.chippkg); 278 ri->nvramrev = le32_to_cpu(revinfo.nvramrev); 279 } 280 ri->result = err; 281 282 /* Do any CLM downloading */ 283 err = brcmf_c_process_clm_blob(ifp); 284 if (err < 0) { 285 brcmf_err("download CLM blob file failed, %d\n", err); 286 goto done; 287 } 288 289 /* query for 'ver' to get version info from firmware */ 290 memset(buf, 0, sizeof(buf)); 291 strcpy(buf, "ver"); 292 err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf)); 293 if (err < 0) { 294 brcmf_err("Retreiving version information failed, %d\n", 295 err); 296 goto done; 297 } 298 ptr = (char *)buf; 299 strsep(&ptr, "\n"); 300 301 /* Print fw version info */ 302 brcmf_info("Firmware version = %s\n", buf); 303 304 /* locate firmware version number for ethtool */ 305 ptr = strrchr(buf, ' ') + 1; 306 strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver)); 307 308 /* Query for 'clmver' to get CLM version info from firmware */ 309 memset(buf, 0, sizeof(buf)); 310 err = brcmf_fil_iovar_data_get(ifp, "clmver", buf, sizeof(buf)); 311 if (err) { 312 brcmf_dbg(TRACE, "retrieving clmver failed, %d\n", err); 313 } else { 314 clmver = (char *)buf; 315 /* store CLM version for adding it to revinfo debugfs file */ 316 memcpy(ifp->drvr->clmver, clmver, sizeof(ifp->drvr->clmver)); 317 318 /* Replace all newline/linefeed characters with space 319 * character 320 */ 321 ptr = clmver; 322 while ((ptr = strnchr(ptr, '\n', sizeof(buf))) != NULL) 323 *ptr = ' '; 324 325 brcmf_dbg(INFO, "CLM version = %s\n", clmver); 326 } 327 328 /* set mpc */ 329 err = brcmf_fil_iovar_int_set(ifp, "mpc", 1); 330 if (err) { 331 brcmf_err("failed setting mpc\n"); 332 goto done; 333 } 334 335 brcmf_c_set_joinpref_default(ifp); 336 337 /* Setup event_msgs, enable E_IF */ 338 err = brcmf_fil_iovar_data_get(ifp, "event_msgs", eventmask, 339 BRCMF_EVENTING_MASK_LEN); 340 if (err) { 341 brcmf_err("Get event_msgs error (%d)\n", err); 342 goto done; 343 } 344 setbit(eventmask, BRCMF_E_IF); 345 err = brcmf_fil_iovar_data_set(ifp, "event_msgs", eventmask, 346 BRCMF_EVENTING_MASK_LEN); 347 if (err) { 348 brcmf_err("Set event_msgs error (%d)\n", err); 349 goto done; 350 } 351 352 /* Setup default scan channel time */ 353 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME, 354 BRCMF_DEFAULT_SCAN_CHANNEL_TIME); 355 if (err) { 356 brcmf_err("BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n", 357 err); 358 goto done; 359 } 360 361 /* Setup default scan unassoc time */ 362 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME, 363 BRCMF_DEFAULT_SCAN_UNASSOC_TIME); 364 if (err) { 365 brcmf_err("BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n", 366 err); 367 goto done; 368 } 369 370 /* Enable tx beamforming, errors can be ignored (not supported) */ 371 (void)brcmf_fil_iovar_int_set(ifp, "txbf", 1); 372 373 /* do bus specific preinit here */ 374 err = brcmf_bus_preinit(ifp->drvr->bus_if); 375 done: 376 return err; 377 } 378 379 #ifndef CONFIG_BRCM_TRACING 380 void __brcmf_err(const char *func, const char *fmt, ...) 381 { 382 struct va_format vaf; 383 va_list args; 384 385 va_start(args, fmt); 386 387 vaf.fmt = fmt; 388 vaf.va = &args; 389 pr_err("%s: %pV", func, &vaf); 390 391 va_end(args); 392 } 393 #endif 394 395 #if defined(CONFIG_BRCM_TRACING) || defined(CONFIG_BRCMDBG) 396 void __brcmf_dbg(u32 level, const char *func, const char *fmt, ...) 397 { 398 struct va_format vaf = { 399 .fmt = fmt, 400 }; 401 va_list args; 402 403 va_start(args, fmt); 404 vaf.va = &args; 405 if (brcmf_msg_level & level) 406 pr_debug("%s %pV", func, &vaf); 407 trace_brcmf_dbg(level, func, &vaf); 408 va_end(args); 409 } 410 #endif 411 412 static void brcmf_mp_attach(void) 413 { 414 /* If module param firmware path is set then this will always be used, 415 * if not set then if available use the platform data version. To make 416 * sure it gets initialized at all, always copy the module param version 417 */ 418 strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path, 419 BRCMF_FW_ALTPATH_LEN); 420 if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) && 421 (brcmf_mp_global.firmware_path[0] == '\0')) { 422 strlcpy(brcmf_mp_global.firmware_path, 423 brcmfmac_pdata->fw_alternative_path, 424 BRCMF_FW_ALTPATH_LEN); 425 } 426 } 427 428 struct brcmf_mp_device *brcmf_get_module_param(struct device *dev, 429 enum brcmf_bus_type bus_type, 430 u32 chip, u32 chiprev) 431 { 432 struct brcmf_mp_device *settings; 433 struct brcmfmac_pd_device *device_pd; 434 bool found; 435 int i; 436 437 brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip, 438 chiprev); 439 settings = kzalloc(sizeof(*settings), GFP_ATOMIC); 440 if (!settings) 441 return NULL; 442 443 /* start by using the module paramaters */ 444 settings->p2p_enable = !!brcmf_p2p_enable; 445 settings->feature_disable = brcmf_feature_disable; 446 settings->fcmode = brcmf_fcmode; 447 settings->roamoff = !!brcmf_roamoff; 448 settings->iapp = !!brcmf_iapp_enable; 449 #ifdef DEBUG 450 settings->ignore_probe_fail = !!brcmf_ignore_probe_fail; 451 #endif 452 453 if (bus_type == BRCMF_BUSTYPE_SDIO) 454 settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz; 455 456 /* See if there is any device specific platform data configured */ 457 found = false; 458 if (brcmfmac_pdata) { 459 for (i = 0; i < brcmfmac_pdata->device_count; i++) { 460 device_pd = &brcmfmac_pdata->devices[i]; 461 if ((device_pd->bus_type == bus_type) && 462 (device_pd->id == chip) && 463 ((device_pd->rev == chiprev) || 464 (device_pd->rev == -1))) { 465 brcmf_dbg(INFO, "Platform data for device found\n"); 466 settings->country_codes = 467 device_pd->country_codes; 468 if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO) 469 memcpy(&settings->bus.sdio, 470 &device_pd->bus.sdio, 471 sizeof(settings->bus.sdio)); 472 found = true; 473 break; 474 } 475 } 476 } 477 if (!found) { 478 /* No platform data for this device, try OF (Open Firwmare) */ 479 brcmf_of_probe(dev, bus_type, settings); 480 } 481 return settings; 482 } 483 484 void brcmf_release_module_param(struct brcmf_mp_device *module_param) 485 { 486 kfree(module_param); 487 } 488 489 static int __init brcmf_common_pd_probe(struct platform_device *pdev) 490 { 491 brcmf_dbg(INFO, "Enter\n"); 492 493 brcmfmac_pdata = dev_get_platdata(&pdev->dev); 494 495 if (brcmfmac_pdata->power_on) 496 brcmfmac_pdata->power_on(); 497 498 return 0; 499 } 500 501 static int brcmf_common_pd_remove(struct platform_device *pdev) 502 { 503 brcmf_dbg(INFO, "Enter\n"); 504 505 if (brcmfmac_pdata->power_off) 506 brcmfmac_pdata->power_off(); 507 508 return 0; 509 } 510 511 static struct platform_driver brcmf_pd = { 512 .remove = brcmf_common_pd_remove, 513 .driver = { 514 .name = BRCMFMAC_PDATA_NAME, 515 } 516 }; 517 518 static int __init brcmfmac_module_init(void) 519 { 520 int err; 521 522 /* Initialize debug system first */ 523 brcmf_debugfs_init(); 524 525 /* Get the platform data (if available) for our devices */ 526 err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe); 527 if (err == -ENODEV) 528 brcmf_dbg(INFO, "No platform data available.\n"); 529 530 /* Initialize global module paramaters */ 531 brcmf_mp_attach(); 532 533 /* Continue the initialization by registering the different busses */ 534 err = brcmf_core_init(); 535 if (err) { 536 brcmf_debugfs_exit(); 537 if (brcmfmac_pdata) 538 platform_driver_unregister(&brcmf_pd); 539 } 540 541 return err; 542 } 543 544 static void __exit brcmfmac_module_exit(void) 545 { 546 brcmf_core_exit(); 547 if (brcmfmac_pdata) 548 platform_driver_unregister(&brcmf_pd); 549 brcmf_debugfs_exit(); 550 } 551 552 module_init(brcmfmac_module_init); 553 module_exit(brcmfmac_module_exit); 554 555