drivers/net/wireless/wl12xx/init.c

   1 /*
   2  * This file is part of wl1271
   3  *
   4  * Copyright (C) 2009 Nokia Corporation
   5  *
   6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  *
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/slab.h>
  27
  28 #include "init.h"
  29 #include "wl12xx_80211.h"
  30 #include "acx.h"
  31 #include "cmd.h"
  32 #include "reg.h"
  33 #include "tx.h"
  34 #include "io.h"
  35
  36 int wl1271_sta_init_templates_config(struct wl1271 *wl)
  37 {
  38         int ret, i;
  39
  40         /* send empty templates for fw memory reservation */
  41         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4, NULL,
  42                                       WL1271_CMD_TEMPL_DFLT_SIZE,
  43                                       0, WL1271_RATE_AUTOMATIC);
  44         if (ret < 0)
  45                 return ret;
  46
  47         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_5,
  48                                       NULL, WL1271_CMD_TEMPL_DFLT_SIZE, 0,
  49                                       WL1271_RATE_AUTOMATIC);
  50         if (ret < 0)
  51                 return ret;
  52
  53         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, NULL,
  54                                       sizeof(struct wl12xx_null_data_template),
  55                                       0, WL1271_RATE_AUTOMATIC);
  56         if (ret < 0)
  57                 return ret;
  58
  59         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PS_POLL, NULL,
  60                                       sizeof(struct wl12xx_ps_poll_template),
  61                                       0, WL1271_RATE_AUTOMATIC);
  62         if (ret < 0)
  63                 return ret;
  64
  65         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, NULL,
  66                                       sizeof
  67                                       (struct wl12xx_qos_null_data_template),
  68                                       0, WL1271_RATE_AUTOMATIC);
  69         if (ret < 0)
  70                 return ret;
  71
  72         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PROBE_RESPONSE, NULL,
  73                                       WL1271_CMD_TEMPL_DFLT_SIZE,
  74                                       0, WL1271_RATE_AUTOMATIC);
  75         if (ret < 0)
  76                 return ret;
  77
  78         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON, NULL,
  79                                       WL1271_CMD_TEMPL_DFLT_SIZE,
  80                                       0, WL1271_RATE_AUTOMATIC);
  81         if (ret < 0)
  82                 return ret;
  83
  84         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_ARP_RSP, NULL,
  85                                       sizeof
  86                                       (struct wl12xx_arp_rsp_template),
  87                                       0, WL1271_RATE_AUTOMATIC);
  88         if (ret < 0)
  89                 return ret;
  90
  91         for (i = 0; i < CMD_TEMPL_KLV_IDX_MAX; i++) {
  92                 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_KLV, NULL,
  93                                               WL1271_CMD_TEMPL_DFLT_SIZE, i,
  94                                               WL1271_RATE_AUTOMATIC);
  95                 if (ret < 0)
  96                         return ret;
  97         }
  98
  99         return 0;
 100 }
 101
 102 static int wl1271_ap_init_deauth_template(struct wl1271 *wl)
 103 {
 104         struct wl12xx_disconn_template *tmpl;
 105         int ret;
 106
 107         tmpl = kzalloc(sizeof(*tmpl), GFP_KERNEL);
 108         if (!tmpl) {
 109                 ret = -ENOMEM;
 110                 goto out;
 111         }
 112
 113         tmpl->header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 114                                              IEEE80211_STYPE_DEAUTH);
 115
 116         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_DEAUTH_AP,
 117                                       tmpl, sizeof(*tmpl), 0,
 118                                       wl1271_tx_min_rate_get(wl));
 119
 120 out:
 121         kfree(tmpl);
 122         return ret;
 123 }
 124
 125 static int wl1271_ap_init_null_template(struct wl1271 *wl)
 126 {
 127         struct ieee80211_hdr_3addr *nullfunc;
 128         int ret;
 129
 130         nullfunc = kzalloc(sizeof(*nullfunc), GFP_KERNEL);
 131         if (!nullfunc) {
 132                 ret = -ENOMEM;
 133                 goto out;
 134         }
 135
 136         nullfunc->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
 137                                               IEEE80211_STYPE_NULLFUNC |
 138                                               IEEE80211_FCTL_FROMDS);
 139
 140         /* nullfunc->addr1 is filled by FW */
 141
 142         memcpy(nullfunc->addr2, wl->mac_addr, ETH_ALEN);
 143         memcpy(nullfunc->addr3, wl->mac_addr, ETH_ALEN);
 144
 145         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, nullfunc,
 146                                       sizeof(*nullfunc), 0,
 147                                       wl1271_tx_min_rate_get(wl));
 148
 149 out:
 150         kfree(nullfunc);
 151         return ret;
 152 }
 153
 154 static int wl1271_ap_init_qos_null_template(struct wl1271 *wl)
 155 {
 156         struct ieee80211_qos_hdr *qosnull;
 157         int ret;
 158
 159         qosnull = kzalloc(sizeof(*qosnull), GFP_KERNEL);
 160         if (!qosnull) {
 161                 ret = -ENOMEM;
 162                 goto out;
 163         }
 164
 165         qosnull->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
 166                                              IEEE80211_STYPE_QOS_NULLFUNC |
 167                                              IEEE80211_FCTL_FROMDS);
 168
 169         /* qosnull->addr1 is filled by FW */
 170
 171         memcpy(qosnull->addr2, wl->mac_addr, ETH_ALEN);
 172         memcpy(qosnull->addr3, wl->mac_addr, ETH_ALEN);
 173
 174         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, qosnull,
 175                                       sizeof(*qosnull), 0,
 176                                       wl1271_tx_min_rate_get(wl));
 177
 178 out:
 179         kfree(qosnull);
 180         return ret;
 181 }
 182
 183 static int wl1271_ap_init_templates_config(struct wl1271 *wl)
 184 {
 185         int ret;
 186
 187         /*
 188          * Put very large empty placeholders for all templates. These
 189          * reserve memory for later.
 190          */
 191         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_AP_PROBE_RESPONSE, NULL,
 192                                       WL1271_CMD_TEMPL_MAX_SIZE,
 193                                       0, WL1271_RATE_AUTOMATIC);
 194         if (ret < 0)
 195                 return ret;
 196
 197         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_AP_BEACON, NULL,
 198                                       WL1271_CMD_TEMPL_MAX_SIZE,
 199                                       0, WL1271_RATE_AUTOMATIC);
 200         if (ret < 0)
 201                 return ret;
 202
 203         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_DEAUTH_AP, NULL,
 204                                       sizeof
 205                                       (struct wl12xx_disconn_template),
 206                                       0, WL1271_RATE_AUTOMATIC);
 207         if (ret < 0)
 208                 return ret;
 209
 210         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, NULL,
 211                                       sizeof(struct wl12xx_null_data_template),
 212                                       0, WL1271_RATE_AUTOMATIC);
 213         if (ret < 0)
 214                 return ret;
 215
 216         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, NULL,
 217                                       sizeof
 218                                       (struct wl12xx_qos_null_data_template),
 219                                       0, WL1271_RATE_AUTOMATIC);
 220         if (ret < 0)
 221                 return ret;
 222
 223         return 0;
 224 }
 225
 226 static int wl12xx_init_rx_config(struct wl1271 *wl)
 227 {
 228         int ret;
 229
 230         ret = wl1271_acx_rx_msdu_life_time(wl);
 231         if (ret < 0)
 232                 return ret;
 233
 234         return 0;
 235 }
 236
 237 int wl1271_init_phy_config(struct wl1271 *wl)
 238 {
 239         int ret;
 240
 241         ret = wl1271_acx_pd_threshold(wl);
 242         if (ret < 0)
 243                 return ret;
 244
 245         ret = wl1271_acx_slot(wl, DEFAULT_SLOT_TIME);
 246         if (ret < 0)
 247                 return ret;
 248
 249         ret = wl1271_acx_service_period_timeout(wl);
 250         if (ret < 0)
 251                 return ret;
 252
 253         ret = wl1271_acx_rts_threshold(wl, wl->hw->wiphy->rts_threshold);
 254         if (ret < 0)
 255                 return ret;
 256
 257         return 0;
 258 }
 259
 260 static int wl1271_init_beacon_filter(struct wl1271 *wl)
 261 {
 262         int ret;
 263
 264         /* disable beacon filtering at this stage */
 265         ret = wl1271_acx_beacon_filter_opt(wl, false);
 266         if (ret < 0)
 267                 return ret;
 268
 269         ret = wl1271_acx_beacon_filter_table(wl);
 270         if (ret < 0)
 271                 return ret;
 272
 273         return 0;
 274 }
 275
 276 int wl1271_init_pta(struct wl1271 *wl)
 277 {
 278         int ret;
 279
 280         ret = wl12xx_acx_sg_cfg(wl);
 281         if (ret < 0)
 282                 return ret;
 283
 284         ret = wl1271_acx_sg_enable(wl, wl->sg_enabled);
 285         if (ret < 0)
 286                 return ret;
 287
 288         return 0;
 289 }
 290
 291 int wl1271_init_energy_detection(struct wl1271 *wl)
 292 {
 293         int ret;
 294
 295         ret = wl1271_acx_cca_threshold(wl);
 296         if (ret < 0)
 297                 return ret;
 298
 299         return 0;
 300 }
 301
 302 static int wl1271_init_beacon_broadcast(struct wl1271 *wl)
 303 {
 304         int ret;
 305
 306         ret = wl1271_acx_bcn_dtim_options(wl);
 307         if (ret < 0)
 308                 return ret;
 309
 310         return 0;
 311 }
 312
 313 static int wl12xx_init_fwlog(struct wl1271 *wl)
 314 {
 315         int ret;
 316
 317         if (wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED)
 318                 return 0;
 319
 320         ret = wl12xx_cmd_config_fwlog(wl);
 321         if (ret < 0)
 322                 return ret;
 323
 324         return 0;
 325 }
 326
 327 static int wl1271_sta_hw_init(struct wl1271 *wl)
 328 {
 329         int ret;
 330
 331         if (wl->chip.id != CHIP_ID_1283_PG20) {
 332                 ret = wl1271_cmd_ext_radio_parms(wl);
 333                 if (ret < 0)
 334                         return ret;
 335         }
 336
 337         /* PS config */
 338         ret = wl1271_acx_config_ps(wl);
 339         if (ret < 0)
 340                 return ret;
 341
 342         ret = wl1271_sta_init_templates_config(wl);
 343         if (ret < 0)
 344                 return ret;
 345
 346         ret = wl1271_acx_group_address_tbl(wl, true, NULL, 0);
 347         if (ret < 0)
 348                 return ret;
 349
 350         /* Initialize connection monitoring thresholds */
 351         ret = wl1271_acx_conn_monit_params(wl, false);
 352         if (ret < 0)
 353                 return ret;
 354
 355         /* Beacon filtering */
 356         ret = wl1271_init_beacon_filter(wl);
 357         if (ret < 0)
 358                 return ret;
 359
 360         /* FM WLAN coexistence */
 361         ret = wl1271_acx_fm_coex(wl);
 362         if (ret < 0)
 363                 return ret;
 364
 365         /* Beacons and broadcast settings */
 366         ret = wl1271_init_beacon_broadcast(wl);
 367         if (ret < 0)
 368                 return ret;
 369
 370         /* Configure for ELP power saving */
 371         ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_ELP);
 372         if (ret < 0)
 373                 return ret;
 374
 375         /* Configure rssi/snr averaging weights */
 376         ret = wl1271_acx_rssi_snr_avg_weights(wl);
 377         if (ret < 0)
 378                 return ret;
 379
 380         ret = wl1271_acx_sta_rate_policies(wl);
 381         if (ret < 0)
 382                 return ret;
 383
 384         ret = wl12xx_acx_mem_cfg(wl);
 385         if (ret < 0)
 386                 return ret;
 387
 388         /* Configure the FW logger */
 389         ret = wl12xx_init_fwlog(wl);
 390         if (ret < 0)
 391                 return ret;
 392
 393         return 0;
 394 }
 395
 396 static int wl1271_sta_hw_init_post_mem(struct wl1271 *wl)
 397 {
 398         int ret, i;
 399
 400         /* disable all keep-alive templates */
 401         for (i = 0; i < CMD_TEMPL_KLV_IDX_MAX; i++) {
 402                 ret = wl1271_acx_keep_alive_config(wl, i,
 403                                                    ACX_KEEP_ALIVE_TPL_INVALID);
 404                 if (ret < 0)
 405                         return ret;
 406         }
 407
 408         /* disable the keep-alive feature */
 409         ret = wl1271_acx_keep_alive_mode(wl, false);
 410         if (ret < 0)
 411                 return ret;
 412
 413         return 0;
 414 }
 415
 416 static int wl1271_ap_hw_init(struct wl1271 *wl)
 417 {
 418         int ret;
 419
 420         ret = wl1271_ap_init_templates_config(wl);
 421         if (ret < 0)
 422                 return ret;
 423
 424         /* Configure for power always on */
 425         ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
 426         if (ret < 0)
 427                 return ret;
 428
 429         ret = wl1271_init_ap_rates(wl);
 430         if (ret < 0)
 431                 return ret;
 432
 433         ret = wl1271_acx_ap_max_tx_retry(wl);
 434         if (ret < 0)
 435                 return ret;
 436
 437         ret = wl12xx_acx_mem_cfg(wl);
 438         if (ret < 0)
 439                 return ret;
 440
 441         /* initialize Tx power */
 442         ret = wl1271_acx_tx_power(wl, wl->power_level);
 443         if (ret < 0)
 444                 return ret;
 445
 446         return 0;
 447 }
 448
 449 int wl1271_ap_init_templates(struct wl1271 *wl)
 450 {
 451         int ret;
 452
 453         ret = wl1271_ap_init_deauth_template(wl);
 454         if (ret < 0)
 455                 return ret;
 456
 457         ret = wl1271_ap_init_null_template(wl);
 458         if (ret < 0)
 459                 return ret;
 460
 461         ret = wl1271_ap_init_qos_null_template(wl);
 462         if (ret < 0)
 463                 return ret;
 464
 465         /*
 466          * when operating as AP we want to receive external beacons for
 467          * configuring ERP protection.
 468          */
 469         ret = wl1271_acx_beacon_filter_opt(wl, false);
 470         if (ret < 0)
 471                 return ret;
 472
 473         return 0;
 474 }
 475
 476 static int wl1271_ap_hw_init_post_mem(struct wl1271 *wl)
 477 {
 478         return wl1271_ap_init_templates(wl);
 479 }
 480
 481 int wl1271_init_ap_rates(struct wl1271 *wl)
 482 {
 483         int i, ret;
 484         struct conf_tx_rate_class rc;
 485         u32 supported_rates;
 486
 487         wl1271_debug(DEBUG_AP, "AP basic rate set: 0x%x", wl->basic_rate_set);
 488
 489         if (wl->basic_rate_set == 0)
 490                 return -EINVAL;
 491
 492         rc.enabled_rates = wl->basic_rate_set;
 493         rc.long_retry_limit = 10;
 494         rc.short_retry_limit = 10;
 495         rc.aflags = 0;
 496         ret = wl1271_acx_ap_rate_policy(wl, &rc, ACX_TX_AP_MODE_MGMT_RATE);
 497         if (ret < 0)
 498                 return ret;
 499
 500         /* use the min basic rate for AP broadcast/multicast */
 501         rc.enabled_rates = wl1271_tx_min_rate_get(wl);
 502         rc.short_retry_limit = 10;
 503         rc.long_retry_limit = 10;
 504         rc.aflags = 0;
 505         ret = wl1271_acx_ap_rate_policy(wl, &rc, ACX_TX_AP_MODE_BCST_RATE);
 506         if (ret < 0)
 507                 return ret;
 508
 509         /*
 510          * If the basic rates contain OFDM rates, use OFDM only
 511          * rates for unicast TX as well. Else use all supported rates.
 512          */
 513         if ((wl->basic_rate_set & CONF_TX_OFDM_RATES))
 514                 supported_rates = CONF_TX_OFDM_RATES;
 515         else
 516                 supported_rates = CONF_TX_AP_ENABLED_RATES;
 517
 518         /* unconditionally enable HT rates */
 519         supported_rates |= CONF_TX_MCS_RATES;
 520
 521         /* configure unicast TX rate classes */
 522         for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
 523                 rc.enabled_rates = supported_rates;
 524                 rc.short_retry_limit = 10;
 525                 rc.long_retry_limit = 10;
 526                 rc.aflags = 0;
 527                 ret = wl1271_acx_ap_rate_policy(wl, &rc, i);
 528                 if (ret < 0)
 529                         return ret;
 530         }
 531
 532         return 0;
 533 }
 534
 535 static int wl1271_set_ba_policies(struct wl1271 *wl)
 536 {
 537         /* Reset the BA RX indicators */
 538         wl->ba_rx_bitmap = 0;
 539         wl->ba_allowed = true;
 540         wl->ba_rx_session_count = 0;
 541
 542         /* BA is supported in STA/AP modes */
 543         if (wl->bss_type != BSS_TYPE_AP_BSS &&
 544             wl->bss_type != BSS_TYPE_STA_BSS) {
 545                 wl->ba_support = false;
 546                 return 0;
 547         }
 548
 549         wl->ba_support = true;
 550
 551         /* 802.11n initiator BA session setting */
 552         return wl12xx_acx_set_ba_initiator_policy(wl);
 553 }
 554
 555 int wl1271_chip_specific_init(struct wl1271 *wl)
 556 {
 557         int ret = 0;
 558
 559         if (wl->chip.id == CHIP_ID_1283_PG20) {
 560                 u32 host_cfg_bitmap = HOST_IF_CFG_RX_FIFO_ENABLE;
 561
 562                 if (wl->quirks & WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT)
 563                         /* Enable SDIO padding */
 564                         host_cfg_bitmap |= HOST_IF_CFG_TX_PAD_TO_SDIO_BLK;
 565
 566                 /* Must be before wl1271_acx_init_mem_config() */
 567                 ret = wl1271_acx_host_if_cfg_bitmap(wl, host_cfg_bitmap);
 568                 if (ret < 0)
 569                         goto out;
 570         }
 571 out:
 572         return ret;
 573 }
 574
 575
 576 int wl1271_hw_init(struct wl1271 *wl)
 577 {
 578         struct conf_tx_ac_category *conf_ac;
 579         struct conf_tx_tid *conf_tid;
 580         int ret, i;
 581         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
 582
 583         if (wl->chip.id == CHIP_ID_1283_PG20)
 584                 ret = wl128x_cmd_general_parms(wl);
 585         else
 586                 ret = wl1271_cmd_general_parms(wl);
 587         if (ret < 0)
 588                 return ret;
 589
 590         if (wl->chip.id == CHIP_ID_1283_PG20)
 591                 ret = wl128x_cmd_radio_parms(wl);
 592         else
 593                 ret = wl1271_cmd_radio_parms(wl);
 594         if (ret < 0)
 595                 return ret;
 596
 597         /* Chip-specific init */
 598         ret = wl1271_chip_specific_init(wl);
 599         if (ret < 0)
 600                 return ret;
 601
 602         /* Mode specific init */
 603         if (is_ap)
 604                 ret = wl1271_ap_hw_init(wl);
 605         else
 606                 ret = wl1271_sta_hw_init(wl);
 607
 608         if (ret < 0)
 609                 return ret;
 610
 611         /* Bluetooth WLAN coexistence */
 612         ret = wl1271_init_pta(wl);
 613         if (ret < 0)
 614                 return ret;
 615
 616         /* Default memory configuration */
 617         ret = wl1271_acx_init_mem_config(wl);
 618         if (ret < 0)
 619                 return ret;
 620
 621         /* RX config */
 622         ret = wl12xx_init_rx_config(wl);
 623         if (ret < 0)
 624                 goto out_free_memmap;
 625
 626         /* PHY layer config */
 627         ret = wl1271_init_phy_config(wl);
 628         if (ret < 0)
 629                 goto out_free_memmap;
 630
 631         ret = wl1271_acx_dco_itrim_params(wl);
 632         if (ret < 0)
 633                 goto out_free_memmap;
 634
 635         /* Configure TX patch complete interrupt behavior */
 636         ret = wl1271_acx_tx_config_options(wl);
 637         if (ret < 0)
 638                 goto out_free_memmap;
 639
 640         /* RX complete interrupt pacing */
 641         ret = wl1271_acx_init_rx_interrupt(wl);
 642         if (ret < 0)
 643                 goto out_free_memmap;
 644
 645         /* Energy detection */
 646         ret = wl1271_init_energy_detection(wl);
 647         if (ret < 0)
 648                 goto out_free_memmap;
 649
 650         /* Default fragmentation threshold */
 651         ret = wl1271_acx_frag_threshold(wl, wl->hw->wiphy->frag_threshold);
 652         if (ret < 0)
 653                 goto out_free_memmap;
 654
 655         /* Default TID/AC configuration */
 656         BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
 657         for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
 658                 conf_ac = &wl->conf.tx.ac_conf[i];
 659                 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
 660                                         conf_ac->cw_max, conf_ac->aifsn,
 661                                         conf_ac->tx_op_limit);
 662                 if (ret < 0)
 663                         goto out_free_memmap;
 664
 665                 conf_tid = &wl->conf.tx.tid_conf[i];
 666                 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
 667                                          conf_tid->channel_type,
 668                                          conf_tid->tsid,
 669                                          conf_tid->ps_scheme,
 670                                          conf_tid->ack_policy,
 671                                          conf_tid->apsd_conf[0],
 672                                          conf_tid->apsd_conf[1]);
 673                 if (ret < 0)
 674                         goto out_free_memmap;
 675         }
 676
 677         /* Enable data path */
 678         ret = wl1271_cmd_data_path(wl, 1);
 679         if (ret < 0)
 680                 goto out_free_memmap;
 681
 682         /* Configure HW encryption */
 683         ret = wl1271_acx_feature_cfg(wl);
 684         if (ret < 0)
 685                 goto out_free_memmap;
 686
 687         /* configure PM */
 688         ret = wl1271_acx_pm_config(wl);
 689         if (ret < 0)
 690                 goto out_free_memmap;
 691
 692         /* Mode specific init - post mem init */
 693         if (is_ap)
 694                 ret = wl1271_ap_hw_init_post_mem(wl);
 695         else
 696                 ret = wl1271_sta_hw_init_post_mem(wl);
 697
 698         if (ret < 0)
 699                 goto out_free_memmap;
 700
 701         ret = wl12xx_acx_set_rate_mgmt_params(wl);
 702         if (ret < 0)
 703                 goto out_free_memmap;
 704
 705         /* Configure initiator BA sessions policies */
 706         ret = wl1271_set_ba_policies(wl);
 707         if (ret < 0)
 708                 goto out_free_memmap;
 709
 710         return 0;
 711
 712  out_free_memmap:
 713         kfree(wl->target_mem_map);
 714         wl->target_mem_map = NULL;
 715
 716         return ret;
 717 }