1 /* 2 * This file is part of wl1271 3 * 4 * Copyright (C) 2008-2009 Nokia Corporation 5 * 6 * Contact: Luciano Coelho <luciano.coelho@nokia.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * version 2 as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 20 * 02110-1301 USA 21 * 22 */ 23 24 #include "acx.h" 25 26 #include <linux/module.h> 27 #include <linux/platform_device.h> 28 #include <linux/spi/spi.h> 29 #include <linux/slab.h> 30 31 #include "wlcore.h" 32 #include "debug.h" 33 #include "wl12xx_80211.h" 34 #include "ps.h" 35 #include "hw_ops.h" 36 37 int wl1271_acx_wake_up_conditions(struct wl1271 *wl, struct wl12xx_vif *wlvif, 38 u8 wake_up_event, u8 listen_interval) 39 { 40 struct acx_wake_up_condition *wake_up; 41 int ret; 42 43 wl1271_debug(DEBUG_ACX, "acx wake up conditions (wake_up_event %d listen_interval %d)", 44 wake_up_event, listen_interval); 45 46 wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL); 47 if (!wake_up) { 48 ret = -ENOMEM; 49 goto out; 50 } 51 52 wake_up->role_id = wlvif->role_id; 53 wake_up->wake_up_event = wake_up_event; 54 wake_up->listen_interval = listen_interval; 55 56 ret = wl1271_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS, 57 wake_up, sizeof(*wake_up)); 58 if (ret < 0) { 59 wl1271_warning("could not set wake up conditions: %d", ret); 60 goto out; 61 } 62 63 out: 64 kfree(wake_up); 65 return ret; 66 } 67 68 int wl1271_acx_sleep_auth(struct wl1271 *wl, u8 sleep_auth) 69 { 70 struct acx_sleep_auth *auth; 71 int ret; 72 73 wl1271_debug(DEBUG_ACX, "acx sleep auth %d", sleep_auth); 74 75 auth = kzalloc(sizeof(*auth), GFP_KERNEL); 76 if (!auth) { 77 ret = -ENOMEM; 78 goto out; 79 } 80 81 auth->sleep_auth = sleep_auth; 82 83 ret = wl1271_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth)); 84 if (ret < 0) { 85 wl1271_error("could not configure sleep_auth to %d: %d", 86 sleep_auth, ret); 87 goto out; 88 } 89 90 wl->sleep_auth = sleep_auth; 91 out: 92 kfree(auth); 93 return ret; 94 } 95 EXPORT_SYMBOL_GPL(wl1271_acx_sleep_auth); 96 97 int wl1271_acx_tx_power(struct wl1271 *wl, struct wl12xx_vif *wlvif, 98 int power) 99 { 100 struct acx_current_tx_power *acx; 101 int ret; 102 103 wl1271_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr %d", power); 104 105 if (power < 0 || power > 25) 106 return -EINVAL; 107 108 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 109 if (!acx) { 110 ret = -ENOMEM; 111 goto out; 112 } 113 114 acx->role_id = wlvif->role_id; 115 acx->current_tx_power = power * 10; 116 117 ret = wl1271_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx)); 118 if (ret < 0) { 119 wl1271_warning("configure of tx power failed: %d", ret); 120 goto out; 121 } 122 123 out: 124 kfree(acx); 125 return ret; 126 } 127 128 int wl1271_acx_feature_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif) 129 { 130 struct acx_feature_config *feature; 131 int ret; 132 133 wl1271_debug(DEBUG_ACX, "acx feature cfg"); 134 135 feature = kzalloc(sizeof(*feature), GFP_KERNEL); 136 if (!feature) { 137 ret = -ENOMEM; 138 goto out; 139 } 140 141 /* DF_ENCRYPTION_DISABLE and DF_SNIFF_MODE_ENABLE are disabled */ 142 feature->role_id = wlvif->role_id; 143 feature->data_flow_options = 0; 144 feature->options = 0; 145 146 ret = wl1271_cmd_configure(wl, ACX_FEATURE_CFG, 147 feature, sizeof(*feature)); 148 if (ret < 0) { 149 wl1271_error("Couldnt set HW encryption"); 150 goto out; 151 } 152 153 out: 154 kfree(feature); 155 return ret; 156 } 157 158 int wl1271_acx_mem_map(struct wl1271 *wl, struct acx_header *mem_map, 159 size_t len) 160 { 161 int ret; 162 163 wl1271_debug(DEBUG_ACX, "acx mem map"); 164 165 ret = wl1271_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, 166 sizeof(struct acx_header), len); 167 if (ret < 0) 168 return ret; 169 170 return 0; 171 } 172 173 int wl1271_acx_rx_msdu_life_time(struct wl1271 *wl) 174 { 175 struct acx_rx_msdu_lifetime *acx; 176 int ret; 177 178 wl1271_debug(DEBUG_ACX, "acx rx msdu life time"); 179 180 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 181 if (!acx) { 182 ret = -ENOMEM; 183 goto out; 184 } 185 186 acx->lifetime = cpu_to_le32(wl->conf.rx.rx_msdu_life_time); 187 ret = wl1271_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME, 188 acx, sizeof(*acx)); 189 if (ret < 0) { 190 wl1271_warning("failed to set rx msdu life time: %d", ret); 191 goto out; 192 } 193 194 out: 195 kfree(acx); 196 return ret; 197 } 198 199 int wl1271_acx_slot(struct wl1271 *wl, struct wl12xx_vif *wlvif, 200 enum acx_slot_type slot_time) 201 { 202 struct acx_slot *slot; 203 int ret; 204 205 wl1271_debug(DEBUG_ACX, "acx slot"); 206 207 slot = kzalloc(sizeof(*slot), GFP_KERNEL); 208 if (!slot) { 209 ret = -ENOMEM; 210 goto out; 211 } 212 213 slot->role_id = wlvif->role_id; 214 slot->wone_index = STATION_WONE_INDEX; 215 slot->slot_time = slot_time; 216 217 ret = wl1271_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot)); 218 if (ret < 0) { 219 wl1271_warning("failed to set slot time: %d", ret); 220 goto out; 221 } 222 223 out: 224 kfree(slot); 225 return ret; 226 } 227 228 int wl1271_acx_group_address_tbl(struct wl1271 *wl, struct wl12xx_vif *wlvif, 229 bool enable, void *mc_list, u32 mc_list_len) 230 { 231 struct acx_dot11_grp_addr_tbl *acx; 232 int ret; 233 234 wl1271_debug(DEBUG_ACX, "acx group address tbl"); 235 236 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 237 if (!acx) { 238 ret = -ENOMEM; 239 goto out; 240 } 241 242 /* MAC filtering */ 243 acx->role_id = wlvif->role_id; 244 acx->enabled = enable; 245 acx->num_groups = mc_list_len; 246 memcpy(acx->mac_table, mc_list, mc_list_len * ETH_ALEN); 247 248 ret = wl1271_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL, 249 acx, sizeof(*acx)); 250 if (ret < 0) { 251 wl1271_warning("failed to set group addr table: %d", ret); 252 goto out; 253 } 254 255 out: 256 kfree(acx); 257 return ret; 258 } 259 260 int wl1271_acx_service_period_timeout(struct wl1271 *wl, 261 struct wl12xx_vif *wlvif) 262 { 263 struct acx_rx_timeout *rx_timeout; 264 int ret; 265 266 rx_timeout = kzalloc(sizeof(*rx_timeout), GFP_KERNEL); 267 if (!rx_timeout) { 268 ret = -ENOMEM; 269 goto out; 270 } 271 272 wl1271_debug(DEBUG_ACX, "acx service period timeout"); 273 274 rx_timeout->role_id = wlvif->role_id; 275 rx_timeout->ps_poll_timeout = cpu_to_le16(wl->conf.rx.ps_poll_timeout); 276 rx_timeout->upsd_timeout = cpu_to_le16(wl->conf.rx.upsd_timeout); 277 278 ret = wl1271_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT, 279 rx_timeout, sizeof(*rx_timeout)); 280 if (ret < 0) { 281 wl1271_warning("failed to set service period timeout: %d", 282 ret); 283 goto out; 284 } 285 286 out: 287 kfree(rx_timeout); 288 return ret; 289 } 290 291 int wl1271_acx_rts_threshold(struct wl1271 *wl, struct wl12xx_vif *wlvif, 292 u32 rts_threshold) 293 { 294 struct acx_rts_threshold *rts; 295 int ret; 296 297 /* 298 * If the RTS threshold is not configured or out of range, use the 299 * default value. 300 */ 301 if (rts_threshold > IEEE80211_MAX_RTS_THRESHOLD) 302 rts_threshold = wl->conf.rx.rts_threshold; 303 304 wl1271_debug(DEBUG_ACX, "acx rts threshold: %d", rts_threshold); 305 306 rts = kzalloc(sizeof(*rts), GFP_KERNEL); 307 if (!rts) { 308 ret = -ENOMEM; 309 goto out; 310 } 311 312 rts->role_id = wlvif->role_id; 313 rts->threshold = cpu_to_le16((u16)rts_threshold); 314 315 ret = wl1271_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts)); 316 if (ret < 0) { 317 wl1271_warning("failed to set rts threshold: %d", ret); 318 goto out; 319 } 320 321 out: 322 kfree(rts); 323 return ret; 324 } 325 326 int wl1271_acx_dco_itrim_params(struct wl1271 *wl) 327 { 328 struct acx_dco_itrim_params *dco; 329 struct conf_itrim_settings *c = &wl->conf.itrim; 330 int ret; 331 332 wl1271_debug(DEBUG_ACX, "acx dco itrim parameters"); 333 334 dco = kzalloc(sizeof(*dco), GFP_KERNEL); 335 if (!dco) { 336 ret = -ENOMEM; 337 goto out; 338 } 339 340 dco->enable = c->enable; 341 dco->timeout = cpu_to_le32(c->timeout); 342 343 ret = wl1271_cmd_configure(wl, ACX_SET_DCO_ITRIM_PARAMS, 344 dco, sizeof(*dco)); 345 if (ret < 0) { 346 wl1271_warning("failed to set dco itrim parameters: %d", ret); 347 goto out; 348 } 349 350 out: 351 kfree(dco); 352 return ret; 353 } 354 355 int wl1271_acx_beacon_filter_opt(struct wl1271 *wl, struct wl12xx_vif *wlvif, 356 bool enable_filter) 357 { 358 struct acx_beacon_filter_option *beacon_filter = NULL; 359 int ret = 0; 360 361 wl1271_debug(DEBUG_ACX, "acx beacon filter opt enable=%d", 362 enable_filter); 363 364 if (enable_filter && 365 wl->conf.conn.bcn_filt_mode == CONF_BCN_FILT_MODE_DISABLED) 366 goto out; 367 368 beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL); 369 if (!beacon_filter) { 370 ret = -ENOMEM; 371 goto out; 372 } 373 374 beacon_filter->role_id = wlvif->role_id; 375 beacon_filter->enable = enable_filter; 376 377 /* 378 * When set to zero, and the filter is enabled, beacons 379 * without the unicast TIM bit set are dropped. 380 */ 381 beacon_filter->max_num_beacons = 0; 382 383 ret = wl1271_cmd_configure(wl, ACX_BEACON_FILTER_OPT, 384 beacon_filter, sizeof(*beacon_filter)); 385 if (ret < 0) { 386 wl1271_warning("failed to set beacon filter opt: %d", ret); 387 goto out; 388 } 389 390 out: 391 kfree(beacon_filter); 392 return ret; 393 } 394 395 int wl1271_acx_beacon_filter_table(struct wl1271 *wl, 396 struct wl12xx_vif *wlvif) 397 { 398 struct acx_beacon_filter_ie_table *ie_table; 399 int i, idx = 0; 400 int ret; 401 bool vendor_spec = false; 402 403 wl1271_debug(DEBUG_ACX, "acx beacon filter table"); 404 405 ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL); 406 if (!ie_table) { 407 ret = -ENOMEM; 408 goto out; 409 } 410 411 /* configure default beacon pass-through rules */ 412 ie_table->role_id = wlvif->role_id; 413 ie_table->num_ie = 0; 414 for (i = 0; i < wl->conf.conn.bcn_filt_ie_count; i++) { 415 struct conf_bcn_filt_rule *r = &(wl->conf.conn.bcn_filt_ie[i]); 416 ie_table->table[idx++] = r->ie; 417 ie_table->table[idx++] = r->rule; 418 419 if (r->ie == WLAN_EID_VENDOR_SPECIFIC) { 420 /* only one vendor specific ie allowed */ 421 if (vendor_spec) 422 continue; 423 424 /* for vendor specific rules configure the 425 additional fields */ 426 memcpy(&(ie_table->table[idx]), r->oui, 427 CONF_BCN_IE_OUI_LEN); 428 idx += CONF_BCN_IE_OUI_LEN; 429 ie_table->table[idx++] = r->type; 430 memcpy(&(ie_table->table[idx]), r->version, 431 CONF_BCN_IE_VER_LEN); 432 idx += CONF_BCN_IE_VER_LEN; 433 vendor_spec = true; 434 } 435 436 ie_table->num_ie++; 437 } 438 439 ret = wl1271_cmd_configure(wl, ACX_BEACON_FILTER_TABLE, 440 ie_table, sizeof(*ie_table)); 441 if (ret < 0) { 442 wl1271_warning("failed to set beacon filter table: %d", ret); 443 goto out; 444 } 445 446 out: 447 kfree(ie_table); 448 return ret; 449 } 450 451 #define ACX_CONN_MONIT_DISABLE_VALUE 0xffffffff 452 453 int wl1271_acx_conn_monit_params(struct wl1271 *wl, struct wl12xx_vif *wlvif, 454 bool enable) 455 { 456 struct acx_conn_monit_params *acx; 457 u32 threshold = ACX_CONN_MONIT_DISABLE_VALUE; 458 u32 timeout = ACX_CONN_MONIT_DISABLE_VALUE; 459 int ret; 460 461 wl1271_debug(DEBUG_ACX, "acx connection monitor parameters: %s", 462 enable ? "enabled" : "disabled"); 463 464 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 465 if (!acx) { 466 ret = -ENOMEM; 467 goto out; 468 } 469 470 if (enable) { 471 threshold = wl->conf.conn.synch_fail_thold; 472 timeout = wl->conf.conn.bss_lose_timeout; 473 } 474 475 acx->role_id = wlvif->role_id; 476 acx->synch_fail_thold = cpu_to_le32(threshold); 477 acx->bss_lose_timeout = cpu_to_le32(timeout); 478 479 ret = wl1271_cmd_configure(wl, ACX_CONN_MONIT_PARAMS, 480 acx, sizeof(*acx)); 481 if (ret < 0) { 482 wl1271_warning("failed to set connection monitor " 483 "parameters: %d", ret); 484 goto out; 485 } 486 487 out: 488 kfree(acx); 489 return ret; 490 } 491 492 493 int wl1271_acx_sg_enable(struct wl1271 *wl, bool enable) 494 { 495 struct acx_bt_wlan_coex *pta; 496 int ret; 497 498 wl1271_debug(DEBUG_ACX, "acx sg enable"); 499 500 pta = kzalloc(sizeof(*pta), GFP_KERNEL); 501 if (!pta) { 502 ret = -ENOMEM; 503 goto out; 504 } 505 506 if (enable) 507 pta->enable = wl->conf.sg.state; 508 else 509 pta->enable = CONF_SG_DISABLE; 510 511 ret = wl1271_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta)); 512 if (ret < 0) { 513 wl1271_warning("failed to set softgemini enable: %d", ret); 514 goto out; 515 } 516 517 out: 518 kfree(pta); 519 return ret; 520 } 521 522 int wl12xx_acx_sg_cfg(struct wl1271 *wl) 523 { 524 struct acx_bt_wlan_coex_param *param; 525 struct conf_sg_settings *c = &wl->conf.sg; 526 int i, ret; 527 528 wl1271_debug(DEBUG_ACX, "acx sg cfg"); 529 530 param = kzalloc(sizeof(*param), GFP_KERNEL); 531 if (!param) { 532 ret = -ENOMEM; 533 goto out; 534 } 535 536 /* BT-WLAN coext parameters */ 537 for (i = 0; i < CONF_SG_PARAMS_MAX; i++) 538 param->params[i] = cpu_to_le32(c->params[i]); 539 param->param_idx = CONF_SG_PARAMS_ALL; 540 541 ret = wl1271_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param)); 542 if (ret < 0) { 543 wl1271_warning("failed to set sg config: %d", ret); 544 goto out; 545 } 546 547 out: 548 kfree(param); 549 return ret; 550 } 551 552 int wl1271_acx_cca_threshold(struct wl1271 *wl) 553 { 554 struct acx_energy_detection *detection; 555 int ret; 556 557 wl1271_debug(DEBUG_ACX, "acx cca threshold"); 558 559 detection = kzalloc(sizeof(*detection), GFP_KERNEL); 560 if (!detection) { 561 ret = -ENOMEM; 562 goto out; 563 } 564 565 detection->rx_cca_threshold = cpu_to_le16(wl->conf.rx.rx_cca_threshold); 566 detection->tx_energy_detection = wl->conf.tx.tx_energy_detection; 567 568 ret = wl1271_cmd_configure(wl, ACX_CCA_THRESHOLD, 569 detection, sizeof(*detection)); 570 if (ret < 0) 571 wl1271_warning("failed to set cca threshold: %d", ret); 572 573 out: 574 kfree(detection); 575 return ret; 576 } 577 578 int wl1271_acx_bcn_dtim_options(struct wl1271 *wl, struct wl12xx_vif *wlvif) 579 { 580 struct acx_beacon_broadcast *bb; 581 int ret; 582 583 wl1271_debug(DEBUG_ACX, "acx bcn dtim options"); 584 585 bb = kzalloc(sizeof(*bb), GFP_KERNEL); 586 if (!bb) { 587 ret = -ENOMEM; 588 goto out; 589 } 590 591 bb->role_id = wlvif->role_id; 592 bb->beacon_rx_timeout = cpu_to_le16(wl->conf.conn.beacon_rx_timeout); 593 bb->broadcast_timeout = cpu_to_le16(wl->conf.conn.broadcast_timeout); 594 bb->rx_broadcast_in_ps = wl->conf.conn.rx_broadcast_in_ps; 595 bb->ps_poll_threshold = wl->conf.conn.ps_poll_threshold; 596 597 ret = wl1271_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb)); 598 if (ret < 0) { 599 wl1271_warning("failed to set rx config: %d", ret); 600 goto out; 601 } 602 603 out: 604 kfree(bb); 605 return ret; 606 } 607 608 int wl1271_acx_aid(struct wl1271 *wl, struct wl12xx_vif *wlvif, u16 aid) 609 { 610 struct acx_aid *acx_aid; 611 int ret; 612 613 wl1271_debug(DEBUG_ACX, "acx aid"); 614 615 acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL); 616 if (!acx_aid) { 617 ret = -ENOMEM; 618 goto out; 619 } 620 621 acx_aid->role_id = wlvif->role_id; 622 acx_aid->aid = cpu_to_le16(aid); 623 624 ret = wl1271_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid)); 625 if (ret < 0) { 626 wl1271_warning("failed to set aid: %d", ret); 627 goto out; 628 } 629 630 out: 631 kfree(acx_aid); 632 return ret; 633 } 634 635 int wl1271_acx_event_mbox_mask(struct wl1271 *wl, u32 event_mask) 636 { 637 struct acx_event_mask *mask; 638 int ret; 639 640 wl1271_debug(DEBUG_ACX, "acx event mbox mask"); 641 642 mask = kzalloc(sizeof(*mask), GFP_KERNEL); 643 if (!mask) { 644 ret = -ENOMEM; 645 goto out; 646 } 647 648 /* high event mask is unused */ 649 mask->high_event_mask = cpu_to_le32(0xffffffff); 650 mask->event_mask = cpu_to_le32(event_mask); 651 652 ret = wl1271_cmd_configure(wl, ACX_EVENT_MBOX_MASK, 653 mask, sizeof(*mask)); 654 if (ret < 0) { 655 wl1271_warning("failed to set acx_event_mbox_mask: %d", ret); 656 goto out; 657 } 658 659 out: 660 kfree(mask); 661 return ret; 662 } 663 664 int wl1271_acx_set_preamble(struct wl1271 *wl, struct wl12xx_vif *wlvif, 665 enum acx_preamble_type preamble) 666 { 667 struct acx_preamble *acx; 668 int ret; 669 670 wl1271_debug(DEBUG_ACX, "acx_set_preamble"); 671 672 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 673 if (!acx) { 674 ret = -ENOMEM; 675 goto out; 676 } 677 678 acx->role_id = wlvif->role_id; 679 acx->preamble = preamble; 680 681 ret = wl1271_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx)); 682 if (ret < 0) { 683 wl1271_warning("Setting of preamble failed: %d", ret); 684 goto out; 685 } 686 687 out: 688 kfree(acx); 689 return ret; 690 } 691 692 int wl1271_acx_cts_protect(struct wl1271 *wl, struct wl12xx_vif *wlvif, 693 enum acx_ctsprotect_type ctsprotect) 694 { 695 struct acx_ctsprotect *acx; 696 int ret; 697 698 wl1271_debug(DEBUG_ACX, "acx_set_ctsprotect"); 699 700 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 701 if (!acx) { 702 ret = -ENOMEM; 703 goto out; 704 } 705 706 acx->role_id = wlvif->role_id; 707 acx->ctsprotect = ctsprotect; 708 709 ret = wl1271_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx)); 710 if (ret < 0) { 711 wl1271_warning("Setting of ctsprotect failed: %d", ret); 712 goto out; 713 } 714 715 out: 716 kfree(acx); 717 return ret; 718 } 719 720 int wl1271_acx_statistics(struct wl1271 *wl, void *stats) 721 { 722 int ret; 723 724 wl1271_debug(DEBUG_ACX, "acx statistics"); 725 726 ret = wl1271_cmd_interrogate(wl, ACX_STATISTICS, stats, 727 sizeof(struct acx_header), 728 wl->stats.fw_stats_len); 729 if (ret < 0) { 730 wl1271_warning("acx statistics failed: %d", ret); 731 return -ENOMEM; 732 } 733 734 return 0; 735 } 736 737 int wl1271_acx_sta_rate_policies(struct wl1271 *wl, struct wl12xx_vif *wlvif) 738 { 739 struct acx_rate_policy *acx; 740 struct conf_tx_rate_class *c = &wl->conf.tx.sta_rc_conf; 741 int ret = 0; 742 743 wl1271_debug(DEBUG_ACX, "acx rate policies"); 744 745 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 746 747 if (!acx) { 748 ret = -ENOMEM; 749 goto out; 750 } 751 752 wl1271_debug(DEBUG_ACX, "basic_rate: 0x%x, full_rate: 0x%x", 753 wlvif->basic_rate, wlvif->rate_set); 754 755 /* configure one basic rate class */ 756 acx->rate_policy_idx = cpu_to_le32(wlvif->sta.basic_rate_idx); 757 acx->rate_policy.enabled_rates = cpu_to_le32(wlvif->basic_rate); 758 acx->rate_policy.short_retry_limit = c->short_retry_limit; 759 acx->rate_policy.long_retry_limit = c->long_retry_limit; 760 acx->rate_policy.aflags = c->aflags; 761 762 ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx)); 763 if (ret < 0) { 764 wl1271_warning("Setting of rate policies failed: %d", ret); 765 goto out; 766 } 767 768 /* configure one AP supported rate class */ 769 acx->rate_policy_idx = cpu_to_le32(wlvif->sta.ap_rate_idx); 770 771 /* the AP policy is HW specific */ 772 acx->rate_policy.enabled_rates = 773 cpu_to_le32(wlcore_hw_sta_get_ap_rate_mask(wl, wlvif)); 774 acx->rate_policy.short_retry_limit = c->short_retry_limit; 775 acx->rate_policy.long_retry_limit = c->long_retry_limit; 776 acx->rate_policy.aflags = c->aflags; 777 778 ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx)); 779 if (ret < 0) { 780 wl1271_warning("Setting of rate policies failed: %d", ret); 781 goto out; 782 } 783 784 /* 785 * configure one rate class for basic p2p operations. 786 * (p2p packets should always go out with OFDM rates, even 787 * if we are currently connected to 11b AP) 788 */ 789 acx->rate_policy_idx = cpu_to_le32(wlvif->sta.p2p_rate_idx); 790 acx->rate_policy.enabled_rates = 791 cpu_to_le32(CONF_TX_RATE_MASK_BASIC_P2P); 792 acx->rate_policy.short_retry_limit = c->short_retry_limit; 793 acx->rate_policy.long_retry_limit = c->long_retry_limit; 794 acx->rate_policy.aflags = c->aflags; 795 796 ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx)); 797 if (ret < 0) { 798 wl1271_warning("Setting of rate policies failed: %d", ret); 799 goto out; 800 } 801 802 out: 803 kfree(acx); 804 return ret; 805 } 806 807 int wl1271_acx_ap_rate_policy(struct wl1271 *wl, struct conf_tx_rate_class *c, 808 u8 idx) 809 { 810 struct acx_rate_policy *acx; 811 int ret = 0; 812 813 wl1271_debug(DEBUG_ACX, "acx ap rate policy %d rates 0x%x", 814 idx, c->enabled_rates); 815 816 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 817 if (!acx) { 818 ret = -ENOMEM; 819 goto out; 820 } 821 822 acx->rate_policy.enabled_rates = cpu_to_le32(c->enabled_rates); 823 acx->rate_policy.short_retry_limit = c->short_retry_limit; 824 acx->rate_policy.long_retry_limit = c->long_retry_limit; 825 acx->rate_policy.aflags = c->aflags; 826 827 acx->rate_policy_idx = cpu_to_le32(idx); 828 829 ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx)); 830 if (ret < 0) { 831 wl1271_warning("Setting of ap rate policy failed: %d", ret); 832 goto out; 833 } 834 835 out: 836 kfree(acx); 837 return ret; 838 } 839 840 int wl1271_acx_ac_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif, 841 u8 ac, u8 cw_min, u16 cw_max, u8 aifsn, u16 txop) 842 { 843 struct acx_ac_cfg *acx; 844 int ret = 0; 845 846 wl1271_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d " 847 "aifs %d txop %d", ac, cw_min, cw_max, aifsn, txop); 848 849 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 850 851 if (!acx) { 852 ret = -ENOMEM; 853 goto out; 854 } 855 856 acx->role_id = wlvif->role_id; 857 acx->ac = ac; 858 acx->cw_min = cw_min; 859 acx->cw_max = cpu_to_le16(cw_max); 860 acx->aifsn = aifsn; 861 acx->tx_op_limit = cpu_to_le16(txop); 862 863 ret = wl1271_cmd_configure(wl, ACX_AC_CFG, acx, sizeof(*acx)); 864 if (ret < 0) { 865 wl1271_warning("acx ac cfg failed: %d", ret); 866 goto out; 867 } 868 869 out: 870 kfree(acx); 871 return ret; 872 } 873 874 int wl1271_acx_tid_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif, 875 u8 queue_id, u8 channel_type, 876 u8 tsid, u8 ps_scheme, u8 ack_policy, 877 u32 apsd_conf0, u32 apsd_conf1) 878 { 879 struct acx_tid_config *acx; 880 int ret = 0; 881 882 wl1271_debug(DEBUG_ACX, "acx tid config"); 883 884 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 885 886 if (!acx) { 887 ret = -ENOMEM; 888 goto out; 889 } 890 891 acx->role_id = wlvif->role_id; 892 acx->queue_id = queue_id; 893 acx->channel_type = channel_type; 894 acx->tsid = tsid; 895 acx->ps_scheme = ps_scheme; 896 acx->ack_policy = ack_policy; 897 acx->apsd_conf[0] = cpu_to_le32(apsd_conf0); 898 acx->apsd_conf[1] = cpu_to_le32(apsd_conf1); 899 900 ret = wl1271_cmd_configure(wl, ACX_TID_CFG, acx, sizeof(*acx)); 901 if (ret < 0) { 902 wl1271_warning("Setting of tid config failed: %d", ret); 903 goto out; 904 } 905 906 out: 907 kfree(acx); 908 return ret; 909 } 910 911 int wl1271_acx_frag_threshold(struct wl1271 *wl, u32 frag_threshold) 912 { 913 struct acx_frag_threshold *acx; 914 int ret = 0; 915 916 /* 917 * If the fragmentation is not configured or out of range, use the 918 * default value. 919 */ 920 if (frag_threshold > IEEE80211_MAX_FRAG_THRESHOLD) 921 frag_threshold = wl->conf.tx.frag_threshold; 922 923 wl1271_debug(DEBUG_ACX, "acx frag threshold: %d", frag_threshold); 924 925 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 926 927 if (!acx) { 928 ret = -ENOMEM; 929 goto out; 930 } 931 932 acx->frag_threshold = cpu_to_le16((u16)frag_threshold); 933 ret = wl1271_cmd_configure(wl, ACX_FRAG_CFG, acx, sizeof(*acx)); 934 if (ret < 0) { 935 wl1271_warning("Setting of frag threshold failed: %d", ret); 936 goto out; 937 } 938 939 out: 940 kfree(acx); 941 return ret; 942 } 943 944 int wl1271_acx_tx_config_options(struct wl1271 *wl) 945 { 946 struct acx_tx_config_options *acx; 947 int ret = 0; 948 949 wl1271_debug(DEBUG_ACX, "acx tx config options"); 950 951 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 952 953 if (!acx) { 954 ret = -ENOMEM; 955 goto out; 956 } 957 958 acx->tx_compl_timeout = cpu_to_le16(wl->conf.tx.tx_compl_timeout); 959 acx->tx_compl_threshold = cpu_to_le16(wl->conf.tx.tx_compl_threshold); 960 ret = wl1271_cmd_configure(wl, ACX_TX_CONFIG_OPT, acx, sizeof(*acx)); 961 if (ret < 0) { 962 wl1271_warning("Setting of tx options failed: %d", ret); 963 goto out; 964 } 965 966 out: 967 kfree(acx); 968 return ret; 969 } 970 971 int wl12xx_acx_mem_cfg(struct wl1271 *wl) 972 { 973 struct wl12xx_acx_config_memory *mem_conf; 974 struct conf_memory_settings *mem; 975 int ret; 976 977 wl1271_debug(DEBUG_ACX, "wl1271 mem cfg"); 978 979 mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL); 980 if (!mem_conf) { 981 ret = -ENOMEM; 982 goto out; 983 } 984 985 mem = &wl->conf.mem; 986 987 /* memory config */ 988 mem_conf->num_stations = mem->num_stations; 989 mem_conf->rx_mem_block_num = mem->rx_block_num; 990 mem_conf->tx_min_mem_block_num = mem->tx_min_block_num; 991 mem_conf->num_ssid_profiles = mem->ssid_profiles; 992 mem_conf->total_tx_descriptors = cpu_to_le32(wl->num_tx_desc); 993 mem_conf->dyn_mem_enable = mem->dynamic_memory; 994 mem_conf->tx_free_req = mem->min_req_tx_blocks; 995 mem_conf->rx_free_req = mem->min_req_rx_blocks; 996 mem_conf->tx_min = mem->tx_min; 997 mem_conf->fwlog_blocks = wl->conf.fwlog.mem_blocks; 998 999 ret = wl1271_cmd_configure(wl, ACX_MEM_CFG, mem_conf, 1000 sizeof(*mem_conf)); 1001 if (ret < 0) { 1002 wl1271_warning("wl1271 mem config failed: %d", ret); 1003 goto out; 1004 } 1005 1006 out: 1007 kfree(mem_conf); 1008 return ret; 1009 } 1010 EXPORT_SYMBOL_GPL(wl12xx_acx_mem_cfg); 1011 1012 int wl1271_acx_init_mem_config(struct wl1271 *wl) 1013 { 1014 int ret; 1015 1016 wl->target_mem_map = kzalloc(sizeof(struct wl1271_acx_mem_map), 1017 GFP_KERNEL); 1018 if (!wl->target_mem_map) { 1019 wl1271_error("couldn't allocate target memory map"); 1020 return -ENOMEM; 1021 } 1022 1023 /* we now ask for the firmware built memory map */ 1024 ret = wl1271_acx_mem_map(wl, (void *)wl->target_mem_map, 1025 sizeof(struct wl1271_acx_mem_map)); 1026 if (ret < 0) { 1027 wl1271_error("couldn't retrieve firmware memory map"); 1028 kfree(wl->target_mem_map); 1029 wl->target_mem_map = NULL; 1030 return ret; 1031 } 1032 1033 /* initialize TX block book keeping */ 1034 wl->tx_blocks_available = 1035 le32_to_cpu(wl->target_mem_map->num_tx_mem_blocks); 1036 wl1271_debug(DEBUG_TX, "available tx blocks: %d", 1037 wl->tx_blocks_available); 1038 1039 return 0; 1040 } 1041 EXPORT_SYMBOL_GPL(wl1271_acx_init_mem_config); 1042 1043 int wl1271_acx_init_rx_interrupt(struct wl1271 *wl) 1044 { 1045 struct wl1271_acx_rx_config_opt *rx_conf; 1046 int ret; 1047 1048 wl1271_debug(DEBUG_ACX, "wl1271 rx interrupt config"); 1049 1050 rx_conf = kzalloc(sizeof(*rx_conf), GFP_KERNEL); 1051 if (!rx_conf) { 1052 ret = -ENOMEM; 1053 goto out; 1054 } 1055 1056 rx_conf->threshold = cpu_to_le16(wl->conf.rx.irq_pkt_threshold); 1057 rx_conf->timeout = cpu_to_le16(wl->conf.rx.irq_timeout); 1058 rx_conf->mblk_threshold = cpu_to_le16(wl->conf.rx.irq_blk_threshold); 1059 rx_conf->queue_type = wl->conf.rx.queue_type; 1060 1061 ret = wl1271_cmd_configure(wl, ACX_RX_CONFIG_OPT, rx_conf, 1062 sizeof(*rx_conf)); 1063 if (ret < 0) { 1064 wl1271_warning("wl1271 rx config opt failed: %d", ret); 1065 goto out; 1066 } 1067 1068 out: 1069 kfree(rx_conf); 1070 return ret; 1071 } 1072 1073 int wl1271_acx_bet_enable(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1074 bool enable) 1075 { 1076 struct wl1271_acx_bet_enable *acx = NULL; 1077 int ret = 0; 1078 1079 wl1271_debug(DEBUG_ACX, "acx bet enable"); 1080 1081 if (enable && wl->conf.conn.bet_enable == CONF_BET_MODE_DISABLE) 1082 goto out; 1083 1084 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1085 if (!acx) { 1086 ret = -ENOMEM; 1087 goto out; 1088 } 1089 1090 acx->role_id = wlvif->role_id; 1091 acx->enable = enable ? CONF_BET_MODE_ENABLE : CONF_BET_MODE_DISABLE; 1092 acx->max_consecutive = wl->conf.conn.bet_max_consecutive; 1093 1094 ret = wl1271_cmd_configure(wl, ACX_BET_ENABLE, acx, sizeof(*acx)); 1095 if (ret < 0) { 1096 wl1271_warning("acx bet enable failed: %d", ret); 1097 goto out; 1098 } 1099 1100 out: 1101 kfree(acx); 1102 return ret; 1103 } 1104 1105 int wl1271_acx_arp_ip_filter(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1106 u8 enable, __be32 address) 1107 { 1108 struct wl1271_acx_arp_filter *acx; 1109 int ret; 1110 1111 wl1271_debug(DEBUG_ACX, "acx arp ip filter, enable: %d", enable); 1112 1113 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1114 if (!acx) { 1115 ret = -ENOMEM; 1116 goto out; 1117 } 1118 1119 acx->role_id = wlvif->role_id; 1120 acx->version = ACX_IPV4_VERSION; 1121 acx->enable = enable; 1122 1123 if (enable) 1124 memcpy(acx->address, &address, ACX_IPV4_ADDR_SIZE); 1125 1126 ret = wl1271_cmd_configure(wl, ACX_ARP_IP_FILTER, 1127 acx, sizeof(*acx)); 1128 if (ret < 0) { 1129 wl1271_warning("failed to set arp ip filter: %d", ret); 1130 goto out; 1131 } 1132 1133 out: 1134 kfree(acx); 1135 return ret; 1136 } 1137 1138 int wl1271_acx_pm_config(struct wl1271 *wl) 1139 { 1140 struct wl1271_acx_pm_config *acx = NULL; 1141 struct conf_pm_config_settings *c = &wl->conf.pm_config; 1142 int ret = 0; 1143 1144 wl1271_debug(DEBUG_ACX, "acx pm config"); 1145 1146 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1147 if (!acx) { 1148 ret = -ENOMEM; 1149 goto out; 1150 } 1151 1152 acx->host_clk_settling_time = cpu_to_le32(c->host_clk_settling_time); 1153 acx->host_fast_wakeup_support = c->host_fast_wakeup_support; 1154 1155 ret = wl1271_cmd_configure(wl, ACX_PM_CONFIG, acx, sizeof(*acx)); 1156 if (ret < 0) { 1157 wl1271_warning("acx pm config failed: %d", ret); 1158 goto out; 1159 } 1160 1161 out: 1162 kfree(acx); 1163 return ret; 1164 } 1165 EXPORT_SYMBOL_GPL(wl1271_acx_pm_config); 1166 1167 int wl1271_acx_keep_alive_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1168 bool enable) 1169 { 1170 struct wl1271_acx_keep_alive_mode *acx = NULL; 1171 int ret = 0; 1172 1173 wl1271_debug(DEBUG_ACX, "acx keep alive mode: %d", enable); 1174 1175 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1176 if (!acx) { 1177 ret = -ENOMEM; 1178 goto out; 1179 } 1180 1181 acx->role_id = wlvif->role_id; 1182 acx->enabled = enable; 1183 1184 ret = wl1271_cmd_configure(wl, ACX_KEEP_ALIVE_MODE, acx, sizeof(*acx)); 1185 if (ret < 0) { 1186 wl1271_warning("acx keep alive mode failed: %d", ret); 1187 goto out; 1188 } 1189 1190 out: 1191 kfree(acx); 1192 return ret; 1193 } 1194 1195 int wl1271_acx_keep_alive_config(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1196 u8 index, u8 tpl_valid) 1197 { 1198 struct wl1271_acx_keep_alive_config *acx = NULL; 1199 int ret = 0; 1200 1201 wl1271_debug(DEBUG_ACX, "acx keep alive config"); 1202 1203 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1204 if (!acx) { 1205 ret = -ENOMEM; 1206 goto out; 1207 } 1208 1209 acx->role_id = wlvif->role_id; 1210 acx->period = cpu_to_le32(wl->conf.conn.keep_alive_interval); 1211 acx->index = index; 1212 acx->tpl_validation = tpl_valid; 1213 acx->trigger = ACX_KEEP_ALIVE_NO_TX; 1214 1215 ret = wl1271_cmd_configure(wl, ACX_SET_KEEP_ALIVE_CONFIG, 1216 acx, sizeof(*acx)); 1217 if (ret < 0) { 1218 wl1271_warning("acx keep alive config failed: %d", ret); 1219 goto out; 1220 } 1221 1222 out: 1223 kfree(acx); 1224 return ret; 1225 } 1226 1227 int wl1271_acx_rssi_snr_trigger(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1228 bool enable, s16 thold, u8 hyst) 1229 { 1230 struct wl1271_acx_rssi_snr_trigger *acx = NULL; 1231 int ret = 0; 1232 1233 wl1271_debug(DEBUG_ACX, "acx rssi snr trigger"); 1234 1235 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1236 if (!acx) { 1237 ret = -ENOMEM; 1238 goto out; 1239 } 1240 1241 wlvif->last_rssi_event = -1; 1242 1243 acx->role_id = wlvif->role_id; 1244 acx->pacing = cpu_to_le16(wl->conf.roam_trigger.trigger_pacing); 1245 acx->metric = WL1271_ACX_TRIG_METRIC_RSSI_BEACON; 1246 acx->type = WL1271_ACX_TRIG_TYPE_EDGE; 1247 if (enable) 1248 acx->enable = WL1271_ACX_TRIG_ENABLE; 1249 else 1250 acx->enable = WL1271_ACX_TRIG_DISABLE; 1251 1252 acx->index = WL1271_ACX_TRIG_IDX_RSSI; 1253 acx->dir = WL1271_ACX_TRIG_DIR_BIDIR; 1254 acx->threshold = cpu_to_le16(thold); 1255 acx->hysteresis = hyst; 1256 1257 ret = wl1271_cmd_configure(wl, ACX_RSSI_SNR_TRIGGER, acx, sizeof(*acx)); 1258 if (ret < 0) { 1259 wl1271_warning("acx rssi snr trigger setting failed: %d", ret); 1260 goto out; 1261 } 1262 1263 out: 1264 kfree(acx); 1265 return ret; 1266 } 1267 1268 int wl1271_acx_rssi_snr_avg_weights(struct wl1271 *wl, 1269 struct wl12xx_vif *wlvif) 1270 { 1271 struct wl1271_acx_rssi_snr_avg_weights *acx = NULL; 1272 struct conf_roam_trigger_settings *c = &wl->conf.roam_trigger; 1273 int ret = 0; 1274 1275 wl1271_debug(DEBUG_ACX, "acx rssi snr avg weights"); 1276 1277 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1278 if (!acx) { 1279 ret = -ENOMEM; 1280 goto out; 1281 } 1282 1283 acx->role_id = wlvif->role_id; 1284 acx->rssi_beacon = c->avg_weight_rssi_beacon; 1285 acx->rssi_data = c->avg_weight_rssi_data; 1286 acx->snr_beacon = c->avg_weight_snr_beacon; 1287 acx->snr_data = c->avg_weight_snr_data; 1288 1289 ret = wl1271_cmd_configure(wl, ACX_RSSI_SNR_WEIGHTS, acx, sizeof(*acx)); 1290 if (ret < 0) { 1291 wl1271_warning("acx rssi snr trigger weights failed: %d", ret); 1292 goto out; 1293 } 1294 1295 out: 1296 kfree(acx); 1297 return ret; 1298 } 1299 1300 int wl1271_acx_set_ht_capabilities(struct wl1271 *wl, 1301 struct ieee80211_sta_ht_cap *ht_cap, 1302 bool allow_ht_operation, u8 hlid) 1303 { 1304 struct wl1271_acx_ht_capabilities *acx; 1305 int ret = 0; 1306 u32 ht_capabilites = 0; 1307 1308 wl1271_debug(DEBUG_ACX, "acx ht capabilities setting " 1309 "sta supp: %d sta cap: %d", ht_cap->ht_supported, 1310 ht_cap->cap); 1311 1312 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1313 if (!acx) { 1314 ret = -ENOMEM; 1315 goto out; 1316 } 1317 1318 if (allow_ht_operation && ht_cap->ht_supported) { 1319 /* no need to translate capabilities - use the spec values */ 1320 ht_capabilites = ht_cap->cap; 1321 1322 /* 1323 * this bit is not employed by the spec but only by FW to 1324 * indicate peer HT support 1325 */ 1326 ht_capabilites |= WL12XX_HT_CAP_HT_OPERATION; 1327 1328 /* get data from A-MPDU parameters field */ 1329 acx->ampdu_max_length = ht_cap->ampdu_factor; 1330 acx->ampdu_min_spacing = ht_cap->ampdu_density; 1331 } 1332 1333 acx->hlid = hlid; 1334 acx->ht_capabilites = cpu_to_le32(ht_capabilites); 1335 1336 ret = wl1271_cmd_configure(wl, ACX_PEER_HT_CAP, acx, sizeof(*acx)); 1337 if (ret < 0) { 1338 wl1271_warning("acx ht capabilities setting failed: %d", ret); 1339 goto out; 1340 } 1341 1342 out: 1343 kfree(acx); 1344 return ret; 1345 } 1346 EXPORT_SYMBOL_GPL(wl1271_acx_set_ht_capabilities); 1347 1348 1349 int wl1271_acx_set_ht_information(struct wl1271 *wl, 1350 struct wl12xx_vif *wlvif, 1351 u16 ht_operation_mode) 1352 { 1353 struct wl1271_acx_ht_information *acx; 1354 int ret = 0; 1355 1356 wl1271_debug(DEBUG_ACX, "acx ht information setting"); 1357 1358 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1359 if (!acx) { 1360 ret = -ENOMEM; 1361 goto out; 1362 } 1363 1364 acx->role_id = wlvif->role_id; 1365 acx->ht_protection = 1366 (u8)(ht_operation_mode & IEEE80211_HT_OP_MODE_PROTECTION); 1367 acx->rifs_mode = 0; 1368 acx->gf_protection = 1369 !!(ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT); 1370 acx->ht_tx_burst_limit = 0; 1371 acx->dual_cts_protection = 0; 1372 1373 ret = wl1271_cmd_configure(wl, ACX_HT_BSS_OPERATION, acx, sizeof(*acx)); 1374 1375 if (ret < 0) { 1376 wl1271_warning("acx ht information setting failed: %d", ret); 1377 goto out; 1378 } 1379 1380 out: 1381 kfree(acx); 1382 return ret; 1383 } 1384 1385 /* Configure BA session initiator/receiver parameters setting in the FW. */ 1386 int wl12xx_acx_set_ba_initiator_policy(struct wl1271 *wl, 1387 struct wl12xx_vif *wlvif) 1388 { 1389 struct wl1271_acx_ba_initiator_policy *acx; 1390 int ret; 1391 1392 wl1271_debug(DEBUG_ACX, "acx ba initiator policy"); 1393 1394 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1395 if (!acx) { 1396 ret = -ENOMEM; 1397 goto out; 1398 } 1399 1400 /* set for the current role */ 1401 acx->role_id = wlvif->role_id; 1402 acx->tid_bitmap = wl->conf.ht.tx_ba_tid_bitmap; 1403 acx->win_size = wl->conf.ht.tx_ba_win_size; 1404 acx->inactivity_timeout = wl->conf.ht.inactivity_timeout; 1405 1406 ret = wl1271_cmd_configure(wl, 1407 ACX_BA_SESSION_INIT_POLICY, 1408 acx, 1409 sizeof(*acx)); 1410 if (ret < 0) { 1411 wl1271_warning("acx ba initiator policy failed: %d", ret); 1412 goto out; 1413 } 1414 1415 out: 1416 kfree(acx); 1417 return ret; 1418 } 1419 1420 /* setup BA session receiver setting in the FW. */ 1421 int wl12xx_acx_set_ba_receiver_session(struct wl1271 *wl, u8 tid_index, 1422 u16 ssn, bool enable, u8 peer_hlid) 1423 { 1424 struct wl1271_acx_ba_receiver_setup *acx; 1425 int ret; 1426 1427 wl1271_debug(DEBUG_ACX, "acx ba receiver session setting"); 1428 1429 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1430 if (!acx) { 1431 ret = -ENOMEM; 1432 goto out; 1433 } 1434 1435 acx->hlid = peer_hlid; 1436 acx->tid = tid_index; 1437 acx->enable = enable; 1438 acx->win_size = wl->conf.ht.rx_ba_win_size; 1439 acx->ssn = ssn; 1440 1441 ret = wlcore_cmd_configure_failsafe(wl, ACX_BA_SESSION_RX_SETUP, acx, 1442 sizeof(*acx), 1443 BIT(CMD_STATUS_NO_RX_BA_SESSION)); 1444 if (ret < 0) { 1445 wl1271_warning("acx ba receiver session failed: %d", ret); 1446 goto out; 1447 } 1448 1449 /* sometimes we can't start the session */ 1450 if (ret == CMD_STATUS_NO_RX_BA_SESSION) { 1451 wl1271_warning("no fw rx ba on tid %d", tid_index); 1452 ret = -EBUSY; 1453 goto out; 1454 } 1455 1456 ret = 0; 1457 out: 1458 kfree(acx); 1459 return ret; 1460 } 1461 1462 int wl12xx_acx_tsf_info(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1463 u64 *mactime) 1464 { 1465 struct wl12xx_acx_fw_tsf_information *tsf_info; 1466 int ret; 1467 1468 tsf_info = kzalloc(sizeof(*tsf_info), GFP_KERNEL); 1469 if (!tsf_info) { 1470 ret = -ENOMEM; 1471 goto out; 1472 } 1473 1474 tsf_info->role_id = wlvif->role_id; 1475 1476 ret = wl1271_cmd_interrogate(wl, ACX_TSF_INFO, tsf_info, 1477 sizeof(struct acx_header), sizeof(*tsf_info)); 1478 if (ret < 0) { 1479 wl1271_warning("acx tsf info interrogate failed"); 1480 goto out; 1481 } 1482 1483 *mactime = le32_to_cpu(tsf_info->current_tsf_low) | 1484 ((u64) le32_to_cpu(tsf_info->current_tsf_high) << 32); 1485 1486 out: 1487 kfree(tsf_info); 1488 return ret; 1489 } 1490 1491 int wl1271_acx_ps_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1492 bool enable) 1493 { 1494 struct wl1271_acx_ps_rx_streaming *rx_streaming; 1495 u32 conf_queues, enable_queues; 1496 int i, ret = 0; 1497 1498 wl1271_debug(DEBUG_ACX, "acx ps rx streaming"); 1499 1500 rx_streaming = kzalloc(sizeof(*rx_streaming), GFP_KERNEL); 1501 if (!rx_streaming) { 1502 ret = -ENOMEM; 1503 goto out; 1504 } 1505 1506 conf_queues = wl->conf.rx_streaming.queues; 1507 if (enable) 1508 enable_queues = conf_queues; 1509 else 1510 enable_queues = 0; 1511 1512 for (i = 0; i < 8; i++) { 1513 /* 1514 * Skip non-changed queues, to avoid redundant acxs. 1515 * this check assumes conf.rx_streaming.queues can't 1516 * be changed while rx_streaming is enabled. 1517 */ 1518 if (!(conf_queues & BIT(i))) 1519 continue; 1520 1521 rx_streaming->role_id = wlvif->role_id; 1522 rx_streaming->tid = i; 1523 rx_streaming->enable = enable_queues & BIT(i); 1524 rx_streaming->period = wl->conf.rx_streaming.interval; 1525 rx_streaming->timeout = wl->conf.rx_streaming.interval; 1526 1527 ret = wl1271_cmd_configure(wl, ACX_PS_RX_STREAMING, 1528 rx_streaming, 1529 sizeof(*rx_streaming)); 1530 if (ret < 0) { 1531 wl1271_warning("acx ps rx streaming failed: %d", ret); 1532 goto out; 1533 } 1534 } 1535 out: 1536 kfree(rx_streaming); 1537 return ret; 1538 } 1539 1540 int wl1271_acx_ap_max_tx_retry(struct wl1271 *wl, struct wl12xx_vif *wlvif) 1541 { 1542 struct wl1271_acx_ap_max_tx_retry *acx = NULL; 1543 int ret; 1544 1545 wl1271_debug(DEBUG_ACX, "acx ap max tx retry"); 1546 1547 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1548 if (!acx) 1549 return -ENOMEM; 1550 1551 acx->role_id = wlvif->role_id; 1552 acx->max_tx_retry = cpu_to_le16(wl->conf.tx.max_tx_retries); 1553 1554 ret = wl1271_cmd_configure(wl, ACX_MAX_TX_FAILURE, acx, sizeof(*acx)); 1555 if (ret < 0) { 1556 wl1271_warning("acx ap max tx retry failed: %d", ret); 1557 goto out; 1558 } 1559 1560 out: 1561 kfree(acx); 1562 return ret; 1563 } 1564 1565 int wl12xx_acx_config_ps(struct wl1271 *wl, struct wl12xx_vif *wlvif) 1566 { 1567 struct wl1271_acx_config_ps *config_ps; 1568 int ret; 1569 1570 wl1271_debug(DEBUG_ACX, "acx config ps"); 1571 1572 config_ps = kzalloc(sizeof(*config_ps), GFP_KERNEL); 1573 if (!config_ps) { 1574 ret = -ENOMEM; 1575 goto out; 1576 } 1577 1578 config_ps->exit_retries = wl->conf.conn.psm_exit_retries; 1579 config_ps->enter_retries = wl->conf.conn.psm_entry_retries; 1580 config_ps->null_data_rate = cpu_to_le32(wlvif->basic_rate); 1581 1582 ret = wl1271_cmd_configure(wl, ACX_CONFIG_PS, config_ps, 1583 sizeof(*config_ps)); 1584 1585 if (ret < 0) { 1586 wl1271_warning("acx config ps failed: %d", ret); 1587 goto out; 1588 } 1589 1590 out: 1591 kfree(config_ps); 1592 return ret; 1593 } 1594 1595 int wl1271_acx_set_inconnection_sta(struct wl1271 *wl, 1596 struct wl12xx_vif *wlvif, u8 *addr) 1597 { 1598 struct wl1271_acx_inconnection_sta *acx = NULL; 1599 int ret; 1600 1601 wl1271_debug(DEBUG_ACX, "acx set inconnaction sta %pM", addr); 1602 1603 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1604 if (!acx) 1605 return -ENOMEM; 1606 1607 memcpy(acx->addr, addr, ETH_ALEN); 1608 acx->role_id = wlvif->role_id; 1609 1610 ret = wl1271_cmd_configure(wl, ACX_UPDATE_INCONNECTION_STA_LIST, 1611 acx, sizeof(*acx)); 1612 if (ret < 0) { 1613 wl1271_warning("acx set inconnaction sta failed: %d", ret); 1614 goto out; 1615 } 1616 1617 out: 1618 kfree(acx); 1619 return ret; 1620 } 1621 1622 int wl1271_acx_fm_coex(struct wl1271 *wl) 1623 { 1624 struct wl1271_acx_fm_coex *acx; 1625 int ret; 1626 1627 wl1271_debug(DEBUG_ACX, "acx fm coex setting"); 1628 1629 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1630 if (!acx) { 1631 ret = -ENOMEM; 1632 goto out; 1633 } 1634 1635 acx->enable = wl->conf.fm_coex.enable; 1636 acx->swallow_period = wl->conf.fm_coex.swallow_period; 1637 acx->n_divider_fref_set_1 = wl->conf.fm_coex.n_divider_fref_set_1; 1638 acx->n_divider_fref_set_2 = wl->conf.fm_coex.n_divider_fref_set_2; 1639 acx->m_divider_fref_set_1 = 1640 cpu_to_le16(wl->conf.fm_coex.m_divider_fref_set_1); 1641 acx->m_divider_fref_set_2 = 1642 cpu_to_le16(wl->conf.fm_coex.m_divider_fref_set_2); 1643 acx->coex_pll_stabilization_time = 1644 cpu_to_le32(wl->conf.fm_coex.coex_pll_stabilization_time); 1645 acx->ldo_stabilization_time = 1646 cpu_to_le16(wl->conf.fm_coex.ldo_stabilization_time); 1647 acx->fm_disturbed_band_margin = 1648 wl->conf.fm_coex.fm_disturbed_band_margin; 1649 acx->swallow_clk_diff = wl->conf.fm_coex.swallow_clk_diff; 1650 1651 ret = wl1271_cmd_configure(wl, ACX_FM_COEX_CFG, acx, sizeof(*acx)); 1652 if (ret < 0) { 1653 wl1271_warning("acx fm coex setting failed: %d", ret); 1654 goto out; 1655 } 1656 1657 out: 1658 kfree(acx); 1659 return ret; 1660 } 1661 1662 int wl12xx_acx_set_rate_mgmt_params(struct wl1271 *wl) 1663 { 1664 struct wl12xx_acx_set_rate_mgmt_params *acx = NULL; 1665 struct conf_rate_policy_settings *conf = &wl->conf.rate; 1666 int ret; 1667 1668 wl1271_debug(DEBUG_ACX, "acx set rate mgmt params"); 1669 1670 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1671 if (!acx) 1672 return -ENOMEM; 1673 1674 acx->index = ACX_RATE_MGMT_ALL_PARAMS; 1675 acx->rate_retry_score = cpu_to_le16(conf->rate_retry_score); 1676 acx->per_add = cpu_to_le16(conf->per_add); 1677 acx->per_th1 = cpu_to_le16(conf->per_th1); 1678 acx->per_th2 = cpu_to_le16(conf->per_th2); 1679 acx->max_per = cpu_to_le16(conf->max_per); 1680 acx->inverse_curiosity_factor = conf->inverse_curiosity_factor; 1681 acx->tx_fail_low_th = conf->tx_fail_low_th; 1682 acx->tx_fail_high_th = conf->tx_fail_high_th; 1683 acx->per_alpha_shift = conf->per_alpha_shift; 1684 acx->per_add_shift = conf->per_add_shift; 1685 acx->per_beta1_shift = conf->per_beta1_shift; 1686 acx->per_beta2_shift = conf->per_beta2_shift; 1687 acx->rate_check_up = conf->rate_check_up; 1688 acx->rate_check_down = conf->rate_check_down; 1689 memcpy(acx->rate_retry_policy, conf->rate_retry_policy, 1690 sizeof(acx->rate_retry_policy)); 1691 1692 ret = wl1271_cmd_configure(wl, ACX_SET_RATE_MGMT_PARAMS, 1693 acx, sizeof(*acx)); 1694 if (ret < 0) { 1695 wl1271_warning("acx set rate mgmt params failed: %d", ret); 1696 goto out; 1697 } 1698 1699 out: 1700 kfree(acx); 1701 return ret; 1702 } 1703 1704 int wl12xx_acx_config_hangover(struct wl1271 *wl) 1705 { 1706 struct wl12xx_acx_config_hangover *acx; 1707 struct conf_hangover_settings *conf = &wl->conf.hangover; 1708 int ret; 1709 1710 wl1271_debug(DEBUG_ACX, "acx config hangover"); 1711 1712 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1713 if (!acx) { 1714 ret = -ENOMEM; 1715 goto out; 1716 } 1717 1718 acx->recover_time = cpu_to_le32(conf->recover_time); 1719 acx->hangover_period = conf->hangover_period; 1720 acx->dynamic_mode = conf->dynamic_mode; 1721 acx->early_termination_mode = conf->early_termination_mode; 1722 acx->max_period = conf->max_period; 1723 acx->min_period = conf->min_period; 1724 acx->increase_delta = conf->increase_delta; 1725 acx->decrease_delta = conf->decrease_delta; 1726 acx->quiet_time = conf->quiet_time; 1727 acx->increase_time = conf->increase_time; 1728 acx->window_size = conf->window_size; 1729 1730 ret = wl1271_cmd_configure(wl, ACX_CONFIG_HANGOVER, acx, 1731 sizeof(*acx)); 1732 1733 if (ret < 0) { 1734 wl1271_warning("acx config hangover failed: %d", ret); 1735 goto out; 1736 } 1737 1738 out: 1739 kfree(acx); 1740 return ret; 1741 1742 } 1743 1744 int wlcore_acx_average_rssi(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1745 s8 *avg_rssi) 1746 { 1747 struct acx_roaming_stats *acx; 1748 int ret = 0; 1749 1750 wl1271_debug(DEBUG_ACX, "acx roaming statistics"); 1751 1752 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1753 if (!acx) { 1754 ret = -ENOMEM; 1755 goto out; 1756 } 1757 1758 acx->role_id = wlvif->role_id; 1759 ret = wl1271_cmd_interrogate(wl, ACX_ROAMING_STATISTICS_TBL, 1760 acx, sizeof(*acx), sizeof(*acx)); 1761 if (ret < 0) { 1762 wl1271_warning("acx roaming statistics failed: %d", ret); 1763 ret = -ENOMEM; 1764 goto out; 1765 } 1766 1767 *avg_rssi = acx->rssi_beacon; 1768 out: 1769 kfree(acx); 1770 return ret; 1771 } 1772 1773 #ifdef CONFIG_PM 1774 /* Set the global behaviour of RX filters - On/Off + default action */ 1775 int wl1271_acx_default_rx_filter_enable(struct wl1271 *wl, bool enable, 1776 enum rx_filter_action action) 1777 { 1778 struct acx_default_rx_filter *acx; 1779 int ret; 1780 1781 wl1271_debug(DEBUG_ACX, "acx default rx filter en: %d act: %d", 1782 enable, action); 1783 1784 acx = kzalloc(sizeof(*acx), GFP_KERNEL); 1785 if (!acx) 1786 return -ENOMEM; 1787 1788 acx->enable = enable; 1789 acx->default_action = action; 1790 1791 ret = wl1271_cmd_configure(wl, ACX_ENABLE_RX_DATA_FILTER, acx, 1792 sizeof(*acx)); 1793 if (ret < 0) { 1794 wl1271_warning("acx default rx filter enable failed: %d", ret); 1795 goto out; 1796 } 1797 1798 out: 1799 kfree(acx); 1800 return ret; 1801 } 1802 1803 /* Configure or disable a specific RX filter pattern */ 1804 int wl1271_acx_set_rx_filter(struct wl1271 *wl, u8 index, bool enable, 1805 struct wl12xx_rx_filter *filter) 1806 { 1807 struct acx_rx_filter_cfg *acx; 1808 int fields_size = 0; 1809 int acx_size; 1810 int ret; 1811 1812 WARN_ON(enable && !filter); 1813 WARN_ON(index >= WL1271_MAX_RX_FILTERS); 1814 1815 wl1271_debug(DEBUG_ACX, 1816 "acx set rx filter idx: %d enable: %d filter: %p", 1817 index, enable, filter); 1818 1819 if (enable) { 1820 fields_size = wl1271_rx_filter_get_fields_size(filter); 1821 1822 wl1271_debug(DEBUG_ACX, "act: %d num_fields: %d field_size: %d", 1823 filter->action, filter->num_fields, fields_size); 1824 } 1825 1826 acx_size = ALIGN(sizeof(*acx) + fields_size, 4); 1827 acx = kzalloc(acx_size, GFP_KERNEL); 1828 1829 if (!acx) 1830 return -ENOMEM; 1831 1832 acx->enable = enable; 1833 acx->index = index; 1834 1835 if (enable) { 1836 acx->num_fields = filter->num_fields; 1837 acx->action = filter->action; 1838 wl1271_rx_filter_flatten_fields(filter, acx->fields); 1839 } 1840 1841 wl1271_dump(DEBUG_ACX, "RX_FILTER: ", acx, acx_size); 1842 1843 ret = wl1271_cmd_configure(wl, ACX_SET_RX_DATA_FILTER, acx, acx_size); 1844 if (ret < 0) { 1845 wl1271_warning("setting rx filter failed: %d", ret); 1846 goto out; 1847 } 1848 1849 out: 1850 kfree(acx); 1851 return ret; 1852 } 1853 #endif /* CONFIG_PM */ 1854