drivers/net/wireless/broadcom/brcm80211/brcmfmac/common.c

   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_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         /* retreive mac address */
 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                 /* use revinfo if not known yet */
 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         /* Do any CLM downloading */
 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         /* query for 'ver' to get version info from firmware */
 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         /* Print fw version info */
 271         brcmf_info("Firmware: %s %s\n", ri->chipname, buf);
 272
 273         /* locate firmware version number for ethtool */
 274         ptr = strrchr(buf, ' ') + 1;
 275         strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));
 276
 277         /* Query for 'clmver' to get CLM version info from firmware */
 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                 /* store CLM version for adding it to revinfo debugfs file */
 285                 memcpy(ifp->drvr->clmver, clmver, sizeof(ifp->drvr->clmver));
 286
 287                 /* Replace all newline/linefeed characters with space
 288                  * character
 289                  */
 290                 strreplace(clmver, '\n', ' ');
 291
 292                 brcmf_dbg(INFO, "CLM version = %s\n", clmver);
 293         }
 294
 295         /* set mpc */
 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         /* Setup event_msgs, enable E_IF */
 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         /* Setup default scan channel time */
 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         /* Setup default scan unassoc time */
 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         /* Enable tx beamforming, errors can be ignored (not supported) */
 338         (void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);
 339 done:
 340         return err;
 341 }
 342
 343 #ifndef CONFIG_BRCM_TRACING
 344 void __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)
 363 void __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
 379 static void brcmf_mp_attach(void)
 380 {
 381         /* If module param firmware path is set then this will always be used,
 382          * if not set then if available use the platform data version. To make
 383          * sure it gets initialized at all, always copy the module param version
 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
 395 struct 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         /* start by using the module paramaters */
 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         /* See if there is any device specific platform data configured */
 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                 /* No platform data for this device, try OF and DMI data */
 446                 brcmf_dmi_probe(settings, chip, chiprev);
 447                 brcmf_of_probe(dev, bus_type, settings);
 448         }
 449         return settings;
 450 }
 451
 452 void brcmf_release_module_param(struct brcmf_mp_device *module_param)
 453 {
 454         kfree(module_param);
 455 }
 456
 457 static 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
 469 static 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
 479 static struct platform_driver brcmf_pd = {
 480         .remove         = brcmf_common_pd_remove,
 481         .driver         = {
 482                 .name   = BRCMFMAC_PDATA_NAME,
 483         }
 484 };
 485
 486 static int __init brcmfmac_module_init(void)
 487 {
 488         int err;
 489
 490         /* Get the platform data (if available) for our devices */
 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         /* Initialize global module paramaters */
 496         brcmf_mp_attach();
 497
 498         /* Continue the initialization by registering the different busses */
 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
 508 static void __exit brcmfmac_module_exit(void)
 509 {
 510         brcmf_core_exit();
 511         if (brcmfmac_pdata)
 512                 platform_driver_unregister(&brcmf_pd);
 513 }
 514
 515 module_init(brcmfmac_module_init);
 516 module_exit(brcmfmac_module_exit);
 517