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