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

   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 <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
  32 MODULE_AUTHOR("Broadcom Corporation");
  33 MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver.");
  34 MODULE_LICENSE("Dual BSD/GPL");
  35
  36 const 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 /* default boost value for RSSI_DELTA in preferred join selection */
  42 #define BRCMF_JOIN_PREF_RSSI_BOOST      8
  43
  44 #define BRCMF_DEFAULT_TXGLOM_SIZE       32  /* max tx frames in glom chain */
  45
  46 static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE;
  47 module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0);
  48 MODULE_PARM_DESC(txglomsz, "Maximum tx packet chain size [SDIO]");
  49
  50 /* Debug level configuration. See debug.h for bits, sysfs modifiable */
  51 int brcmf_msg_level;
  52 module_param_named(debug, brcmf_msg_level, int, S_IRUSR | S_IWUSR);
  53 MODULE_PARM_DESC(debug, "Level of debug output");
  54
  55 static int brcmf_p2p_enable;
  56 module_param_named(p2pon, brcmf_p2p_enable, int, 0);
  57 MODULE_PARM_DESC(p2pon, "Enable legacy p2p management functionality");
  58
  59 static int brcmf_feature_disable;
  60 module_param_named(feature_disable, brcmf_feature_disable, int, 0);
  61 MODULE_PARM_DESC(feature_disable, "Disable features");
  62
  63 static char brcmf_firmware_path[BRCMF_FW_ALTPATH_LEN];
  64 module_param_string(alternative_fw_path, brcmf_firmware_path,
  65                     BRCMF_FW_ALTPATH_LEN, S_IRUSR);
  66 MODULE_PARM_DESC(alternative_fw_path, "Alternative firmware path");
  67
  68 static int brcmf_fcmode;
  69 module_param_named(fcmode, brcmf_fcmode, int, 0);
  70 MODULE_PARM_DESC(fcmode, "Mode of firmware signalled flow control");
  71
  72 static int brcmf_roamoff;
  73 module_param_named(roamoff, brcmf_roamoff, int, S_IRUSR);
  74 MODULE_PARM_DESC(roamoff, "Do not use internal roaming engine");
  75
  76 #ifdef DEBUG
  77 /* always succeed brcmf_bus_started() */
  78 static int brcmf_ignore_probe_fail;
  79 module_param_named(ignore_probe_fail, brcmf_ignore_probe_fail, int, 0);
  80 MODULE_PARM_DESC(ignore_probe_fail, "always succeed probe for debugging");
  81 #endif
  82
  83 static struct brcmfmac_platform_data *brcmfmac_pdata;
  84 struct brcmf_mp_global_t brcmf_mp_global;
  85
  86 void brcmf_c_set_joinpref_default(struct brcmf_if *ifp)
  87 {
  88         struct brcmf_join_pref_params join_pref_params[2];
  89         int err;
  90
  91         /* Setup join_pref to select target by RSSI (boost on 5GHz) */
  92         join_pref_params[0].type = BRCMF_JOIN_PREF_RSSI_DELTA;
  93         join_pref_params[0].len = 2;
  94         join_pref_params[0].rssi_gain = BRCMF_JOIN_PREF_RSSI_BOOST;
  95         join_pref_params[0].band = WLC_BAND_5G;
  96
  97         join_pref_params[1].type = BRCMF_JOIN_PREF_RSSI;
  98         join_pref_params[1].len = 2;
  99         join_pref_params[1].rssi_gain = 0;
 100         join_pref_params[1].band = 0;
 101         err = brcmf_fil_iovar_data_set(ifp, "join_pref", join_pref_params,
 102                                        sizeof(join_pref_params));
 103         if (err)
 104                 brcmf_err("Set join_pref error (%d)\n", err);
 105 }
 106
 107 int brcmf_c_preinit_dcmds(struct brcmf_if *ifp)
 108 {
 109         s8 eventmask[BRCMF_EVENTING_MASK_LEN];
 110         u8 buf[BRCMF_DCMD_SMLEN];
 111         struct brcmf_rev_info_le revinfo;
 112         struct brcmf_rev_info *ri;
 113         char *ptr;
 114         s32 err;
 115
 116         /* retreive mac address */
 117         err = brcmf_fil_iovar_data_get(ifp, "cur_etheraddr", ifp->mac_addr,
 118                                        sizeof(ifp->mac_addr));
 119         if (err < 0) {
 120                 brcmf_err("Retreiving cur_etheraddr failed, %d\n", err);
 121                 goto done;
 122         }
 123         memcpy(ifp->drvr->mac, ifp->mac_addr, sizeof(ifp->drvr->mac));
 124
 125         err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_REVINFO,
 126                                      &revinfo, sizeof(revinfo));
 127         ri = &ifp->drvr->revinfo;
 128         if (err < 0) {
 129                 brcmf_err("retrieving revision info failed, %d\n", err);
 130         } else {
 131                 ri->vendorid = le32_to_cpu(revinfo.vendorid);
 132                 ri->deviceid = le32_to_cpu(revinfo.deviceid);
 133                 ri->radiorev = le32_to_cpu(revinfo.radiorev);
 134                 ri->chiprev = le32_to_cpu(revinfo.chiprev);
 135                 ri->corerev = le32_to_cpu(revinfo.corerev);
 136                 ri->boardid = le32_to_cpu(revinfo.boardid);
 137                 ri->boardvendor = le32_to_cpu(revinfo.boardvendor);
 138                 ri->boardrev = le32_to_cpu(revinfo.boardrev);
 139                 ri->driverrev = le32_to_cpu(revinfo.driverrev);
 140                 ri->ucoderev = le32_to_cpu(revinfo.ucoderev);
 141                 ri->bus = le32_to_cpu(revinfo.bus);
 142                 ri->chipnum = le32_to_cpu(revinfo.chipnum);
 143                 ri->phytype = le32_to_cpu(revinfo.phytype);
 144                 ri->phyrev = le32_to_cpu(revinfo.phyrev);
 145                 ri->anarev = le32_to_cpu(revinfo.anarev);
 146                 ri->chippkg = le32_to_cpu(revinfo.chippkg);
 147                 ri->nvramrev = le32_to_cpu(revinfo.nvramrev);
 148         }
 149         ri->result = err;
 150
 151         /* query for 'ver' to get version info from firmware */
 152         memset(buf, 0, sizeof(buf));
 153         strcpy(buf, "ver");
 154         err = brcmf_fil_iovar_data_get(ifp, "ver", buf, sizeof(buf));
 155         if (err < 0) {
 156                 brcmf_err("Retreiving version information failed, %d\n",
 157                           err);
 158                 goto done;
 159         }
 160         buf[sizeof(buf) - 1] = '\0';
 161         ptr = (char *)buf;
 162         strsep(&ptr, "\n");
 163
 164         /* Print fw version info */
 165         brcmf_info("Firmware version = %s\n", buf);
 166
 167         /* locate firmware version number for ethtool */
 168         ptr = strrchr(buf, ' ') + 1;
 169         strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));
 170
 171         /* set mpc */
 172         err = brcmf_fil_iovar_int_set(ifp, "mpc", 1);
 173         if (err) {
 174                 brcmf_err("failed setting mpc\n");
 175                 goto done;
 176         }
 177
 178         brcmf_c_set_joinpref_default(ifp);
 179
 180         /* Setup event_msgs, enable E_IF */
 181         err = brcmf_fil_iovar_data_get(ifp, "event_msgs", eventmask,
 182                                        BRCMF_EVENTING_MASK_LEN);
 183         if (err) {
 184                 brcmf_err("Get event_msgs error (%d)\n", err);
 185                 goto done;
 186         }
 187         setbit(eventmask, BRCMF_E_IF);
 188         err = brcmf_fil_iovar_data_set(ifp, "event_msgs", eventmask,
 189                                        BRCMF_EVENTING_MASK_LEN);
 190         if (err) {
 191                 brcmf_err("Set event_msgs error (%d)\n", err);
 192                 goto done;
 193         }
 194
 195         /* Setup default scan channel time */
 196         err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
 197                                     BRCMF_DEFAULT_SCAN_CHANNEL_TIME);
 198         if (err) {
 199                 brcmf_err("BRCMF_C_SET_SCAN_CHANNEL_TIME error (%d)\n",
 200                           err);
 201                 goto done;
 202         }
 203
 204         /* Setup default scan unassoc time */
 205         err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
 206                                     BRCMF_DEFAULT_SCAN_UNASSOC_TIME);
 207         if (err) {
 208                 brcmf_err("BRCMF_C_SET_SCAN_UNASSOC_TIME error (%d)\n",
 209                           err);
 210                 goto done;
 211         }
 212
 213         /* Enable tx beamforming, errors can be ignored (not supported) */
 214         (void)brcmf_fil_iovar_int_set(ifp, "txbf", 1);
 215
 216         /* do bus specific preinit here */
 217         err = brcmf_bus_preinit(ifp->drvr->bus_if);
 218 done:
 219         return err;
 220 }
 221
 222 #ifndef CONFIG_BRCM_TRACING
 223 void __brcmf_err(const char *func, const char *fmt, ...)
 224 {
 225         struct va_format vaf;
 226         va_list args;
 227
 228         va_start(args, fmt);
 229
 230         vaf.fmt = fmt;
 231         vaf.va = &args;
 232         pr_err("%s: %pV", func, &vaf);
 233
 234         va_end(args);
 235 }
 236 #endif
 237
 238 #if defined(CONFIG_BRCM_TRACING) || defined(CONFIG_BRCMDBG)
 239 void __brcmf_dbg(u32 level, const char *func, const char *fmt, ...)
 240 {
 241         struct va_format vaf = {
 242                 .fmt = fmt,
 243         };
 244         va_list args;
 245
 246         va_start(args, fmt);
 247         vaf.va = &args;
 248         if (brcmf_msg_level & level)
 249                 pr_debug("%s %pV", func, &vaf);
 250         trace_brcmf_dbg(level, func, &vaf);
 251         va_end(args);
 252 }
 253 #endif
 254
 255 static void brcmf_mp_attach(void)
 256 {
 257         /* If module param firmware path is set then this will always be used,
 258          * if not set then if available use the platform data version. To make
 259          * sure it gets initialized at all, always copy the module param version
 260          */
 261         strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
 262                 BRCMF_FW_ALTPATH_LEN);
 263         if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&
 264             (brcmf_mp_global.firmware_path[0] == '\0')) {
 265                 strlcpy(brcmf_mp_global.firmware_path,
 266                         brcmfmac_pdata->fw_alternative_path,
 267                         BRCMF_FW_ALTPATH_LEN);
 268         }
 269 }
 270
 271 struct brcmf_mp_device *brcmf_get_module_param(struct device *dev,
 272                                                enum brcmf_bus_type bus_type,
 273                                                u32 chip, u32 chiprev)
 274 {
 275         struct brcmf_mp_device *settings;
 276         struct brcmfmac_pd_device *device_pd;
 277         bool found;
 278         int i;
 279
 280         brcmf_dbg(INFO, "Enter, bus=%d, chip=%d, rev=%d\n", bus_type, chip,
 281                   chiprev);
 282         settings = kzalloc(sizeof(*settings), GFP_ATOMIC);
 283         if (!settings)
 284                 return NULL;
 285
 286         /* start by using the module paramaters */
 287         settings->p2p_enable = !!brcmf_p2p_enable;
 288         settings->feature_disable = brcmf_feature_disable;
 289         settings->fcmode = brcmf_fcmode;
 290         settings->roamoff = !!brcmf_roamoff;
 291 #ifdef DEBUG
 292         settings->ignore_probe_fail = !!brcmf_ignore_probe_fail;
 293 #endif
 294
 295         if (bus_type == BRCMF_BUSTYPE_SDIO)
 296                 settings->bus.sdio.txglomsz = brcmf_sdiod_txglomsz;
 297
 298         /* See if there is any device specific platform data configured */
 299         found = false;
 300         if (brcmfmac_pdata) {
 301                 for (i = 0; i < brcmfmac_pdata->device_count; i++) {
 302                         device_pd = &brcmfmac_pdata->devices[i];
 303                         if ((device_pd->bus_type == bus_type) &&
 304                             (device_pd->id == chip) &&
 305                             ((device_pd->rev == chiprev) ||
 306                              (device_pd->rev == -1))) {
 307                                 brcmf_dbg(INFO, "Platform data for device found\n");
 308                                 settings->country_codes =
 309                                                 device_pd->country_codes;
 310                                 if (device_pd->bus_type == BRCMF_BUSTYPE_SDIO)
 311                                         memcpy(&settings->bus.sdio,
 312                                                &device_pd->bus.sdio,
 313                                                sizeof(settings->bus.sdio));
 314                                 found = true;
 315                                 break;
 316                         }
 317                 }
 318         }
 319         if (!found) {
 320                 /* No platform data for this device, try OF (Open Firwmare) */
 321                 brcmf_of_probe(dev, bus_type, settings);
 322         }
 323         return settings;
 324 }
 325
 326 void brcmf_release_module_param(struct brcmf_mp_device *module_param)
 327 {
 328         kfree(module_param);
 329 }
 330
 331 static int __init brcmf_common_pd_probe(struct platform_device *pdev)
 332 {
 333         brcmf_dbg(INFO, "Enter\n");
 334
 335         brcmfmac_pdata = dev_get_platdata(&pdev->dev);
 336
 337         if (brcmfmac_pdata->power_on)
 338                 brcmfmac_pdata->power_on();
 339
 340         return 0;
 341 }
 342
 343 static int brcmf_common_pd_remove(struct platform_device *pdev)
 344 {
 345         brcmf_dbg(INFO, "Enter\n");
 346
 347         if (brcmfmac_pdata->power_off)
 348                 brcmfmac_pdata->power_off();
 349
 350         return 0;
 351 }
 352
 353 static struct platform_driver brcmf_pd = {
 354         .remove         = brcmf_common_pd_remove,
 355         .driver         = {
 356                 .name   = BRCMFMAC_PDATA_NAME,
 357         }
 358 };
 359
 360 static int __init brcmfmac_module_init(void)
 361 {
 362         int err;
 363
 364         /* Initialize debug system first */
 365         brcmf_debugfs_init();
 366
 367         /* Get the platform data (if available) for our devices */
 368         err = platform_driver_probe(&brcmf_pd, brcmf_common_pd_probe);
 369         if (err == -ENODEV)
 370                 brcmf_dbg(INFO, "No platform data available.\n");
 371
 372         /* Initialize global module paramaters */
 373         brcmf_mp_attach();
 374
 375         /* Continue the initialization by registering the different busses */
 376         err = brcmf_core_init();
 377         if (err) {
 378                 brcmf_debugfs_exit();
 379                 if (brcmfmac_pdata)
 380                         platform_driver_unregister(&brcmf_pd);
 381         }
 382
 383         return err;
 384 }
 385
 386 static void __exit brcmfmac_module_exit(void)
 387 {
 388         brcmf_core_exit();
 389         if (brcmfmac_pdata)
 390                 platform_driver_unregister(&brcmf_pd);
 391         brcmf_debugfs_exit();
 392 }
 393
 394 module_init(brcmfmac_module_init);
 395 module_exit(brcmfmac_module_exit);
 396