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