drivers/net/wireless/ti/wlcore/cmd.c

   1 /*
   2  * This file is part of wl1271
   3  *
   4  * Copyright (C) 2009-2010 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/module.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/spi/spi.h>
  27 #include <linux/etherdevice.h>
  28 #include <linux/ieee80211.h>
  29 #include <linux/slab.h>
  30
  31 #include "wlcore.h"
  32 #include "debug.h"
  33 #include "io.h"
  34 #include "acx.h"
  35 #include "wl12xx_80211.h"
  36 #include "cmd.h"
  37 #include "event.h"
  38 #include "tx.h"
  39 #include "hw_ops.h"
  40
  41 #define WL1271_CMD_FAST_POLL_COUNT       50
  42 #define WL1271_WAIT_EVENT_FAST_POLL_COUNT 20
  43
  44 /*
  45  * send command to firmware
  46  *
  47  * @wl: wl struct
  48  * @id: command id
  49  * @buf: buffer containing the command, must work with dma
  50  * @len: length of the buffer
  51  * return the cmd status code on success.
  52  */
  53 static int __wlcore_cmd_send(struct wl1271 *wl, u16 id, void *buf,
  54                              size_t len, size_t res_len)
  55 {
  56         struct wl1271_cmd_header *cmd;
  57         unsigned long timeout;
  58         u32 intr;
  59         int ret;
  60         u16 status;
  61         u16 poll_count = 0;
  62
  63         if (WARN_ON(unlikely(wl->state == WLCORE_STATE_RESTARTING)))
  64                 return -EIO;
  65
  66         cmd = buf;
  67         cmd->id = cpu_to_le16(id);
  68         cmd->status = 0;
  69
  70         WARN_ON(len % 4 != 0);
  71         WARN_ON(test_bit(WL1271_FLAG_IN_ELP, &wl->flags));
  72
  73         ret = wlcore_write(wl, wl->cmd_box_addr, buf, len, false);
  74         if (ret < 0)
  75                 return ret;
  76
  77         /*
  78          * TODO: we just need this because one bit is in a different
  79          * place.  Is there any better way?
  80          */
  81         ret = wl->ops->trigger_cmd(wl, wl->cmd_box_addr, buf, len);
  82         if (ret < 0)
  83                 return ret;
  84
  85         timeout = jiffies + msecs_to_jiffies(WL1271_COMMAND_TIMEOUT);
  86
  87         ret = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR, &intr);
  88         if (ret < 0)
  89                 return ret;
  90
  91         while (!(intr & WL1271_ACX_INTR_CMD_COMPLETE)) {
  92                 if (time_after(jiffies, timeout)) {
  93                         wl1271_error("command complete timeout");
  94                         return -ETIMEDOUT;
  95                 }
  96
  97                 poll_count++;
  98                 if (poll_count < WL1271_CMD_FAST_POLL_COUNT)
  99                         udelay(10);
 100                 else
 101                         msleep(1);
 102
 103                 ret = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR, &intr);
 104                 if (ret < 0)
 105                         return ret;
 106         }
 107
 108         /* read back the status code of the command */
 109         if (res_len == 0)
 110                 res_len = sizeof(struct wl1271_cmd_header);
 111
 112         ret = wlcore_read(wl, wl->cmd_box_addr, cmd, res_len, false);
 113         if (ret < 0)
 114                 return ret;
 115
 116         status = le16_to_cpu(cmd->status);
 117
 118         ret = wlcore_write_reg(wl, REG_INTERRUPT_ACK,
 119                                WL1271_ACX_INTR_CMD_COMPLETE);
 120         if (ret < 0)
 121                 return ret;
 122
 123         return status;
 124 }
 125
 126 /*
 127  * send command to fw and return cmd status on success
 128  * valid_rets contains a bitmap of allowed error codes
 129  */
 130 int wlcore_cmd_send_failsafe(struct wl1271 *wl, u16 id, void *buf, size_t len,
 131                              size_t res_len, unsigned long valid_rets)
 132 {
 133         int ret = __wlcore_cmd_send(wl, id, buf, len, res_len);
 134
 135         if (ret < 0)
 136                 goto fail;
 137
 138         /* success is always a valid status */
 139         valid_rets |= BIT(CMD_STATUS_SUCCESS);
 140
 141         if (ret >= MAX_COMMAND_STATUS ||
 142             !test_bit(ret, &valid_rets)) {
 143                 wl1271_error("command execute failure %d", ret);
 144                 ret = -EIO;
 145                 goto fail;
 146         }
 147         return ret;
 148 fail:
 149         wl12xx_queue_recovery_work(wl);
 150         return ret;
 151 }
 152 EXPORT_SYMBOL_GPL(wl1271_cmd_send);
 153
 154 /*
 155  * wrapper for wlcore_cmd_send that accept only CMD_STATUS_SUCCESS
 156  * return 0 on success.
 157  */
 158 int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len,
 159                     size_t res_len)
 160 {
 161         int ret = wlcore_cmd_send_failsafe(wl, id, buf, len, res_len, 0);
 162
 163         if (ret < 0)
 164                 return ret;
 165         return 0;
 166 }
 167
 168 /*
 169  * Poll the mailbox event field until any of the bits in the mask is set or a
 170  * timeout occurs (WL1271_EVENT_TIMEOUT in msecs)
 171  */
 172 int wlcore_cmd_wait_for_event_or_timeout(struct wl1271 *wl,
 173                                          u32 mask, bool *timeout)
 174 {
 175         u32 *events_vector;
 176         u32 event;
 177         unsigned long timeout_time;
 178         u16 poll_count = 0;
 179         int ret = 0;
 180
 181         *timeout = false;
 182
 183         events_vector = kmalloc(sizeof(*events_vector), GFP_KERNEL | GFP_DMA);
 184         if (!events_vector)
 185                 return -ENOMEM;
 186
 187         timeout_time = jiffies + msecs_to_jiffies(WL1271_EVENT_TIMEOUT);
 188
 189         do {
 190                 if (time_after(jiffies, timeout_time)) {
 191                         wl1271_debug(DEBUG_CMD, "timeout waiting for event %d",
 192                                      (int)mask);
 193                         *timeout = true;
 194                         goto out;
 195                 }
 196
 197                 poll_count++;
 198                 if (poll_count < WL1271_WAIT_EVENT_FAST_POLL_COUNT)
 199                         usleep_range(50, 51);
 200                 else
 201                         usleep_range(1000, 5000);
 202
 203                 /* read from both event fields */
 204                 ret = wlcore_read(wl, wl->mbox_ptr[0], events_vector,
 205                                   sizeof(*events_vector), false);
 206                 if (ret < 0)
 207                         goto out;
 208
 209                 event = *events_vector & mask;
 210
 211                 ret = wlcore_read(wl, wl->mbox_ptr[1], events_vector,
 212                                   sizeof(*events_vector), false);
 213                 if (ret < 0)
 214                         goto out;
 215
 216                 event |= *events_vector & mask;
 217         } while (!event);
 218
 219 out:
 220         kfree(events_vector);
 221         return ret;
 222 }
 223 EXPORT_SYMBOL_GPL(wlcore_cmd_wait_for_event_or_timeout);
 224
 225 int wl12xx_cmd_role_enable(struct wl1271 *wl, u8 *addr, u8 role_type,
 226                            u8 *role_id)
 227 {
 228         struct wl12xx_cmd_role_enable *cmd;
 229         int ret;
 230
 231         wl1271_debug(DEBUG_CMD, "cmd role enable");
 232
 233         if (WARN_ON(*role_id != WL12XX_INVALID_ROLE_ID))
 234                 return -EBUSY;
 235
 236         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 237         if (!cmd) {
 238                 ret = -ENOMEM;
 239                 goto out;
 240         }
 241
 242         /* get role id */
 243         cmd->role_id = find_first_zero_bit(wl->roles_map, WL12XX_MAX_ROLES);
 244         if (cmd->role_id >= WL12XX_MAX_ROLES) {
 245                 ret = -EBUSY;
 246                 goto out_free;
 247         }
 248
 249         memcpy(cmd->mac_address, addr, ETH_ALEN);
 250         cmd->role_type = role_type;
 251
 252         ret = wl1271_cmd_send(wl, CMD_ROLE_ENABLE, cmd, sizeof(*cmd), 0);
 253         if (ret < 0) {
 254                 wl1271_error("failed to initiate cmd role enable");
 255                 goto out_free;
 256         }
 257
 258         __set_bit(cmd->role_id, wl->roles_map);
 259         *role_id = cmd->role_id;
 260
 261 out_free:
 262         kfree(cmd);
 263
 264 out:
 265         return ret;
 266 }
 267
 268 int wl12xx_cmd_role_disable(struct wl1271 *wl, u8 *role_id)
 269 {
 270         struct wl12xx_cmd_role_disable *cmd;
 271         int ret;
 272
 273         wl1271_debug(DEBUG_CMD, "cmd role disable");
 274
 275         if (WARN_ON(*role_id == WL12XX_INVALID_ROLE_ID))
 276                 return -ENOENT;
 277
 278         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 279         if (!cmd) {
 280                 ret = -ENOMEM;
 281                 goto out;
 282         }
 283         cmd->role_id = *role_id;
 284
 285         ret = wl1271_cmd_send(wl, CMD_ROLE_DISABLE, cmd, sizeof(*cmd), 0);
 286         if (ret < 0) {
 287                 wl1271_error("failed to initiate cmd role disable");
 288                 goto out_free;
 289         }
 290
 291         __clear_bit(*role_id, wl->roles_map);
 292         *role_id = WL12XX_INVALID_ROLE_ID;
 293
 294 out_free:
 295         kfree(cmd);
 296
 297 out:
 298         return ret;
 299 }
 300
 301 static int wlcore_get_new_session_id(struct wl1271 *wl, u8 hlid)
 302 {
 303         if (wl->session_ids[hlid] >= SESSION_COUNTER_MAX)
 304                 wl->session_ids[hlid] = 0;
 305
 306         wl->session_ids[hlid]++;
 307
 308         return wl->session_ids[hlid];
 309 }
 310
 311 int wl12xx_allocate_link(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 *hlid)
 312 {
 313         unsigned long flags;
 314         u8 link = find_first_zero_bit(wl->links_map, WL12XX_MAX_LINKS);
 315         if (link >= WL12XX_MAX_LINKS)
 316                 return -EBUSY;
 317
 318         wl->session_ids[link] = wlcore_get_new_session_id(wl, link);
 319
 320         /* these bits are used by op_tx */
 321         spin_lock_irqsave(&wl->wl_lock, flags);
 322         __set_bit(link, wl->links_map);
 323         __set_bit(link, wlvif->links_map);
 324         spin_unlock_irqrestore(&wl->wl_lock, flags);
 325
 326         /* take the last "freed packets" value from the current FW status */
 327         wl->links[link].prev_freed_pkts =
 328                         wl->fw_status_2->counters.tx_lnk_free_pkts[link];
 329         wl->links[link].wlvif = wlvif;
 330         *hlid = link;
 331
 332         wl->active_link_count++;
 333         return 0;
 334 }
 335
 336 void wl12xx_free_link(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 *hlid)
 337 {
 338         unsigned long flags;
 339
 340         if (*hlid == WL12XX_INVALID_LINK_ID)
 341                 return;
 342
 343         /* these bits are used by op_tx */
 344         spin_lock_irqsave(&wl->wl_lock, flags);
 345         __clear_bit(*hlid, wl->links_map);
 346         __clear_bit(*hlid, wlvif->links_map);
 347         spin_unlock_irqrestore(&wl->wl_lock, flags);
 348
 349         wl->links[*hlid].allocated_pkts = 0;
 350         wl->links[*hlid].prev_freed_pkts = 0;
 351         wl->links[*hlid].ba_bitmap = 0;
 352         memset(wl->links[*hlid].addr, 0, ETH_ALEN);
 353
 354         /*
 355          * At this point op_tx() will not add more packets to the queues. We
 356          * can purge them.
 357          */
 358         wl1271_tx_reset_link_queues(wl, *hlid);
 359         wl->links[*hlid].wlvif = NULL;
 360
 361         *hlid = WL12XX_INVALID_LINK_ID;
 362         wl->active_link_count--;
 363         WARN_ON_ONCE(wl->active_link_count < 0);
 364 }
 365
 366 static u8 wlcore_get_native_channel_type(u8 nl_channel_type)
 367 {
 368         switch (nl_channel_type) {
 369         case NL80211_CHAN_NO_HT:
 370                 return WLCORE_CHAN_NO_HT;
 371         case NL80211_CHAN_HT20:
 372                 return WLCORE_CHAN_HT20;
 373         case NL80211_CHAN_HT40MINUS:
 374                 return WLCORE_CHAN_HT40MINUS;
 375         case NL80211_CHAN_HT40PLUS:
 376                 return WLCORE_CHAN_HT40PLUS;
 377         default:
 378                 WARN_ON(1);
 379                 return WLCORE_CHAN_NO_HT;
 380         }
 381 }
 382
 383 static int wl12xx_cmd_role_start_dev(struct wl1271 *wl,
 384                                      struct wl12xx_vif *wlvif,
 385                                      enum ieee80211_band band,
 386                                      int channel)
 387 {
 388         struct wl12xx_cmd_role_start *cmd;
 389         int ret;
 390
 391         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 392         if (!cmd) {
 393                 ret = -ENOMEM;
 394                 goto out;
 395         }
 396
 397         wl1271_debug(DEBUG_CMD, "cmd role start dev %d", wlvif->dev_role_id);
 398
 399         cmd->role_id = wlvif->dev_role_id;
 400         if (band == IEEE80211_BAND_5GHZ)
 401                 cmd->band = WLCORE_BAND_5GHZ;
 402         cmd->channel = channel;
 403
 404         if (wlvif->dev_hlid == WL12XX_INVALID_LINK_ID) {
 405                 ret = wl12xx_allocate_link(wl, wlvif, &wlvif->dev_hlid);
 406                 if (ret)
 407                         goto out_free;
 408         }
 409         cmd->device.hlid = wlvif->dev_hlid;
 410         cmd->device.session = wl->session_ids[wlvif->dev_hlid];
 411
 412         wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d",
 413                      cmd->role_id, cmd->device.hlid, cmd->device.session);
 414
 415         ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0);
 416         if (ret < 0) {
 417                 wl1271_error("failed to initiate cmd role enable");
 418                 goto err_hlid;
 419         }
 420
 421         goto out_free;
 422
 423 err_hlid:
 424         /* clear links on error */
 425         wl12xx_free_link(wl, wlvif, &wlvif->dev_hlid);
 426
 427 out_free:
 428         kfree(cmd);
 429
 430 out:
 431         return ret;
 432 }
 433
 434 static int wl12xx_cmd_role_stop_dev(struct wl1271 *wl,
 435                                     struct wl12xx_vif *wlvif)
 436 {
 437         struct wl12xx_cmd_role_stop *cmd;
 438         int ret;
 439
 440         if (WARN_ON(wlvif->dev_hlid == WL12XX_INVALID_LINK_ID))
 441                 return -EINVAL;
 442
 443         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 444         if (!cmd) {
 445                 ret = -ENOMEM;
 446                 goto out;
 447         }
 448
 449         wl1271_debug(DEBUG_CMD, "cmd role stop dev");
 450
 451         cmd->role_id = wlvif->dev_role_id;
 452         cmd->disc_type = DISCONNECT_IMMEDIATE;
 453         cmd->reason = cpu_to_le16(WLAN_REASON_UNSPECIFIED);
 454
 455         ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0);
 456         if (ret < 0) {
 457                 wl1271_error("failed to initiate cmd role stop");
 458                 goto out_free;
 459         }
 460
 461         wl12xx_free_link(wl, wlvif, &wlvif->dev_hlid);
 462
 463 out_free:
 464         kfree(cmd);
 465
 466 out:
 467         return ret;
 468 }
 469
 470 int wl12xx_cmd_role_start_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 471 {
 472         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
 473         struct wl12xx_cmd_role_start *cmd;
 474         u32 supported_rates;
 475         int ret;
 476
 477         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 478         if (!cmd) {
 479                 ret = -ENOMEM;
 480                 goto out;
 481         }
 482
 483         wl1271_debug(DEBUG_CMD, "cmd role start sta %d", wlvif->role_id);
 484
 485         cmd->role_id = wlvif->role_id;
 486         if (wlvif->band == IEEE80211_BAND_5GHZ)
 487                 cmd->band = WLCORE_BAND_5GHZ;
 488         cmd->channel = wlvif->channel;
 489         cmd->sta.basic_rate_set = cpu_to_le32(wlvif->basic_rate_set);
 490         cmd->sta.beacon_interval = cpu_to_le16(wlvif->beacon_int);
 491         cmd->sta.ssid_type = WL12XX_SSID_TYPE_ANY;
 492         cmd->sta.ssid_len = wlvif->ssid_len;
 493         memcpy(cmd->sta.ssid, wlvif->ssid, wlvif->ssid_len);
 494         memcpy(cmd->sta.bssid, vif->bss_conf.bssid, ETH_ALEN);
 495
 496         supported_rates = CONF_TX_ENABLED_RATES | CONF_TX_MCS_RATES |
 497                           wlcore_hw_sta_get_ap_rate_mask(wl, wlvif);
 498         if (wlvif->p2p)
 499                 supported_rates &= ~CONF_TX_CCK_RATES;
 500
 501         cmd->sta.local_rates = cpu_to_le32(supported_rates);
 502
 503         cmd->channel_type = wlcore_get_native_channel_type(wlvif->channel_type);
 504
 505         if (wlvif->sta.hlid == WL12XX_INVALID_LINK_ID) {
 506                 ret = wl12xx_allocate_link(wl, wlvif, &wlvif->sta.hlid);
 507                 if (ret)
 508                         goto out_free;
 509         }
 510         cmd->sta.hlid = wlvif->sta.hlid;
 511         cmd->sta.session = wl->session_ids[wlvif->sta.hlid];
 512         /*
 513          * We don't have the correct remote rates in this stage.  The
 514          * rates will be reconfigured later, after association, if the
 515          * firmware supports ACX_PEER_CAP.  Otherwise, there's nothing
 516          * we can do, so use all supported_rates here.
 517          */
 518         cmd->sta.remote_rates = cpu_to_le32(supported_rates);
 519
 520         wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d "
 521                      "basic_rate_set: 0x%x, remote_rates: 0x%x",
 522                      wlvif->role_id, cmd->sta.hlid, cmd->sta.session,
 523                      wlvif->basic_rate_set, wlvif->rate_set);
 524
 525         ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0);
 526         if (ret < 0) {
 527                 wl1271_error("failed to initiate cmd role start sta");
 528                 goto err_hlid;
 529         }
 530
 531         wlvif->sta.role_chan_type = wlvif->channel_type;
 532         goto out_free;
 533
 534 err_hlid:
 535         /* clear links on error. */
 536         wl12xx_free_link(wl, wlvif, &wlvif->sta.hlid);
 537
 538 out_free:
 539         kfree(cmd);
 540
 541 out:
 542         return ret;
 543 }
 544
 545 /* use this function to stop ibss as well */
 546 int wl12xx_cmd_role_stop_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 547 {
 548         struct wl12xx_cmd_role_stop *cmd;
 549         int ret;
 550
 551         if (WARN_ON(wlvif->sta.hlid == WL12XX_INVALID_LINK_ID))
 552                 return -EINVAL;
 553
 554         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 555         if (!cmd) {
 556                 ret = -ENOMEM;
 557                 goto out;
 558         }
 559
 560         wl1271_debug(DEBUG_CMD, "cmd role stop sta %d", wlvif->role_id);
 561
 562         cmd->role_id = wlvif->role_id;
 563         cmd->disc_type = DISCONNECT_IMMEDIATE;
 564         cmd->reason = cpu_to_le16(WLAN_REASON_UNSPECIFIED);
 565
 566         ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0);
 567         if (ret < 0) {
 568                 wl1271_error("failed to initiate cmd role stop sta");
 569                 goto out_free;
 570         }
 571
 572         wl12xx_free_link(wl, wlvif, &wlvif->sta.hlid);
 573
 574 out_free:
 575         kfree(cmd);
 576
 577 out:
 578         return ret;
 579 }
 580
 581 int wl12xx_cmd_role_start_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 582 {
 583         struct wl12xx_cmd_role_start *cmd;
 584         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
 585         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
 586         u32 supported_rates;
 587         int ret;
 588
 589         wl1271_debug(DEBUG_CMD, "cmd role start ap %d", wlvif->role_id);
 590
 591         /* trying to use hidden SSID with an old hostapd version */
 592         if (wlvif->ssid_len == 0 && !bss_conf->hidden_ssid) {
 593                 wl1271_error("got a null SSID from beacon/bss");
 594                 ret = -EINVAL;
 595                 goto out;
 596         }
 597
 598         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 599         if (!cmd) {
 600                 ret = -ENOMEM;
 601                 goto out;
 602         }
 603
 604         ret = wl12xx_allocate_link(wl, wlvif, &wlvif->ap.global_hlid);
 605         if (ret < 0)
 606                 goto out_free;
 607
 608         ret = wl12xx_allocate_link(wl, wlvif, &wlvif->ap.bcast_hlid);
 609         if (ret < 0)
 610                 goto out_free_global;
 611
 612         cmd->role_id = wlvif->role_id;
 613         cmd->ap.aging_period = cpu_to_le16(wl->conf.tx.ap_aging_period);
 614         cmd->ap.bss_index = WL1271_AP_BSS_INDEX;
 615         cmd->ap.global_hlid = wlvif->ap.global_hlid;
 616         cmd->ap.broadcast_hlid = wlvif->ap.bcast_hlid;
 617         cmd->ap.global_session_id = wl->session_ids[wlvif->ap.global_hlid];
 618         cmd->ap.bcast_session_id = wl->session_ids[wlvif->ap.bcast_hlid];
 619         cmd->ap.basic_rate_set = cpu_to_le32(wlvif->basic_rate_set);
 620         cmd->ap.beacon_interval = cpu_to_le16(wlvif->beacon_int);
 621         cmd->ap.dtim_interval = bss_conf->dtim_period;
 622         cmd->ap.beacon_expiry = WL1271_AP_DEF_BEACON_EXP;
 623         /* FIXME: Change when adding DFS */
 624         cmd->ap.reset_tsf = 1;  /* By default reset AP TSF */
 625         cmd->ap.wmm = wlvif->wmm_enabled;
 626         cmd->channel = wlvif->channel;
 627         cmd->channel_type = wlcore_get_native_channel_type(wlvif->channel_type);
 628
 629         if (!bss_conf->hidden_ssid) {
 630                 /* take the SSID from the beacon for backward compatibility */
 631                 cmd->ap.ssid_type = WL12XX_SSID_TYPE_PUBLIC;
 632                 cmd->ap.ssid_len = wlvif->ssid_len;
 633                 memcpy(cmd->ap.ssid, wlvif->ssid, wlvif->ssid_len);
 634         } else {
 635                 cmd->ap.ssid_type = WL12XX_SSID_TYPE_HIDDEN;
 636                 cmd->ap.ssid_len = bss_conf->ssid_len;
 637                 memcpy(cmd->ap.ssid, bss_conf->ssid, bss_conf->ssid_len);
 638         }
 639
 640         supported_rates = CONF_TX_ENABLED_RATES | CONF_TX_MCS_RATES |
 641                 wlcore_hw_ap_get_mimo_wide_rate_mask(wl, wlvif);
 642         if (wlvif->p2p)
 643                 supported_rates &= ~CONF_TX_CCK_RATES;
 644
 645         wl1271_debug(DEBUG_CMD, "cmd role start ap with supported_rates 0x%08x",
 646                      supported_rates);
 647
 648         cmd->ap.local_rates = cpu_to_le32(supported_rates);
 649
 650         switch (wlvif->band) {
 651         case IEEE80211_BAND_2GHZ:
 652                 cmd->band = WLCORE_BAND_2_4GHZ;
 653                 break;
 654         case IEEE80211_BAND_5GHZ:
 655                 cmd->band = WLCORE_BAND_5GHZ;
 656                 break;
 657         default:
 658                 wl1271_warning("ap start - unknown band: %d", (int)wlvif->band);
 659                 cmd->band = WLCORE_BAND_2_4GHZ;
 660                 break;
 661         }
 662
 663         ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0);
 664         if (ret < 0) {
 665                 wl1271_error("failed to initiate cmd role start ap");
 666                 goto out_free_bcast;
 667         }
 668
 669         goto out_free;
 670
 671 out_free_bcast:
 672         wl12xx_free_link(wl, wlvif, &wlvif->ap.bcast_hlid);
 673
 674 out_free_global:
 675         wl12xx_free_link(wl, wlvif, &wlvif->ap.global_hlid);
 676
 677 out_free:
 678         kfree(cmd);
 679
 680 out:
 681         return ret;
 682 }
 683
 684 int wl12xx_cmd_role_stop_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 685 {
 686         struct wl12xx_cmd_role_stop *cmd;
 687         int ret;
 688
 689         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 690         if (!cmd) {
 691                 ret = -ENOMEM;
 692                 goto out;
 693         }
 694
 695         wl1271_debug(DEBUG_CMD, "cmd role stop ap %d", wlvif->role_id);
 696
 697         cmd->role_id = wlvif->role_id;
 698
 699         ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0);
 700         if (ret < 0) {
 701                 wl1271_error("failed to initiate cmd role stop ap");
 702                 goto out_free;
 703         }
 704
 705         wl12xx_free_link(wl, wlvif, &wlvif->ap.bcast_hlid);
 706         wl12xx_free_link(wl, wlvif, &wlvif->ap.global_hlid);
 707
 708 out_free:
 709         kfree(cmd);
 710
 711 out:
 712         return ret;
 713 }
 714
 715 int wl12xx_cmd_role_start_ibss(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 716 {
 717         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
 718         struct wl12xx_cmd_role_start *cmd;
 719         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
 720         int ret;
 721
 722         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 723         if (!cmd) {
 724                 ret = -ENOMEM;
 725                 goto out;
 726         }
 727
 728         wl1271_debug(DEBUG_CMD, "cmd role start ibss %d", wlvif->role_id);
 729
 730         cmd->role_id = wlvif->role_id;
 731         if (wlvif->band == IEEE80211_BAND_5GHZ)
 732                 cmd->band = WLCORE_BAND_5GHZ;
 733         cmd->channel = wlvif->channel;
 734         cmd->ibss.basic_rate_set = cpu_to_le32(wlvif->basic_rate_set);
 735         cmd->ibss.beacon_interval = cpu_to_le16(wlvif->beacon_int);
 736         cmd->ibss.dtim_interval = bss_conf->dtim_period;
 737         cmd->ibss.ssid_type = WL12XX_SSID_TYPE_ANY;
 738         cmd->ibss.ssid_len = wlvif->ssid_len;
 739         memcpy(cmd->ibss.ssid, wlvif->ssid, wlvif->ssid_len);
 740         memcpy(cmd->ibss.bssid, vif->bss_conf.bssid, ETH_ALEN);
 741         cmd->sta.local_rates = cpu_to_le32(wlvif->rate_set);
 742
 743         if (wlvif->sta.hlid == WL12XX_INVALID_LINK_ID) {
 744                 ret = wl12xx_allocate_link(wl, wlvif, &wlvif->sta.hlid);
 745                 if (ret)
 746                         goto out_free;
 747         }
 748         cmd->ibss.hlid = wlvif->sta.hlid;
 749         cmd->ibss.remote_rates = cpu_to_le32(wlvif->rate_set);
 750
 751         wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d "
 752                      "basic_rate_set: 0x%x, remote_rates: 0x%x",
 753                      wlvif->role_id, cmd->sta.hlid, cmd->sta.session,
 754                      wlvif->basic_rate_set, wlvif->rate_set);
 755
 756         wl1271_debug(DEBUG_CMD, "vif->bss_conf.bssid = %pM",
 757                      vif->bss_conf.bssid);
 758
 759         ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0);
 760         if (ret < 0) {
 761                 wl1271_error("failed to initiate cmd role enable");
 762                 goto err_hlid;
 763         }
 764
 765         goto out_free;
 766
 767 err_hlid:
 768         /* clear links on error. */
 769         wl12xx_free_link(wl, wlvif, &wlvif->sta.hlid);
 770
 771 out_free:
 772         kfree(cmd);
 773
 774 out:
 775         return ret;
 776 }
 777
 778
 779 /**
 780  * send test command to firmware
 781  *
 782  * @wl: wl struct
 783  * @buf: buffer containing the command, with all headers, must work with dma
 784  * @len: length of the buffer
 785  * @answer: is answer needed
 786  */
 787 int wl1271_cmd_test(struct wl1271 *wl, void *buf, size_t buf_len, u8 answer)
 788 {
 789         int ret;
 790         size_t res_len = 0;
 791
 792         wl1271_debug(DEBUG_CMD, "cmd test");
 793
 794         if (answer)
 795                 res_len = buf_len;
 796
 797         ret = wl1271_cmd_send(wl, CMD_TEST, buf, buf_len, res_len);
 798
 799         if (ret < 0) {
 800                 wl1271_warning("TEST command failed");
 801                 return ret;
 802         }
 803
 804         return ret;
 805 }
 806 EXPORT_SYMBOL_GPL(wl1271_cmd_test);
 807
 808 /**
 809  * read acx from firmware
 810  *
 811  * @wl: wl struct
 812  * @id: acx id
 813  * @buf: buffer for the response, including all headers, must work with dma
 814  * @len: length of buf
 815  */
 816 int wl1271_cmd_interrogate(struct wl1271 *wl, u16 id, void *buf, size_t len)
 817 {
 818         struct acx_header *acx = buf;
 819         int ret;
 820
 821         wl1271_debug(DEBUG_CMD, "cmd interrogate");
 822
 823         acx->id = cpu_to_le16(id);
 824
 825         /* payload length, does not include any headers */
 826         acx->len = cpu_to_le16(len - sizeof(*acx));
 827
 828         ret = wl1271_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx), len);
 829         if (ret < 0)
 830                 wl1271_error("INTERROGATE command failed");
 831
 832         return ret;
 833 }
 834
 835 /**
 836  * write acx value to firmware
 837  *
 838  * @wl: wl struct
 839  * @id: acx id
 840  * @buf: buffer containing acx, including all headers, must work with dma
 841  * @len: length of buf
 842  * @valid_rets: bitmap of valid cmd status codes (i.e. return values).
 843  * return the cmd status on success.
 844  */
 845 int wlcore_cmd_configure_failsafe(struct wl1271 *wl, u16 id, void *buf,
 846                                   size_t len, unsigned long valid_rets)
 847 {
 848         struct acx_header *acx = buf;
 849         int ret;
 850
 851         wl1271_debug(DEBUG_CMD, "cmd configure (%d)", id);
 852
 853         acx->id = cpu_to_le16(id);
 854
 855         /* payload length, does not include any headers */
 856         acx->len = cpu_to_le16(len - sizeof(*acx));
 857
 858         ret = wlcore_cmd_send_failsafe(wl, CMD_CONFIGURE, acx, len, 0,
 859                                        valid_rets);
 860         if (ret < 0) {
 861                 wl1271_warning("CONFIGURE command NOK");
 862                 return ret;
 863         }
 864
 865         return ret;
 866 }
 867
 868 /*
 869  * wrapper for wlcore_cmd_configure that accepts only success status.
 870  * return 0 on success
 871  */
 872 int wl1271_cmd_configure(struct wl1271 *wl, u16 id, void *buf, size_t len)
 873 {
 874         int ret = wlcore_cmd_configure_failsafe(wl, id, buf, len, 0);
 875
 876         if (ret < 0)
 877                 return ret;
 878         return 0;
 879 }
 880 EXPORT_SYMBOL_GPL(wl1271_cmd_configure);
 881
 882 int wl1271_cmd_data_path(struct wl1271 *wl, bool enable)
 883 {
 884         struct cmd_enabledisable_path *cmd;
 885         int ret;
 886         u16 cmd_rx, cmd_tx;
 887
 888         wl1271_debug(DEBUG_CMD, "cmd data path");
 889
 890         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 891         if (!cmd) {
 892                 ret = -ENOMEM;
 893                 goto out;
 894         }
 895
 896         /* the channel here is only used for calibration, so hardcoded to 1 */
 897         cmd->channel = 1;
 898
 899         if (enable) {
 900                 cmd_rx = CMD_ENABLE_RX;
 901                 cmd_tx = CMD_ENABLE_TX;
 902         } else {
 903                 cmd_rx = CMD_DISABLE_RX;
 904                 cmd_tx = CMD_DISABLE_TX;
 905         }
 906
 907         ret = wl1271_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd), 0);
 908         if (ret < 0) {
 909                 wl1271_error("rx %s cmd for channel %d failed",
 910                              enable ? "start" : "stop", cmd->channel);
 911                 goto out;
 912         }
 913
 914         wl1271_debug(DEBUG_BOOT, "rx %s cmd channel %d",
 915                      enable ? "start" : "stop", cmd->channel);
 916
 917         ret = wl1271_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd), 0);
 918         if (ret < 0) {
 919                 wl1271_error("tx %s cmd for channel %d failed",
 920                              enable ? "start" : "stop", cmd->channel);
 921                 goto out;
 922         }
 923
 924         wl1271_debug(DEBUG_BOOT, "tx %s cmd channel %d",
 925                      enable ? "start" : "stop", cmd->channel);
 926
 927 out:
 928         kfree(cmd);
 929         return ret;
 930 }
 931 EXPORT_SYMBOL_GPL(wl1271_cmd_data_path);
 932
 933 int wl1271_cmd_ps_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
 934                        u8 ps_mode, u16 auto_ps_timeout)
 935 {
 936         struct wl1271_cmd_ps_params *ps_params = NULL;
 937         int ret = 0;
 938
 939         wl1271_debug(DEBUG_CMD, "cmd set ps mode");
 940
 941         ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
 942         if (!ps_params) {
 943                 ret = -ENOMEM;
 944                 goto out;
 945         }
 946
 947         ps_params->role_id = wlvif->role_id;
 948         ps_params->ps_mode = ps_mode;
 949         ps_params->auto_ps_timeout = auto_ps_timeout;
 950
 951         ret = wl1271_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
 952                               sizeof(*ps_params), 0);
 953         if (ret < 0) {
 954                 wl1271_error("cmd set_ps_mode failed");
 955                 goto out;
 956         }
 957
 958 out:
 959         kfree(ps_params);
 960         return ret;
 961 }
 962
 963 int wl1271_cmd_template_set(struct wl1271 *wl, u8 role_id,
 964                             u16 template_id, void *buf, size_t buf_len,
 965                             int index, u32 rates)
 966 {
 967         struct wl1271_cmd_template_set *cmd;
 968         int ret = 0;
 969
 970         wl1271_debug(DEBUG_CMD, "cmd template_set %d (role %d)",
 971                      template_id, role_id);
 972
 973         WARN_ON(buf_len > WL1271_CMD_TEMPL_MAX_SIZE);
 974         buf_len = min_t(size_t, buf_len, WL1271_CMD_TEMPL_MAX_SIZE);
 975
 976         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 977         if (!cmd) {
 978                 ret = -ENOMEM;
 979                 goto out;
 980         }
 981
 982         /* during initialization wlvif is NULL */
 983         cmd->role_id = role_id;
 984         cmd->len = cpu_to_le16(buf_len);
 985         cmd->template_type = template_id;
 986         cmd->enabled_rates = cpu_to_le32(rates);
 987         cmd->short_retry_limit = wl->conf.tx.tmpl_short_retry_limit;
 988         cmd->long_retry_limit = wl->conf.tx.tmpl_long_retry_limit;
 989         cmd->index = index;
 990
 991         if (buf)
 992                 memcpy(cmd->template_data, buf, buf_len);
 993
 994         ret = wl1271_cmd_send(wl, CMD_SET_TEMPLATE, cmd, sizeof(*cmd), 0);
 995         if (ret < 0) {
 996                 wl1271_warning("cmd set_template failed: %d", ret);
 997                 goto out_free;
 998         }
 999
1000 out_free:
1001         kfree(cmd);
1002
1003 out:
1004         return ret;
1005 }
1006
1007 int wl12xx_cmd_build_null_data(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1008 {
1009         struct sk_buff *skb = NULL;
1010         int size;
1011         void *ptr;
1012         int ret = -ENOMEM;
1013
1014
1015         if (wlvif->bss_type == BSS_TYPE_IBSS) {
1016                 size = sizeof(struct wl12xx_null_data_template);
1017                 ptr = NULL;
1018         } else {
1019                 skb = ieee80211_nullfunc_get(wl->hw,
1020                                              wl12xx_wlvif_to_vif(wlvif));
1021                 if (!skb)
1022                         goto out;
1023                 size = skb->len;
1024                 ptr = skb->data;
1025         }
1026
1027         ret = wl1271_cmd_template_set(wl, wlvif->role_id,
1028                                       CMD_TEMPL_NULL_DATA, ptr, size, 0,
1029                                       wlvif->basic_rate);
1030
1031 out:
1032         dev_kfree_skb(skb);
1033         if (ret)
1034                 wl1271_warning("cmd buld null data failed %d", ret);
1035
1036         return ret;
1037
1038 }
1039
1040 int wl12xx_cmd_build_klv_null_data(struct wl1271 *wl,
1041                                    struct wl12xx_vif *wlvif)
1042 {
1043         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
1044         struct sk_buff *skb = NULL;
1045         int ret = -ENOMEM;
1046
1047         skb = ieee80211_nullfunc_get(wl->hw, vif);
1048         if (!skb)
1049                 goto out;
1050
1051         ret = wl1271_cmd_template_set(wl, wlvif->role_id, CMD_TEMPL_KLV,
1052                                       skb->data, skb->len,
1053                                       wlvif->sta.klv_template_id,
1054                                       wlvif->basic_rate);
1055
1056 out:
1057         dev_kfree_skb(skb);
1058         if (ret)
1059                 wl1271_warning("cmd build klv null data failed %d", ret);
1060
1061         return ret;
1062
1063 }
1064
1065 int wl1271_cmd_build_ps_poll(struct wl1271 *wl, struct wl12xx_vif *wlvif,
1066                              u16 aid)
1067 {
1068         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
1069         struct sk_buff *skb;
1070         int ret = 0;
1071
1072         skb = ieee80211_pspoll_get(wl->hw, vif);
1073         if (!skb)
1074                 goto out;
1075
1076         ret = wl1271_cmd_template_set(wl, wlvif->role_id,
1077                                       CMD_TEMPL_PS_POLL, skb->data,
1078                                       skb->len, 0, wlvif->basic_rate_set);
1079
1080 out:
1081         dev_kfree_skb(skb);
1082         return ret;
1083 }
1084
1085 int wl12xx_cmd_build_probe_req(struct wl1271 *wl, struct wl12xx_vif *wlvif,
1086                                u8 role_id, u8 band,
1087                                const u8 *ssid, size_t ssid_len,
1088                                const u8 *ie, size_t ie_len, bool sched_scan)
1089 {
1090         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
1091         struct sk_buff *skb;
1092         int ret;
1093         u32 rate;
1094         u16 template_id_2_4 = wl->scan_templ_id_2_4;
1095         u16 template_id_5 = wl->scan_templ_id_5;
1096
1097         skb = ieee80211_probereq_get(wl->hw, vif, ssid, ssid_len,
1098                                      ie_len);
1099         if (!skb) {
1100                 ret = -ENOMEM;
1101                 goto out;
1102         }
1103         if (ie_len)
1104                 memcpy(skb_put(skb, ie_len), ie, ie_len);
1105
1106         wl1271_dump(DEBUG_SCAN, "PROBE REQ: ", skb->data, skb->len);
1107
1108         if (sched_scan &&
1109             (wl->quirks & WLCORE_QUIRK_DUAL_PROBE_TMPL)) {
1110                 template_id_2_4 = wl->sched_scan_templ_id_2_4;
1111                 template_id_5 = wl->sched_scan_templ_id_5;
1112         }
1113
1114         rate = wl1271_tx_min_rate_get(wl, wlvif->bitrate_masks[band]);
1115         if (band == IEEE80211_BAND_2GHZ)
1116                 ret = wl1271_cmd_template_set(wl, role_id,
1117                                               template_id_2_4,
1118                                               skb->data, skb->len, 0, rate);
1119         else
1120                 ret = wl1271_cmd_template_set(wl, role_id,
1121                                               template_id_5,
1122                                               skb->data, skb->len, 0, rate);
1123
1124 out:
1125         dev_kfree_skb(skb);
1126         return ret;
1127 }
1128 EXPORT_SYMBOL_GPL(wl12xx_cmd_build_probe_req);
1129
1130 struct sk_buff *wl1271_cmd_build_ap_probe_req(struct wl1271 *wl,
1131                                               struct wl12xx_vif *wlvif,
1132                                               struct sk_buff *skb)
1133 {
1134         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
1135         int ret;
1136         u32 rate;
1137
1138         if (!skb)
1139                 skb = ieee80211_ap_probereq_get(wl->hw, vif);
1140         if (!skb)
1141                 goto out;
1142
1143         wl1271_dump(DEBUG_SCAN, "AP PROBE REQ: ", skb->data, skb->len);
1144
1145         rate = wl1271_tx_min_rate_get(wl, wlvif->bitrate_masks[wlvif->band]);
1146         if (wlvif->band == IEEE80211_BAND_2GHZ)
1147                 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
1148                                               CMD_TEMPL_CFG_PROBE_REQ_2_4,
1149                                               skb->data, skb->len, 0, rate);
1150         else
1151                 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
1152                                               CMD_TEMPL_CFG_PROBE_REQ_5,
1153                                               skb->data, skb->len, 0, rate);
1154
1155         if (ret < 0)
1156                 wl1271_error("Unable to set ap probe request template.");
1157
1158 out:
1159         return skb;
1160 }
1161
1162 int wl1271_cmd_build_arp_rsp(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1163 {
1164         int ret, extra = 0;
1165         u16 fc;
1166         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
1167         struct sk_buff *skb;
1168         struct wl12xx_arp_rsp_template *tmpl;
1169         struct ieee80211_hdr_3addr *hdr;
1170         struct arphdr *arp_hdr;
1171
1172         skb = dev_alloc_skb(sizeof(*hdr) + sizeof(__le16) + sizeof(*tmpl) +
1173                             WL1271_EXTRA_SPACE_MAX);
1174         if (!skb) {
1175                 wl1271_error("failed to allocate buffer for arp rsp template");
1176                 return -ENOMEM;
1177         }
1178
1179         skb_reserve(skb, sizeof(*hdr) + WL1271_EXTRA_SPACE_MAX);
1180
1181         tmpl = (struct wl12xx_arp_rsp_template *)skb_put(skb, sizeof(*tmpl));
1182         memset(tmpl, 0, sizeof(*tmpl));
1183
1184         /* llc layer */
1185         memcpy(tmpl->llc_hdr, rfc1042_header, sizeof(rfc1042_header));
1186         tmpl->llc_type = cpu_to_be16(ETH_P_ARP);
1187
1188         /* arp header */
1189         arp_hdr = &tmpl->arp_hdr;
1190         arp_hdr->ar_hrd = cpu_to_be16(ARPHRD_ETHER);
1191         arp_hdr->ar_pro = cpu_to_be16(ETH_P_IP);
1192         arp_hdr->ar_hln = ETH_ALEN;
1193         arp_hdr->ar_pln = 4;
1194         arp_hdr->ar_op = cpu_to_be16(ARPOP_REPLY);
1195
1196         /* arp payload */
1197         memcpy(tmpl->sender_hw, vif->addr, ETH_ALEN);
1198         tmpl->sender_ip = wlvif->ip_addr;
1199
1200         /* encryption space */
1201         switch (wlvif->encryption_type) {
1202         case KEY_TKIP:
1203                 if (wl->quirks & WLCORE_QUIRK_TKIP_HEADER_SPACE)
1204                         extra = WL1271_EXTRA_SPACE_TKIP;
1205                 break;
1206         case KEY_AES:
1207                 extra = WL1271_EXTRA_SPACE_AES;
1208                 break;
1209         case KEY_NONE:
1210         case KEY_WEP:
1211         case KEY_GEM:
1212                 extra = 0;
1213                 break;
1214         default:
1215                 wl1271_warning("Unknown encryption type: %d",
1216                                wlvif->encryption_type);
1217                 ret = -EINVAL;
1218                 goto out;
1219         }
1220
1221         if (extra) {
1222                 u8 *space = skb_push(skb, extra);
1223                 memset(space, 0, extra);
1224         }
1225
1226         /* QoS header - BE */
1227         if (wlvif->sta.qos)
1228                 memset(skb_push(skb, sizeof(__le16)), 0, sizeof(__le16));
1229
1230         /* mac80211 header */
1231         hdr = (struct ieee80211_hdr_3addr *)skb_push(skb, sizeof(*hdr));
1232         memset(hdr, 0, sizeof(*hdr));
1233         fc = IEEE80211_FTYPE_DATA | IEEE80211_FCTL_TODS;
1234         if (wlvif->sta.qos)
1235                 fc |= IEEE80211_STYPE_QOS_DATA;
1236         else
1237                 fc |= IEEE80211_STYPE_DATA;
1238         if (wlvif->encryption_type != KEY_NONE)
1239                 fc |= IEEE80211_FCTL_PROTECTED;
1240
1241         hdr->frame_control = cpu_to_le16(fc);
1242         memcpy(hdr->addr1, vif->bss_conf.bssid, ETH_ALEN);
1243         memcpy(hdr->addr2, vif->addr, ETH_ALEN);
1244         memset(hdr->addr3, 0xff, ETH_ALEN);
1245
1246         ret = wl1271_cmd_template_set(wl, wlvif->role_id, CMD_TEMPL_ARP_RSP,
1247                                       skb->data, skb->len, 0,
1248                                       wlvif->basic_rate);
1249 out:
1250         dev_kfree_skb(skb);
1251         return ret;
1252 }
1253
1254 int wl1271_build_qos_null_data(struct wl1271 *wl, struct ieee80211_vif *vif)
1255 {
1256         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
1257         struct ieee80211_qos_hdr template;
1258
1259         memset(&template, 0, sizeof(template));
1260
1261         memcpy(template.addr1, vif->bss_conf.bssid, ETH_ALEN);
1262         memcpy(template.addr2, vif->addr, ETH_ALEN);
1263         memcpy(template.addr3, vif->bss_conf.bssid, ETH_ALEN);
1264
1265         template.frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1266                                              IEEE80211_STYPE_QOS_NULLFUNC |
1267                                              IEEE80211_FCTL_TODS);
1268
1269         /* FIXME: not sure what priority to use here */
1270         template.qos_ctrl = cpu_to_le16(0);
1271
1272         return wl1271_cmd_template_set(wl, wlvif->role_id,
1273                                        CMD_TEMPL_QOS_NULL_DATA, &template,
1274                                        sizeof(template), 0,
1275                                        wlvif->basic_rate);
1276 }
1277
1278 int wl12xx_cmd_set_default_wep_key(struct wl1271 *wl, u8 id, u8 hlid)
1279 {
1280         struct wl1271_cmd_set_keys *cmd;
1281         int ret = 0;
1282
1283         wl1271_debug(DEBUG_CMD, "cmd set_default_wep_key %d", id);
1284
1285         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1286         if (!cmd) {
1287                 ret = -ENOMEM;
1288                 goto out;
1289         }
1290
1291         cmd->hlid = hlid;
1292         cmd->key_id = id;
1293         cmd->lid_key_type = WEP_DEFAULT_LID_TYPE;
1294         cmd->key_action = cpu_to_le16(KEY_SET_ID);
1295         cmd->key_type = KEY_WEP;
1296
1297         ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
1298         if (ret < 0) {
1299                 wl1271_warning("cmd set_default_wep_key failed: %d", ret);
1300                 goto out;
1301         }
1302
1303 out:
1304         kfree(cmd);
1305
1306         return ret;
1307 }
1308
1309 int wl1271_cmd_set_sta_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
1310                        u16 action, u8 id, u8 key_type,
1311                        u8 key_size, const u8 *key, const u8 *addr,
1312                        u32 tx_seq_32, u16 tx_seq_16)
1313 {
1314         struct wl1271_cmd_set_keys *cmd;
1315         int ret = 0;
1316
1317         /* hlid might have already been deleted */
1318         if (wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
1319                 return 0;
1320
1321         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1322         if (!cmd) {
1323                 ret = -ENOMEM;
1324                 goto out;
1325         }
1326
1327         cmd->hlid = wlvif->sta.hlid;
1328
1329         if (key_type == KEY_WEP)
1330                 cmd->lid_key_type = WEP_DEFAULT_LID_TYPE;
1331         else if (is_broadcast_ether_addr(addr))
1332                 cmd->lid_key_type = BROADCAST_LID_TYPE;
1333         else
1334                 cmd->lid_key_type = UNICAST_LID_TYPE;
1335
1336         cmd->key_action = cpu_to_le16(action);
1337         cmd->key_size = key_size;
1338         cmd->key_type = key_type;
1339
1340         cmd->ac_seq_num16[0] = cpu_to_le16(tx_seq_16);
1341         cmd->ac_seq_num32[0] = cpu_to_le32(tx_seq_32);
1342
1343         cmd->key_id = id;
1344
1345         if (key_type == KEY_TKIP) {
1346                 /*
1347                  * We get the key in the following form:
1348                  * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
1349                  * but the target is expecting:
1350                  * TKIP - RX MIC - TX MIC
1351                  */
1352                 memcpy(cmd->key, key, 16);
1353                 memcpy(cmd->key + 16, key + 24, 8);
1354                 memcpy(cmd->key + 24, key + 16, 8);
1355
1356         } else {
1357                 memcpy(cmd->key, key, key_size);
1358         }
1359
1360         wl1271_dump(DEBUG_CRYPT, "TARGET KEY: ", cmd, sizeof(*cmd));
1361
1362         ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
1363         if (ret < 0) {
1364                 wl1271_warning("could not set keys");
1365         goto out;
1366         }
1367
1368 out:
1369         kfree(cmd);
1370
1371         return ret;
1372 }
1373
1374 /*
1375  * TODO: merge with sta/ibss into 1 set_key function.
1376  * note there are slight diffs
1377  */
1378 int wl1271_cmd_set_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
1379                           u16 action, u8 id, u8 key_type,
1380                           u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
1381                           u16 tx_seq_16)
1382 {
1383         struct wl1271_cmd_set_keys *cmd;
1384         int ret = 0;
1385         u8 lid_type;
1386
1387         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1388         if (!cmd)
1389                 return -ENOMEM;
1390
1391         if (hlid == wlvif->ap.bcast_hlid) {
1392                 if (key_type == KEY_WEP)
1393                         lid_type = WEP_DEFAULT_LID_TYPE;
1394                 else
1395                         lid_type = BROADCAST_LID_TYPE;
1396         } else {
1397                 lid_type = UNICAST_LID_TYPE;
1398         }
1399
1400         wl1271_debug(DEBUG_CRYPT, "ap key action: %d id: %d lid: %d type: %d"
1401                      " hlid: %d", (int)action, (int)id, (int)lid_type,
1402                      (int)key_type, (int)hlid);
1403
1404         cmd->lid_key_type = lid_type;
1405         cmd->hlid = hlid;
1406         cmd->key_action = cpu_to_le16(action);
1407         cmd->key_size = key_size;
1408         cmd->key_type = key_type;
1409         cmd->key_id = id;
1410         cmd->ac_seq_num16[0] = cpu_to_le16(tx_seq_16);
1411         cmd->ac_seq_num32[0] = cpu_to_le32(tx_seq_32);
1412
1413         if (key_type == KEY_TKIP) {
1414                 /*
1415                  * We get the key in the following form:
1416                  * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
1417                  * but the target is expecting:
1418                  * TKIP - RX MIC - TX MIC
1419                  */
1420                 memcpy(cmd->key, key, 16);
1421                 memcpy(cmd->key + 16, key + 24, 8);
1422                 memcpy(cmd->key + 24, key + 16, 8);
1423         } else {
1424                 memcpy(cmd->key, key, key_size);
1425         }
1426
1427         wl1271_dump(DEBUG_CRYPT, "TARGET AP KEY: ", cmd, sizeof(*cmd));
1428
1429         ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
1430         if (ret < 0) {
1431                 wl1271_warning("could not set ap keys");
1432                 goto out;
1433         }
1434
1435 out:
1436         kfree(cmd);
1437         return ret;
1438 }
1439
1440 int wl12xx_cmd_set_peer_state(struct wl1271 *wl, struct wl12xx_vif *wlvif,
1441                               u8 hlid)
1442 {
1443         struct wl12xx_cmd_set_peer_state *cmd;
1444         int ret = 0;
1445
1446         wl1271_debug(DEBUG_CMD, "cmd set peer state (hlid=%d)", hlid);
1447
1448         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1449         if (!cmd) {
1450                 ret = -ENOMEM;
1451                 goto out;
1452         }
1453
1454         cmd->hlid = hlid;
1455         cmd->state = WL1271_CMD_STA_STATE_CONNECTED;
1456
1457         /* wmm param is valid only for station role */
1458         if (wlvif->bss_type == BSS_TYPE_STA_BSS)
1459                 cmd->wmm = wlvif->wmm_enabled;
1460
1461         ret = wl1271_cmd_send(wl, CMD_SET_PEER_STATE, cmd, sizeof(*cmd), 0);
1462         if (ret < 0) {
1463                 wl1271_error("failed to send set peer state command");
1464                 goto out_free;
1465         }
1466
1467 out_free:
1468         kfree(cmd);
1469
1470 out:
1471         return ret;
1472 }
1473
1474 int wl12xx_cmd_add_peer(struct wl1271 *wl, struct wl12xx_vif *wlvif,
1475                         struct ieee80211_sta *sta, u8 hlid)
1476 {
1477         struct wl12xx_cmd_add_peer *cmd;
1478         int i, ret;
1479         u32 sta_rates;
1480
1481         wl1271_debug(DEBUG_CMD, "cmd add peer %d", (int)hlid);
1482
1483         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1484         if (!cmd) {
1485                 ret = -ENOMEM;
1486                 goto out;
1487         }
1488
1489         memcpy(cmd->addr, sta->addr, ETH_ALEN);
1490         cmd->bss_index = WL1271_AP_BSS_INDEX;
1491         cmd->aid = sta->aid;
1492         cmd->hlid = hlid;
1493         cmd->sp_len = sta->max_sp;
1494         cmd->wmm = sta->wme ? 1 : 0;
1495         cmd->session_id = wl->session_ids[hlid];
1496
1497         for (i = 0; i < NUM_ACCESS_CATEGORIES_COPY; i++)
1498                 if (sta->wme && (sta->uapsd_queues & BIT(i)))
1499                         cmd->psd_type[NUM_ACCESS_CATEGORIES_COPY-1-i] =
1500                                         WL1271_PSD_UPSD_TRIGGER;
1501                 else
1502                         cmd->psd_type[NUM_ACCESS_CATEGORIES_COPY-1-i] =
1503                                         WL1271_PSD_LEGACY;
1504
1505
1506         sta_rates = sta->supp_rates[wlvif->band];
1507         if (sta->ht_cap.ht_supported)
1508                 sta_rates |=
1509                         (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET) |
1510                         (sta->ht_cap.mcs.rx_mask[1] << HW_MIMO_RATES_OFFSET);
1511
1512         cmd->supported_rates =
1513                 cpu_to_le32(wl1271_tx_enabled_rates_get(wl, sta_rates,
1514                                                         wlvif->band));
1515
1516         wl1271_debug(DEBUG_CMD, "new peer rates=0x%x queues=0x%x",
1517                      cmd->supported_rates, sta->uapsd_queues);
1518
1519         ret = wl1271_cmd_send(wl, CMD_ADD_PEER, cmd, sizeof(*cmd), 0);
1520         if (ret < 0) {
1521                 wl1271_error("failed to initiate cmd add peer");
1522                 goto out_free;
1523         }
1524
1525 out_free:
1526         kfree(cmd);
1527
1528 out:
1529         return ret;
1530 }
1531
1532 int wl12xx_cmd_remove_peer(struct wl1271 *wl, u8 hlid)
1533 {
1534         struct wl12xx_cmd_remove_peer *cmd;
1535         int ret;
1536         bool timeout = false;
1537
1538         wl1271_debug(DEBUG_CMD, "cmd remove peer %d", (int)hlid);
1539
1540         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1541         if (!cmd) {
1542                 ret = -ENOMEM;
1543                 goto out;
1544         }
1545
1546         cmd->hlid = hlid;
1547         /* We never send a deauth, mac80211 is in charge of this */
1548         cmd->reason_opcode = 0;
1549         cmd->send_deauth_flag = 0;
1550
1551         ret = wl1271_cmd_send(wl, CMD_REMOVE_PEER, cmd, sizeof(*cmd), 0);
1552         if (ret < 0) {
1553                 wl1271_error("failed to initiate cmd remove peer");
1554                 goto out_free;
1555         }
1556
1557         ret = wl->ops->wait_for_event(wl,
1558                                       WLCORE_EVENT_PEER_REMOVE_COMPLETE,
1559                                       &timeout);
1560
1561         /*
1562          * We are ok with a timeout here. The event is sometimes not sent
1563          * due to a firmware bug. In case of another error (like SDIO timeout)
1564          * queue a recovery.
1565          */
1566         if (ret)
1567                 wl12xx_queue_recovery_work(wl);
1568
1569 out_free:
1570         kfree(cmd);
1571
1572 out:
1573         return ret;
1574 }
1575
1576 static int wlcore_get_reg_conf_ch_idx(enum ieee80211_band band, u16 ch)
1577 {
1578         int idx = -1;
1579
1580         switch (band) {
1581         case IEEE80211_BAND_5GHZ:
1582                 if (ch >= 8 && ch <= 16)
1583                         idx = ((ch-8)/4 + 18);
1584                 else if (ch >= 34 && ch <= 64)
1585                         idx = ((ch-34)/2 + 3 + 18);
1586                 else if (ch >= 100 && ch <= 140)
1587                         idx = ((ch-100)/4 + 15 + 18);
1588                 else if (ch >= 149 && ch <= 165)
1589                         idx = ((ch-149)/4 + 26 + 18);
1590                 else
1591                         idx = -1;
1592                 break;
1593         case IEEE80211_BAND_2GHZ:
1594                 if (ch >= 1 && ch <= 14)
1595                         idx = ch - 1;
1596                 else
1597                         idx = -1;
1598                 break;
1599         default:
1600                 wl1271_error("get reg conf ch idx - unknown band: %d",
1601                              (int)band);
1602         }
1603
1604         return idx;
1605 }
1606
1607 void wlcore_set_pending_regdomain_ch(struct wl1271 *wl, u16 channel,
1608                                      enum ieee80211_band band)
1609 {
1610         int ch_bit_idx = 0;
1611
1612         if (!(wl->quirks & WLCORE_QUIRK_REGDOMAIN_CONF))
1613                 return;
1614
1615         ch_bit_idx = wlcore_get_reg_conf_ch_idx(band, channel);
1616
1617         if (ch_bit_idx > 0 && ch_bit_idx <= WL1271_MAX_CHANNELS)
1618                 set_bit(ch_bit_idx, (long *)wl->reg_ch_conf_pending);
1619 }
1620
1621 int wlcore_cmd_regdomain_config_locked(struct wl1271 *wl)
1622 {
1623         struct wl12xx_cmd_regdomain_dfs_config *cmd = NULL;
1624         int ret = 0, i, b, ch_bit_idx;
1625         struct ieee80211_channel *channel;
1626         u32 tmp_ch_bitmap[2];
1627         u16 ch;
1628         struct wiphy *wiphy = wl->hw->wiphy;
1629         struct ieee80211_supported_band *band;
1630         bool timeout = false;
1631
1632         if (!(wl->quirks & WLCORE_QUIRK_REGDOMAIN_CONF))
1633                 return 0;
1634
1635         wl1271_debug(DEBUG_CMD, "cmd reg domain config");
1636
1637         memset(tmp_ch_bitmap, 0, sizeof(tmp_ch_bitmap));
1638
1639         for (b = IEEE80211_BAND_2GHZ; b <= IEEE80211_BAND_5GHZ; b++) {
1640                 band = wiphy->bands[b];
1641                 for (i = 0; i < band->n_channels; i++) {
1642                         channel = &band->channels[i];
1643                         ch = channel->hw_value;
1644
1645                         if (channel->flags & (IEEE80211_CHAN_DISABLED |
1646                                               IEEE80211_CHAN_RADAR |
1647                                               IEEE80211_CHAN_PASSIVE_SCAN))
1648                                 continue;
1649
1650                         ch_bit_idx = wlcore_get_reg_conf_ch_idx(b, ch);
1651                         if (ch_bit_idx < 0)
1652                                 continue;
1653
1654                         set_bit(ch_bit_idx, (long *)tmp_ch_bitmap);
1655                 }
1656         }
1657
1658         tmp_ch_bitmap[0] |= wl->reg_ch_conf_pending[0];
1659         tmp_ch_bitmap[1] |= wl->reg_ch_conf_pending[1];
1660
1661         if (!memcmp(tmp_ch_bitmap, wl->reg_ch_conf_last, sizeof(tmp_ch_bitmap)))
1662                 goto out;
1663
1664         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1665         if (!cmd) {
1666                 ret = -ENOMEM;
1667                 goto out;
1668         }
1669
1670         cmd->ch_bit_map1 = cpu_to_le32(tmp_ch_bitmap[0]);
1671         cmd->ch_bit_map2 = cpu_to_le32(tmp_ch_bitmap[1]);
1672
1673         wl1271_debug(DEBUG_CMD,
1674                      "cmd reg domain bitmap1: 0x%08x, bitmap2: 0x%08x",
1675                      cmd->ch_bit_map1, cmd->ch_bit_map2);
1676
1677         ret = wl1271_cmd_send(wl, CMD_DFS_CHANNEL_CONFIG, cmd, sizeof(*cmd), 0);
1678         if (ret < 0) {
1679                 wl1271_error("failed to send reg domain dfs config");
1680                 goto out;
1681         }
1682
1683         ret = wl->ops->wait_for_event(wl,
1684                                       WLCORE_EVENT_DFS_CONFIG_COMPLETE,
1685                                       &timeout);
1686         if (ret < 0 || timeout) {
1687                 wl1271_error("reg domain conf %serror",
1688                              timeout ? "completion " : "");
1689                 ret = timeout ? -ETIMEDOUT : ret;
1690                 goto out;
1691         }
1692
1693         memcpy(wl->reg_ch_conf_last, tmp_ch_bitmap, sizeof(tmp_ch_bitmap));
1694         memset(wl->reg_ch_conf_pending, 0, sizeof(wl->reg_ch_conf_pending));
1695
1696 out:
1697         kfree(cmd);
1698         return ret;
1699 }
1700
1701 int wl12xx_cmd_config_fwlog(struct wl1271 *wl)
1702 {
1703         struct wl12xx_cmd_config_fwlog *cmd;
1704         int ret = 0;
1705
1706         wl1271_debug(DEBUG_CMD, "cmd config firmware logger");
1707
1708         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1709         if (!cmd) {
1710                 ret = -ENOMEM;
1711                 goto out;
1712         }
1713
1714         cmd->logger_mode = wl->conf.fwlog.mode;
1715         cmd->log_severity = wl->conf.fwlog.severity;
1716         cmd->timestamp = wl->conf.fwlog.timestamp;
1717         cmd->output = wl->conf.fwlog.output;
1718         cmd->threshold = wl->conf.fwlog.threshold;
1719
1720         ret = wl1271_cmd_send(wl, CMD_CONFIG_FWLOGGER, cmd, sizeof(*cmd), 0);
1721         if (ret < 0) {
1722                 wl1271_error("failed to send config firmware logger command");
1723                 goto out_free;
1724         }
1725
1726 out_free:
1727         kfree(cmd);
1728
1729 out:
1730         return ret;
1731 }
1732
1733 int wl12xx_cmd_start_fwlog(struct wl1271 *wl)
1734 {
1735         struct wl12xx_cmd_start_fwlog *cmd;
1736         int ret = 0;
1737
1738         wl1271_debug(DEBUG_CMD, "cmd start firmware logger");
1739
1740         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1741         if (!cmd) {
1742                 ret = -ENOMEM;
1743                 goto out;
1744         }
1745
1746         ret = wl1271_cmd_send(wl, CMD_START_FWLOGGER, cmd, sizeof(*cmd), 0);
1747         if (ret < 0) {
1748                 wl1271_error("failed to send start firmware logger command");
1749                 goto out_free;
1750         }
1751
1752 out_free:
1753         kfree(cmd);
1754
1755 out:
1756         return ret;
1757 }
1758
1759 int wl12xx_cmd_stop_fwlog(struct wl1271 *wl)
1760 {
1761         struct wl12xx_cmd_stop_fwlog *cmd;
1762         int ret = 0;
1763
1764         wl1271_debug(DEBUG_CMD, "cmd stop firmware logger");
1765
1766         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1767         if (!cmd) {
1768                 ret = -ENOMEM;
1769                 goto out;
1770         }
1771
1772         ret = wl1271_cmd_send(wl, CMD_STOP_FWLOGGER, cmd, sizeof(*cmd), 0);
1773         if (ret < 0) {
1774                 wl1271_error("failed to send stop firmware logger command");
1775                 goto out_free;
1776         }
1777
1778 out_free:
1779         kfree(cmd);
1780
1781 out:
1782         return ret;
1783 }
1784
1785 static int wl12xx_cmd_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
1786                           u8 role_id, enum ieee80211_band band, u8 channel)
1787 {
1788         struct wl12xx_cmd_roc *cmd;
1789         int ret = 0;
1790
1791         wl1271_debug(DEBUG_CMD, "cmd roc %d (%d)", channel, role_id);
1792
1793         if (WARN_ON(role_id == WL12XX_INVALID_ROLE_ID))
1794                 return -EINVAL;
1795
1796         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1797         if (!cmd) {
1798                 ret = -ENOMEM;
1799                 goto out;
1800         }
1801
1802         cmd->role_id = role_id;
1803         cmd->channel = channel;
1804         switch (band) {
1805         case IEEE80211_BAND_2GHZ:
1806                 cmd->band = WLCORE_BAND_2_4GHZ;
1807                 break;
1808         case IEEE80211_BAND_5GHZ:
1809                 cmd->band = WLCORE_BAND_5GHZ;
1810                 break;
1811         default:
1812                 wl1271_error("roc - unknown band: %d", (int)wlvif->band);
1813                 ret = -EINVAL;
1814                 goto out_free;
1815         }
1816
1817
1818         ret = wl1271_cmd_send(wl, CMD_REMAIN_ON_CHANNEL, cmd, sizeof(*cmd), 0);
1819         if (ret < 0) {
1820                 wl1271_error("failed to send ROC command");
1821                 goto out_free;
1822         }
1823
1824 out_free:
1825         kfree(cmd);
1826
1827 out:
1828         return ret;
1829 }
1830
1831 static int wl12xx_cmd_croc(struct wl1271 *wl, u8 role_id)
1832 {
1833         struct wl12xx_cmd_croc *cmd;
1834         int ret = 0;
1835
1836         wl1271_debug(DEBUG_CMD, "cmd croc (%d)", role_id);
1837
1838         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1839         if (!cmd) {
1840                 ret = -ENOMEM;
1841                 goto out;
1842         }
1843         cmd->role_id = role_id;
1844
1845         ret = wl1271_cmd_send(wl, CMD_CANCEL_REMAIN_ON_CHANNEL, cmd,
1846                               sizeof(*cmd), 0);
1847         if (ret < 0) {
1848                 wl1271_error("failed to send ROC command");
1849                 goto out_free;
1850         }
1851
1852 out_free:
1853         kfree(cmd);
1854
1855 out:
1856         return ret;
1857 }
1858
1859 int wl12xx_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 role_id,
1860                enum ieee80211_band band, u8 channel)
1861 {
1862         int ret = 0;
1863
1864         if (WARN_ON(test_bit(role_id, wl->roc_map)))
1865                 return 0;
1866
1867         ret = wl12xx_cmd_roc(wl, wlvif, role_id, band, channel);
1868         if (ret < 0)
1869                 goto out;
1870
1871         __set_bit(role_id, wl->roc_map);
1872 out:
1873         return ret;
1874 }
1875
1876 int wl12xx_croc(struct wl1271 *wl, u8 role_id)
1877 {
1878         int ret = 0;
1879
1880         if (WARN_ON(!test_bit(role_id, wl->roc_map)))
1881                 return 0;
1882
1883         ret = wl12xx_cmd_croc(wl, role_id);
1884         if (ret < 0)
1885                 goto out;
1886
1887         __clear_bit(role_id, wl->roc_map);
1888
1889         /*
1890          * Rearm the tx watchdog when removing the last ROC. This prevents
1891          * recoveries due to just finished ROCs - when Tx hasn't yet had
1892          * a chance to get out.
1893          */
1894         if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) >= WL12XX_MAX_ROLES)
1895                 wl12xx_rearm_tx_watchdog_locked(wl);
1896 out:
1897         return ret;
1898 }
1899
1900 int wl12xx_cmd_stop_channel_switch(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1901 {
1902         struct wl12xx_cmd_stop_channel_switch *cmd;
1903         int ret;
1904
1905         wl1271_debug(DEBUG_ACX, "cmd stop channel switch");
1906
1907         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1908         if (!cmd) {
1909                 ret = -ENOMEM;
1910                 goto out;
1911         }
1912
1913         cmd->role_id = wlvif->role_id;
1914
1915         ret = wl1271_cmd_send(wl, CMD_STOP_CHANNEL_SWICTH, cmd, sizeof(*cmd), 0);
1916         if (ret < 0) {
1917                 wl1271_error("failed to stop channel switch command");
1918                 goto out_free;
1919         }
1920
1921 out_free:
1922         kfree(cmd);
1923
1924 out:
1925         return ret;
1926 }
1927
1928 /* start dev role and roc on its channel */
1929 int wl12xx_start_dev(struct wl1271 *wl, struct wl12xx_vif *wlvif,
1930                      enum ieee80211_band band, int channel)
1931 {
1932         int ret;
1933
1934         if (WARN_ON(!(wlvif->bss_type == BSS_TYPE_STA_BSS ||
1935                       wlvif->bss_type == BSS_TYPE_IBSS)))
1936                 return -EINVAL;
1937
1938         ret = wl12xx_cmd_role_enable(wl,
1939                                      wl12xx_wlvif_to_vif(wlvif)->addr,
1940                                      WL1271_ROLE_DEVICE,
1941                                      &wlvif->dev_role_id);
1942         if (ret < 0)
1943                 goto out;
1944
1945         ret = wl12xx_cmd_role_start_dev(wl, wlvif, band, channel);
1946         if (ret < 0)
1947                 goto out_disable;
1948
1949         ret = wl12xx_roc(wl, wlvif, wlvif->dev_role_id, band, channel);
1950         if (ret < 0)
1951                 goto out_stop;
1952
1953         return 0;
1954
1955 out_stop:
1956         wl12xx_cmd_role_stop_dev(wl, wlvif);
1957 out_disable:
1958         wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
1959 out:
1960         return ret;
1961 }
1962
1963 /* croc dev hlid, and stop the role */
1964 int wl12xx_stop_dev(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1965 {
1966         int ret;
1967
1968         if (WARN_ON(!(wlvif->bss_type == BSS_TYPE_STA_BSS ||
1969                       wlvif->bss_type == BSS_TYPE_IBSS)))
1970                 return -EINVAL;
1971
1972         /* flush all pending packets */
1973         ret = wlcore_tx_work_locked(wl);
1974         if (ret < 0)
1975                 goto out;
1976
1977         if (test_bit(wlvif->dev_role_id, wl->roc_map)) {
1978                 ret = wl12xx_croc(wl, wlvif->dev_role_id);
1979                 if (ret < 0)
1980                         goto out;
1981         }
1982
1983         ret = wl12xx_cmd_role_stop_dev(wl, wlvif);
1984         if (ret < 0)
1985                 goto out;
1986
1987         ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
1988         if (ret < 0)
1989                 goto out;
1990
1991 out:
1992         return ret;
1993 }