drivers/staging/brcm80211/sys/wlc_alloc.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 #include <linux/kernel.h>
  17 #include <linux/string.h>
  18 #include <bcmdefs.h>
  19 #include <wlc_cfg.h>
  20 #include <linux/module.h>
  21 #include <linux/pci.h>
  22 #include <osl.h>
  23 #include <bcmutils.h>
  24 #include <siutils.h>
  25 #include <wlioctl.h>
  26 #include <wlc_pub.h>
  27 #include <wlc_key.h>
  28 #include <sbhndpio.h>
  29 #include <sbhnddma.h>
  30 #include <wlc_event.h>
  31 #include <wlc_mac80211.h>
  32 #include <wlc_alloc.h>
  33 #include <wl_dbg.h>
  34
  35 static struct wlc_pub *wlc_pub_malloc(struct osl_info *osh, uint unit,
  36                                       uint *err, uint devid);
  37 static void wlc_pub_mfree(struct osl_info *osh, struct wlc_pub *pub);
  38 static void wlc_tunables_init(wlc_tunables_t *tunables, uint devid);
  39
  40 void *wlc_calloc(struct osl_info *osh, uint unit, uint size)
  41 {
  42         void *item;
  43
  44         item = kzalloc(size, GFP_ATOMIC);
  45         if (item == NULL)
  46                 WL_ERROR("wl%d: %s: out of memory\n", unit, __func__);
  47         return item;
  48 }
  49
  50 void wlc_tunables_init(wlc_tunables_t *tunables, uint devid)
  51 {
  52         tunables->ntxd = NTXD;
  53         tunables->nrxd = NRXD;
  54         tunables->rxbufsz = RXBUFSZ;
  55         tunables->nrxbufpost = NRXBUFPOST;
  56         tunables->maxscb = MAXSCB;
  57         tunables->ampdunummpdu = AMPDU_NUM_MPDU;
  58         tunables->maxpktcb = MAXPKTCB;
  59         tunables->maxucodebss = WLC_MAX_UCODE_BSS;
  60         tunables->maxucodebss4 = WLC_MAX_UCODE_BSS4;
  61         tunables->maxbss = MAXBSS;
  62         tunables->datahiwat = WLC_DATAHIWAT;
  63         tunables->ampdudatahiwat = WLC_AMPDUDATAHIWAT;
  64         tunables->rxbnd = RXBND;
  65         tunables->txsbnd = TXSBND;
  66 }
  67
  68 static struct wlc_pub *wlc_pub_malloc(struct osl_info *osh, uint unit,
  69                                       uint *err, uint devid)
  70 {
  71         struct wlc_pub *pub;
  72
  73         pub = (struct wlc_pub *) wlc_calloc(osh, unit, sizeof(struct wlc_pub));
  74         if (pub == NULL) {
  75                 *err = 1001;
  76                 goto fail;
  77         }
  78
  79         pub->tunables = (wlc_tunables_t *)wlc_calloc(osh, unit,
  80                 sizeof(wlc_tunables_t));
  81         if (pub->tunables == NULL) {
  82                 *err = 1028;
  83                 goto fail;
  84         }
  85
  86         /* need to init the tunables now */
  87         wlc_tunables_init(pub->tunables, devid);
  88
  89         pub->multicast = (struct ether_addr *)wlc_calloc(osh, unit,
  90                 (sizeof(struct ether_addr) * MAXMULTILIST));
  91         if (pub->multicast == NULL) {
  92                 *err = 1003;
  93                 goto fail;
  94         }
  95
  96         return pub;
  97
  98  fail:
  99         wlc_pub_mfree(osh, pub);
 100         return NULL;
 101 }
 102
 103 static void wlc_pub_mfree(struct osl_info *osh, struct wlc_pub *pub)
 104 {
 105         if (pub == NULL)
 106                 return;
 107
 108         if (pub->multicast)
 109                 kfree(pub->multicast);
 110         if (pub->tunables) {
 111                 kfree(pub->tunables);
 112                 pub->tunables = NULL;
 113         }
 114
 115         kfree(pub);
 116 }
 117
 118 wlc_bsscfg_t *wlc_bsscfg_malloc(struct osl_info *osh, uint unit)
 119 {
 120         wlc_bsscfg_t *cfg;
 121
 122         cfg = (wlc_bsscfg_t *) wlc_calloc(osh, unit, sizeof(wlc_bsscfg_t));
 123         if (cfg == NULL)
 124                 goto fail;
 125
 126         cfg->current_bss = (wlc_bss_info_t *)wlc_calloc(osh, unit,
 127                 sizeof(wlc_bss_info_t));
 128         if (cfg->current_bss == NULL)
 129                 goto fail;
 130
 131         return cfg;
 132
 133  fail:
 134         wlc_bsscfg_mfree(osh, cfg);
 135         return NULL;
 136 }
 137
 138 void wlc_bsscfg_mfree(struct osl_info *osh, wlc_bsscfg_t *cfg)
 139 {
 140         if (cfg == NULL)
 141                 return;
 142
 143         if (cfg->maclist) {
 144                 kfree(cfg->maclist);
 145                 cfg->maclist = NULL;
 146         }
 147
 148         if (cfg->current_bss != NULL) {
 149                 wlc_bss_info_t *current_bss = cfg->current_bss;
 150                 if (current_bss->bcn_prb != NULL)
 151                         kfree(current_bss->bcn_prb);
 152                 kfree(current_bss);
 153                 cfg->current_bss = NULL;
 154         }
 155
 156         kfree(cfg);
 157 }
 158
 159 void wlc_bsscfg_ID_assign(struct wlc_info *wlc, wlc_bsscfg_t *bsscfg)
 160 {
 161         bsscfg->ID = wlc->next_bsscfg_ID;
 162         wlc->next_bsscfg_ID++;
 163 }
 164
 165 /*
 166  * The common driver entry routine. Error codes should be unique
 167  */
 168 struct wlc_info *wlc_attach_malloc(struct osl_info *osh, uint unit, uint *err,
 169                               uint devid)
 170 {
 171         struct wlc_info *wlc;
 172
 173         wlc = (struct wlc_info *) wlc_calloc(osh, unit,
 174                                              sizeof(struct wlc_info));
 175         if (wlc == NULL) {
 176                 *err = 1002;
 177                 goto fail;
 178         }
 179
 180         wlc->hwrxoff = WL_HWRXOFF;
 181
 182         /* allocate struct wlc_pub state structure */
 183         wlc->pub = wlc_pub_malloc(osh, unit, err, devid);
 184         if (wlc->pub == NULL) {
 185                 *err = 1003;
 186                 goto fail;
 187         }
 188         wlc->pub->wlc = wlc;
 189
 190         /* allocate struct wlc_hw_info state structure */
 191
 192         wlc->hw = (struct wlc_hw_info *)wlc_calloc(osh, unit,
 193                 sizeof(struct wlc_hw_info));
 194         if (wlc->hw == NULL) {
 195                 *err = 1005;
 196                 goto fail;
 197         }
 198         wlc->hw->wlc = wlc;
 199
 200         wlc->hw->bandstate[0] = (wlc_hwband_t *)wlc_calloc(osh, unit,
 201                 (sizeof(wlc_hwband_t) * MAXBANDS));
 202         if (wlc->hw->bandstate[0] == NULL) {
 203                 *err = 1006;
 204                 goto fail;
 205         } else {
 206                 int i;
 207
 208                 for (i = 1; i < MAXBANDS; i++) {
 209                         wlc->hw->bandstate[i] = (wlc_hwband_t *)
 210                             ((unsigned long)wlc->hw->bandstate[0] +
 211                              (sizeof(wlc_hwband_t) * i));
 212                 }
 213         }
 214
 215         wlc->modulecb = (modulecb_t *)wlc_calloc(osh, unit,
 216                 sizeof(modulecb_t) * WLC_MAXMODULES);
 217         if (wlc->modulecb == NULL) {
 218                 *err = 1009;
 219                 goto fail;
 220         }
 221
 222         wlc->default_bss = (wlc_bss_info_t *)wlc_calloc(osh, unit,
 223                 sizeof(wlc_bss_info_t));
 224         if (wlc->default_bss == NULL) {
 225                 *err = 1010;
 226                 goto fail;
 227         }
 228
 229         wlc->cfg = wlc_bsscfg_malloc(osh, unit);
 230         if (wlc->cfg == NULL) {
 231                 *err = 1011;
 232                 goto fail;
 233         }
 234         wlc_bsscfg_ID_assign(wlc, wlc->cfg);
 235
 236         wlc->pkt_callback = (pkt_cb_t *)wlc_calloc(osh, unit,
 237                 (sizeof(pkt_cb_t) * (wlc->pub->tunables->maxpktcb + 1)));
 238         if (wlc->pkt_callback == NULL) {
 239                 *err = 1013;
 240                 goto fail;
 241         }
 242
 243         wlc->wsec_def_keys[0] = (wsec_key_t *)wlc_calloc(osh, unit,
 244                 (sizeof(wsec_key_t) * WLC_DEFAULT_KEYS));
 245         if (wlc->wsec_def_keys[0] == NULL) {
 246                 *err = 1015;
 247                 goto fail;
 248         } else {
 249                 int i;
 250                 for (i = 1; i < WLC_DEFAULT_KEYS; i++) {
 251                         wlc->wsec_def_keys[i] = (wsec_key_t *)
 252                             ((unsigned long)wlc->wsec_def_keys[0] +
 253                              (sizeof(wsec_key_t) * i));
 254                 }
 255         }
 256
 257         wlc->protection = (wlc_protection_t *)wlc_calloc(osh, unit,
 258                 sizeof(wlc_protection_t));
 259         if (wlc->protection == NULL) {
 260                 *err = 1016;
 261                 goto fail;
 262         }
 263
 264         wlc->stf = (wlc_stf_t *)wlc_calloc(osh, unit, sizeof(wlc_stf_t));
 265         if (wlc->stf == NULL) {
 266                 *err = 1017;
 267                 goto fail;
 268         }
 269
 270         wlc->bandstate[0] = (struct wlcband *)wlc_calloc(osh, unit,
 271                                 (sizeof(struct wlcband)*MAXBANDS));
 272         if (wlc->bandstate[0] == NULL) {
 273                 *err = 1025;
 274                 goto fail;
 275         } else {
 276                 int i;
 277
 278                 for (i = 1; i < MAXBANDS; i++) {
 279                         wlc->bandstate[i] =
 280                             (struct wlcband *) ((unsigned long)wlc->bandstate[0]
 281                             + (sizeof(struct wlcband)*i));
 282                 }
 283         }
 284
 285         wlc->corestate = (struct wlccore *)wlc_calloc(osh, unit,
 286                                                       sizeof(struct wlccore));
 287         if (wlc->corestate == NULL) {
 288                 *err = 1026;
 289                 goto fail;
 290         }
 291
 292         wlc->corestate->macstat_snapshot =
 293                 (macstat_t *)wlc_calloc(osh, unit, sizeof(macstat_t));
 294         if (wlc->corestate->macstat_snapshot == NULL) {
 295                 *err = 1027;
 296                 goto fail;
 297         }
 298
 299         return wlc;
 300
 301  fail:
 302         wlc_detach_mfree(wlc, osh);
 303         return NULL;
 304 }
 305
 306 void wlc_detach_mfree(struct wlc_info *wlc, struct osl_info *osh)
 307 {
 308         if (wlc == NULL)
 309                 return;
 310
 311         if (wlc->modulecb) {
 312                 kfree(wlc->modulecb);
 313                 wlc->modulecb = NULL;
 314         }
 315
 316         if (wlc->default_bss) {
 317                 kfree(wlc->default_bss);
 318                 wlc->default_bss = NULL;
 319         }
 320         if (wlc->cfg) {
 321                 wlc_bsscfg_mfree(osh, wlc->cfg);
 322                 wlc->cfg = NULL;
 323         }
 324
 325         if (wlc->pkt_callback && wlc->pub && wlc->pub->tunables) {
 326                 kfree(wlc->pkt_callback);
 327                 wlc->pkt_callback = NULL;
 328         }
 329
 330         if (wlc->wsec_def_keys[0])
 331                 kfree(wlc->wsec_def_keys[0]);
 332         if (wlc->protection) {
 333                 kfree(wlc->protection);
 334                 wlc->protection = NULL;
 335         }
 336
 337         if (wlc->stf) {
 338                 kfree(wlc->stf);
 339                 wlc->stf = NULL;
 340         }
 341
 342         if (wlc->bandstate[0])
 343                 kfree(wlc->bandstate[0]);
 344
 345         if (wlc->corestate) {
 346                 if (wlc->corestate->macstat_snapshot) {
 347         kfree(wlc->corestate->macstat_snapshot);                        wlc->corestate->macstat_snapshot = NULL;
 348                 }
 349                 kfree(wlc->corestate);
 350                 wlc->corestate = NULL;
 351         }
 352
 353         if (wlc->pub) {
 354                 /* free pub struct */
 355                 wlc_pub_mfree(osh, wlc->pub);
 356                 wlc->pub = NULL;
 357         }
 358
 359         if (wlc->hw) {
 360                 if (wlc->hw->bandstate[0]) {
 361                         kfree(wlc->hw->bandstate[0]);
 362                         wlc->hw->bandstate[0] = NULL;
 363                 }
 364
 365                 /* free hw struct */
 366                 kfree(wlc->hw);
 367                 wlc->hw = NULL;
 368         }
 369
 370         /* free the wlc */
 371         kfree(wlc);
 372         wlc = NULL;
 373 }