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