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