1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "wl1271_acx.h"
25
26#include <linux/module.h>
27#include <linux/platform_device.h>
28#include <linux/crc7.h>
29#include <linux/spi/spi.h>
30
31#include "wl1271.h"
32#include "wl12xx_80211.h"
33#include "wl1271_reg.h"
34#include "wl1271_spi.h"
35#include "wl1271_ps.h"
36
37int wl1271_acx_wake_up_conditions(struct wl1271 *wl, u8 wake_up_event,
38 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");
44
45 wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
46 if (!wake_up) {
47 ret = -ENOMEM;
48 goto out;
49 }
50
51 wake_up->wake_up_event = wake_up_event;
52 wake_up->listen_interval = listen_interval;
53
54 ret = wl1271_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
55 wake_up, sizeof(*wake_up));
56 if (ret < 0) {
57 wl1271_warning("could not set wake up conditions: %d", ret);
58 goto out;
59 }
60
61out:
62 kfree(wake_up);
63 return ret;
64}
65
66int wl1271_acx_sleep_auth(struct wl1271 *wl, u8 sleep_auth)
67{
68 struct acx_sleep_auth *auth;
69 int ret;
70
71 wl1271_debug(DEBUG_ACX, "acx sleep auth");
72
73 auth = kzalloc(sizeof(*auth), GFP_KERNEL);
74 if (!auth) {
75 ret = -ENOMEM;
76 goto out;
77 }
78
79 auth->sleep_auth = sleep_auth;
80
81 ret = wl1271_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
82 if (ret < 0)
83 return ret;
84
85out:
86 kfree(auth);
87 return ret;
88}
89
90int wl1271_acx_fw_version(struct wl1271 *wl, char *buf, size_t len)
91{
92 struct acx_revision *rev;
93 int ret;
94
95 wl1271_debug(DEBUG_ACX, "acx fw rev");
96
97 rev = kzalloc(sizeof(*rev), GFP_KERNEL);
98 if (!rev) {
99 ret = -ENOMEM;
100 goto out;
101 }
102
103 ret = wl1271_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
104 if (ret < 0) {
105 wl1271_warning("ACX_FW_REV interrogate failed");
106 goto out;
107 }
108
109
110 strncpy(buf, rev->fw_version, min(len, sizeof(rev->fw_version)));
111
112
113
114
115
116
117 buf[min(len, sizeof(rev->fw_version)) - 1] = '\0';
118
119out:
120 kfree(rev);
121 return ret;
122}
123
124int wl1271_acx_tx_power(struct wl1271 *wl, int power)
125{
126 struct acx_current_tx_power *acx;
127 int ret;
128
129 wl1271_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
130
131 if (power < 0 || power > 25)
132 return -EINVAL;
133
134 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
135 if (!acx) {
136 ret = -ENOMEM;
137 goto out;
138 }
139
140 acx->current_tx_power = power * 10;
141
142 ret = wl1271_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
143 if (ret < 0) {
144 wl1271_warning("configure of tx power failed: %d", ret);
145 goto out;
146 }
147
148out:
149 kfree(acx);
150 return ret;
151}
152
153int wl1271_acx_feature_cfg(struct wl1271 *wl)
154{
155 struct acx_feature_config *feature;
156 int ret;
157
158 wl1271_debug(DEBUG_ACX, "acx feature cfg");
159
160 feature = kzalloc(sizeof(*feature), GFP_KERNEL);
161 if (!feature) {
162 ret = -ENOMEM;
163 goto out;
164 }
165
166
167 feature->data_flow_options = 0;
168 feature->options = 0;
169
170 ret = wl1271_cmd_configure(wl, ACX_FEATURE_CFG,
171 feature, sizeof(*feature));
172 if (ret < 0) {
173 wl1271_error("Couldnt set HW encryption");
174 goto out;
175 }
176
177out:
178 kfree(feature);
179 return ret;
180}
181
182int wl1271_acx_mem_map(struct wl1271 *wl, struct acx_header *mem_map,
183 size_t len)
184{
185 int ret;
186
187 wl1271_debug(DEBUG_ACX, "acx mem map");
188
189 ret = wl1271_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
190 if (ret < 0)
191 return ret;
192
193 return 0;
194}
195
196int wl1271_acx_rx_msdu_life_time(struct wl1271 *wl, u32 life_time)
197{
198 struct acx_rx_msdu_lifetime *acx;
199 int ret;
200
201 wl1271_debug(DEBUG_ACX, "acx rx msdu life time");
202
203 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
204 if (!acx) {
205 ret = -ENOMEM;
206 goto out;
207 }
208
209 acx->lifetime = life_time;
210 ret = wl1271_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
211 acx, sizeof(*acx));
212 if (ret < 0) {
213 wl1271_warning("failed to set rx msdu life time: %d", ret);
214 goto out;
215 }
216
217out:
218 kfree(acx);
219 return ret;
220}
221
222int wl1271_acx_rx_config(struct wl1271 *wl, u32 config, u32 filter)
223{
224 struct acx_rx_config *rx_config;
225 int ret;
226
227 wl1271_debug(DEBUG_ACX, "acx rx config");
228
229 rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
230 if (!rx_config) {
231 ret = -ENOMEM;
232 goto out;
233 }
234
235 rx_config->config_options = config;
236 rx_config->filter_options = filter;
237
238 ret = wl1271_cmd_configure(wl, ACX_RX_CFG,
239 rx_config, sizeof(*rx_config));
240 if (ret < 0) {
241 wl1271_warning("failed to set rx config: %d", ret);
242 goto out;
243 }
244
245out:
246 kfree(rx_config);
247 return ret;
248}
249
250int wl1271_acx_pd_threshold(struct wl1271 *wl)
251{
252 struct acx_packet_detection *pd;
253 int ret;
254
255 wl1271_debug(DEBUG_ACX, "acx data pd threshold");
256
257 pd = kzalloc(sizeof(*pd), GFP_KERNEL);
258 if (!pd) {
259 ret = -ENOMEM;
260 goto out;
261 }
262
263
264
265 ret = wl1271_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
266 if (ret < 0) {
267 wl1271_warning("failed to set pd threshold: %d", ret);
268 goto out;
269 }
270
271out:
272 kfree(pd);
273 return 0;
274}
275
276int wl1271_acx_slot(struct wl1271 *wl, enum acx_slot_type slot_time)
277{
278 struct acx_slot *slot;
279 int ret;
280
281 wl1271_debug(DEBUG_ACX, "acx slot");
282
283 slot = kzalloc(sizeof(*slot), GFP_KERNEL);
284 if (!slot) {
285 ret = -ENOMEM;
286 goto out;
287 }
288
289 slot->wone_index = STATION_WONE_INDEX;
290 slot->slot_time = slot_time;
291
292 ret = wl1271_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
293 if (ret < 0) {
294 wl1271_warning("failed to set slot time: %d", ret);
295 goto out;
296 }
297
298out:
299 kfree(slot);
300 return ret;
301}
302
303int wl1271_acx_group_address_tbl(struct wl1271 *wl)
304{
305 struct acx_dot11_grp_addr_tbl *acx;
306 int ret;
307
308 wl1271_debug(DEBUG_ACX, "acx group address tbl");
309
310 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
311 if (!acx) {
312 ret = -ENOMEM;
313 goto out;
314 }
315
316
317 acx->enabled = 0;
318 acx->num_groups = 0;
319 memset(acx->mac_table, 0, ADDRESS_GROUP_MAX_LEN);
320
321 ret = wl1271_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
322 acx, sizeof(*acx));
323 if (ret < 0) {
324 wl1271_warning("failed to set group addr table: %d", ret);
325 goto out;
326 }
327
328out:
329 kfree(acx);
330 return ret;
331}
332
333int wl1271_acx_service_period_timeout(struct wl1271 *wl)
334{
335 struct acx_rx_timeout *rx_timeout;
336 int ret;
337
338 rx_timeout = kzalloc(sizeof(*rx_timeout), GFP_KERNEL);
339 if (!rx_timeout) {
340 ret = -ENOMEM;
341 goto out;
342 }
343
344 wl1271_debug(DEBUG_ACX, "acx service period timeout");
345
346 rx_timeout->ps_poll_timeout = RX_TIMEOUT_PS_POLL_DEF;
347 rx_timeout->upsd_timeout = RX_TIMEOUT_UPSD_DEF;
348
349 ret = wl1271_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
350 rx_timeout, sizeof(*rx_timeout));
351 if (ret < 0) {
352 wl1271_warning("failed to set service period timeout: %d",
353 ret);
354 goto out;
355 }
356
357out:
358 kfree(rx_timeout);
359 return ret;
360}
361
362int wl1271_acx_rts_threshold(struct wl1271 *wl, u16 rts_threshold)
363{
364 struct acx_rts_threshold *rts;
365 int ret;
366
367 wl1271_debug(DEBUG_ACX, "acx rts threshold");
368
369 rts = kzalloc(sizeof(*rts), GFP_KERNEL);
370 if (!rts) {
371 ret = -ENOMEM;
372 goto out;
373 }
374
375 rts->threshold = rts_threshold;
376
377 ret = wl1271_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
378 if (ret < 0) {
379 wl1271_warning("failed to set rts threshold: %d", ret);
380 goto out;
381 }
382
383out:
384 kfree(rts);
385 return ret;
386}
387
388int wl1271_acx_beacon_filter_opt(struct wl1271 *wl)
389{
390 struct acx_beacon_filter_option *beacon_filter;
391 int ret;
392
393 wl1271_debug(DEBUG_ACX, "acx beacon filter opt");
394
395 beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
396 if (!beacon_filter) {
397 ret = -ENOMEM;
398 goto out;
399 }
400
401 beacon_filter->enable = 0;
402 beacon_filter->max_num_beacons = 0;
403
404 ret = wl1271_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
405 beacon_filter, sizeof(*beacon_filter));
406 if (ret < 0) {
407 wl1271_warning("failed to set beacon filter opt: %d", ret);
408 goto out;
409 }
410
411out:
412 kfree(beacon_filter);
413 return ret;
414}
415
416int wl1271_acx_beacon_filter_table(struct wl1271 *wl)
417{
418 struct acx_beacon_filter_ie_table *ie_table;
419 int ret;
420
421 wl1271_debug(DEBUG_ACX, "acx beacon filter table");
422
423 ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
424 if (!ie_table) {
425 ret = -ENOMEM;
426 goto out;
427 }
428
429 ie_table->num_ie = 0;
430 memset(ie_table->table, 0, BEACON_FILTER_TABLE_MAX_SIZE);
431
432 ret = wl1271_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
433 ie_table, sizeof(*ie_table));
434 if (ret < 0) {
435 wl1271_warning("failed to set beacon filter table: %d", ret);
436 goto out;
437 }
438
439out:
440 kfree(ie_table);
441 return ret;
442}
443
444int wl1271_acx_sg_enable(struct wl1271 *wl)
445{
446 struct acx_bt_wlan_coex *pta;
447 int ret;
448
449 wl1271_debug(DEBUG_ACX, "acx sg enable");
450
451 pta = kzalloc(sizeof(*pta), GFP_KERNEL);
452 if (!pta) {
453 ret = -ENOMEM;
454 goto out;
455 }
456
457 pta->enable = SG_ENABLE;
458
459 ret = wl1271_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
460 if (ret < 0) {
461 wl1271_warning("failed to set softgemini enable: %d", ret);
462 goto out;
463 }
464
465out:
466 kfree(pta);
467 return ret;
468}
469
470int wl1271_acx_sg_cfg(struct wl1271 *wl)
471{
472 struct acx_bt_wlan_coex_param *param;
473 int ret;
474
475 wl1271_debug(DEBUG_ACX, "acx sg cfg");
476
477 param = kzalloc(sizeof(*param), GFP_KERNEL);
478 if (!param) {
479 ret = -ENOMEM;
480 goto out;
481 }
482
483
484 param->min_rate = RATE_INDEX_24MBPS;
485 param->bt_hp_max_time = PTA_BT_HP_MAXTIME_DEF;
486 param->wlan_hp_max_time = PTA_WLAN_HP_MAX_TIME_DEF;
487 param->sense_disable_timer = PTA_SENSE_DISABLE_TIMER_DEF;
488 param->rx_time_bt_hp = PTA_PROTECTIVE_RX_TIME_DEF;
489 param->tx_time_bt_hp = PTA_PROTECTIVE_TX_TIME_DEF;
490 param->rx_time_bt_hp_fast = PTA_PROTECTIVE_RX_TIME_FAST_DEF;
491 param->tx_time_bt_hp_fast = PTA_PROTECTIVE_TX_TIME_FAST_DEF;
492 param->wlan_cycle_fast = PTA_CYCLE_TIME_FAST_DEF;
493 param->bt_anti_starvation_period = PTA_ANTI_STARVE_PERIOD_DEF;
494 param->next_bt_lp_packet = PTA_TIMEOUT_NEXT_BT_LP_PACKET_DEF;
495 param->wake_up_beacon = PTA_TIME_BEFORE_BEACON_DEF;
496 param->hp_dm_max_guard_time = PTA_HPDM_MAX_TIME_DEF;
497 param->next_wlan_packet = PTA_TIME_OUT_NEXT_WLAN_DEF;
498 param->antenna_type = PTA_ANTENNA_TYPE_DEF;
499 param->signal_type = PTA_SIGNALING_TYPE_DEF;
500 param->afh_leverage_on = PTA_AFH_LEVERAGE_ON_DEF;
501 param->quiet_cycle_num = PTA_NUMBER_QUIET_CYCLE_DEF;
502 param->max_cts = PTA_MAX_NUM_CTS_DEF;
503 param->wlan_packets_num = PTA_NUMBER_OF_WLAN_PACKETS_DEF;
504 param->bt_packets_num = PTA_NUMBER_OF_BT_PACKETS_DEF;
505 param->missed_rx_avalanche = PTA_RX_FOR_AVALANCHE_DEF;
506 param->wlan_elp_hp = PTA_ELP_HP_DEF;
507 param->bt_anti_starvation_cycles = PTA_ANTI_STARVE_NUM_CYCLE_DEF;
508 param->ack_mode_dual_ant = PTA_ACK_MODE_DEF;
509 param->pa_sd_enable = PTA_ALLOW_PA_SD_DEF;
510 param->pta_auto_mode_enable = PTA_AUTO_MODE_NO_CTS_DEF;
511 param->bt_hp_respected_num = PTA_BT_HP_RESPECTED_DEF;
512
513 ret = wl1271_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
514 if (ret < 0) {
515 wl1271_warning("failed to set sg config: %d", ret);
516 goto out;
517 }
518
519out:
520 kfree(param);
521 return ret;
522}
523
524int wl1271_acx_cca_threshold(struct wl1271 *wl)
525{
526 struct acx_energy_detection *detection;
527 int ret;
528
529 wl1271_debug(DEBUG_ACX, "acx cca threshold");
530
531 detection = kzalloc(sizeof(*detection), GFP_KERNEL);
532 if (!detection) {
533 ret = -ENOMEM;
534 goto out;
535 }
536
537 detection->rx_cca_threshold = CCA_THRSH_DISABLE_ENERGY_D;
538 detection->tx_energy_detection = 0;
539
540 ret = wl1271_cmd_configure(wl, ACX_CCA_THRESHOLD,
541 detection, sizeof(*detection));
542 if (ret < 0) {
543 wl1271_warning("failed to set cca threshold: %d", ret);
544 return ret;
545 }
546
547out:
548 kfree(detection);
549 return ret;
550}
551
552int wl1271_acx_bcn_dtim_options(struct wl1271 *wl)
553{
554 struct acx_beacon_broadcast *bb;
555 int ret;
556
557 wl1271_debug(DEBUG_ACX, "acx bcn dtim options");
558
559 bb = kzalloc(sizeof(*bb), GFP_KERNEL);
560 if (!bb) {
561 ret = -ENOMEM;
562 goto out;
563 }
564
565 bb->beacon_rx_timeout = BCN_RX_TIMEOUT_DEF_VALUE;
566 bb->broadcast_timeout = BROADCAST_RX_TIMEOUT_DEF_VALUE;
567 bb->rx_broadcast_in_ps = RX_BROADCAST_IN_PS_DEF_VALUE;
568 bb->ps_poll_threshold = CONSECUTIVE_PS_POLL_FAILURE_DEF;
569
570 ret = wl1271_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
571 if (ret < 0) {
572 wl1271_warning("failed to set rx config: %d", ret);
573 goto out;
574 }
575
576out:
577 kfree(bb);
578 return ret;
579}
580
581int wl1271_acx_aid(struct wl1271 *wl, u16 aid)
582{
583 struct acx_aid *acx_aid;
584 int ret;
585
586 wl1271_debug(DEBUG_ACX, "acx aid");
587
588 acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
589 if (!acx_aid) {
590 ret = -ENOMEM;
591 goto out;
592 }
593
594 acx_aid->aid = aid;
595
596 ret = wl1271_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
597 if (ret < 0) {
598 wl1271_warning("failed to set aid: %d", ret);
599 goto out;
600 }
601
602out:
603 kfree(acx_aid);
604 return ret;
605}
606
607int wl1271_acx_event_mbox_mask(struct wl1271 *wl, u32 event_mask)
608{
609 struct acx_event_mask *mask;
610 int ret;
611
612 wl1271_debug(DEBUG_ACX, "acx event mbox mask");
613
614 mask = kzalloc(sizeof(*mask), GFP_KERNEL);
615 if (!mask) {
616 ret = -ENOMEM;
617 goto out;
618 }
619
620
621 mask->high_event_mask = 0xffffffff;
622
623 mask->event_mask = event_mask;
624
625 ret = wl1271_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
626 mask, sizeof(*mask));
627 if (ret < 0) {
628 wl1271_warning("failed to set acx_event_mbox_mask: %d", ret);
629 goto out;
630 }
631
632out:
633 kfree(mask);
634 return ret;
635}
636
637int wl1271_acx_set_preamble(struct wl1271 *wl, enum acx_preamble_type preamble)
638{
639 struct acx_preamble *acx;
640 int ret;
641
642 wl1271_debug(DEBUG_ACX, "acx_set_preamble");
643
644 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
645 if (!acx) {
646 ret = -ENOMEM;
647 goto out;
648 }
649
650 acx->preamble = preamble;
651
652 ret = wl1271_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
653 if (ret < 0) {
654 wl1271_warning("Setting of preamble failed: %d", ret);
655 goto out;
656 }
657
658out:
659 kfree(acx);
660 return ret;
661}
662
663int wl1271_acx_cts_protect(struct wl1271 *wl,
664 enum acx_ctsprotect_type ctsprotect)
665{
666 struct acx_ctsprotect *acx;
667 int ret;
668
669 wl1271_debug(DEBUG_ACX, "acx_set_ctsprotect");
670
671 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
672 if (!acx) {
673 ret = -ENOMEM;
674 goto out;
675 }
676
677 acx->ctsprotect = ctsprotect;
678
679 ret = wl1271_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
680 if (ret < 0) {
681 wl1271_warning("Setting of ctsprotect failed: %d", ret);
682 goto out;
683 }
684
685out:
686 kfree(acx);
687 return ret;
688}
689
690int wl1271_acx_statistics(struct wl1271 *wl, struct acx_statistics *stats)
691{
692 int ret;
693
694 wl1271_debug(DEBUG_ACX, "acx statistics");
695
696 ret = wl1271_cmd_interrogate(wl, ACX_STATISTICS, stats,
697 sizeof(*stats));
698 if (ret < 0) {
699 wl1271_warning("acx statistics failed: %d", ret);
700 return -ENOMEM;
701 }
702
703 return 0;
704}
705
706int wl1271_acx_rate_policies(struct wl1271 *wl)
707{
708 struct acx_rate_policy *acx;
709 int ret = 0;
710
711 wl1271_debug(DEBUG_ACX, "acx rate policies");
712
713 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
714
715 if (!acx) {
716 ret = -ENOMEM;
717 goto out;
718 }
719
720
721 acx->rate_class_cnt = 1;
722 acx->rate_class[0].enabled_rates = ACX_RATE_MASK_ALL;
723 acx->rate_class[0].short_retry_limit = ACX_RATE_RETRY_LIMIT;
724 acx->rate_class[0].long_retry_limit = ACX_RATE_RETRY_LIMIT;
725 acx->rate_class[0].aflags = 0;
726
727 ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
728 if (ret < 0) {
729 wl1271_warning("Setting of rate policies failed: %d", ret);
730 goto out;
731 }
732
733out:
734 kfree(acx);
735 return ret;
736}
737
738int wl1271_acx_ac_cfg(struct wl1271 *wl)
739{
740 struct acx_ac_cfg *acx;
741 int i, ret = 0;
742
743 wl1271_debug(DEBUG_ACX, "acx access category config");
744
745 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
746
747 if (!acx) {
748 ret = -ENOMEM;
749 goto out;
750 }
751
752
753
754
755
756 for (i = 0; i < WL1271_ACX_AC_COUNT; i++) {
757 acx->ac = i;
758
759
760
761
762
763 acx->cw_min = 15;
764 acx->cw_max = 63;
765 acx->aifsn = 3;
766 acx->reserved = 0;
767 acx->tx_op_limit = 0;
768
769 ret = wl1271_cmd_configure(wl, ACX_AC_CFG, acx, sizeof(*acx));
770 if (ret < 0) {
771 wl1271_warning("Setting of access category "
772 "config: %d", ret);
773 goto out;
774 }
775 }
776
777out:
778 kfree(acx);
779 return ret;
780}
781
782int wl1271_acx_tid_cfg(struct wl1271 *wl)
783{
784 struct acx_tid_config *acx;
785 int i, ret = 0;
786
787 wl1271_debug(DEBUG_ACX, "acx tid config");
788
789 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
790
791 if (!acx) {
792 ret = -ENOMEM;
793 goto out;
794 }
795
796
797 for (i = 0; i < WL1271_ACX_TID_COUNT; i++) {
798 acx->queue_id = i;
799 acx->tsid = WL1271_ACX_AC_BE;
800 acx->ps_scheme = WL1271_ACX_PS_SCHEME_LEGACY;
801 acx->ack_policy = WL1271_ACX_ACK_POLICY_LEGACY;
802
803 ret = wl1271_cmd_configure(wl, ACX_TID_CFG, acx, sizeof(*acx));
804 if (ret < 0) {
805 wl1271_warning("Setting of tid config failed: %d", ret);
806 goto out;
807 }
808 }
809
810out:
811 kfree(acx);
812 return ret;
813}
814
815int wl1271_acx_frag_threshold(struct wl1271 *wl)
816{
817 struct acx_frag_threshold *acx;
818 int ret = 0;
819
820 wl1271_debug(DEBUG_ACX, "acx frag threshold");
821
822 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
823
824 if (!acx) {
825 ret = -ENOMEM;
826 goto out;
827 }
828
829 acx->frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
830 ret = wl1271_cmd_configure(wl, ACX_FRAG_CFG, acx, sizeof(*acx));
831 if (ret < 0) {
832 wl1271_warning("Setting of frag threshold failed: %d", ret);
833 goto out;
834 }
835
836out:
837 kfree(acx);
838 return ret;
839}
840
841int wl1271_acx_tx_config_options(struct wl1271 *wl)
842{
843 struct acx_tx_config_options *acx;
844 int ret = 0;
845
846 wl1271_debug(DEBUG_ACX, "acx tx config options");
847
848 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
849
850 if (!acx) {
851 ret = -ENOMEM;
852 goto out;
853 }
854
855 acx->tx_compl_timeout = WL1271_ACX_TX_COMPL_TIMEOUT;
856 acx->tx_compl_threshold = WL1271_ACX_TX_COMPL_THRESHOLD;
857 ret = wl1271_cmd_configure(wl, ACX_TX_CONFIG_OPT, acx, sizeof(*acx));
858 if (ret < 0) {
859 wl1271_warning("Setting of tx options failed: %d", ret);
860 goto out;
861 }
862
863out:
864 kfree(acx);
865 return ret;
866}
867
868int wl1271_acx_mem_cfg(struct wl1271 *wl)
869{
870 struct wl1271_acx_config_memory *mem_conf;
871 int ret;
872
873 wl1271_debug(DEBUG_ACX, "wl1271 mem cfg");
874
875 mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
876 if (!mem_conf) {
877 ret = -ENOMEM;
878 goto out;
879 }
880
881
882 mem_conf->num_stations = cpu_to_le16(DEFAULT_NUM_STATIONS);
883 mem_conf->rx_mem_block_num = ACX_RX_MEM_BLOCKS;
884 mem_conf->tx_min_mem_block_num = ACX_TX_MIN_MEM_BLOCKS;
885 mem_conf->num_ssid_profiles = ACX_NUM_SSID_PROFILES;
886 mem_conf->total_tx_descriptors = ACX_TX_DESCRIPTORS;
887
888 ret = wl1271_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
889 sizeof(*mem_conf));
890 if (ret < 0) {
891 wl1271_warning("wl1271 mem config failed: %d", ret);
892 goto out;
893 }
894
895out:
896 kfree(mem_conf);
897 return ret;
898}
899
900int wl1271_acx_init_mem_config(struct wl1271 *wl)
901{
902 int ret;
903
904 ret = wl1271_acx_mem_cfg(wl);
905 if (ret < 0)
906 return ret;
907
908 wl->target_mem_map = kzalloc(sizeof(struct wl1271_acx_mem_map),
909 GFP_KERNEL);
910 if (!wl->target_mem_map) {
911 wl1271_error("couldn't allocate target memory map");
912 return -ENOMEM;
913 }
914
915
916 ret = wl1271_acx_mem_map(wl, (void *)wl->target_mem_map,
917 sizeof(struct wl1271_acx_mem_map));
918 if (ret < 0) {
919 wl1271_error("couldn't retrieve firmware memory map");
920 kfree(wl->target_mem_map);
921 wl->target_mem_map = NULL;
922 return ret;
923 }
924
925
926 wl->tx_blocks_available = wl->target_mem_map->num_tx_mem_blocks;
927 wl1271_debug(DEBUG_TX, "available tx blocks: %d",
928 wl->tx_blocks_available);
929
930 return 0;
931}
932
933int wl1271_acx_init_rx_interrupt(struct wl1271 *wl)
934{
935 struct wl1271_acx_rx_config_opt *rx_conf;
936 int ret;
937
938 wl1271_debug(DEBUG_ACX, "wl1271 rx interrupt config");
939
940 rx_conf = kzalloc(sizeof(*rx_conf), GFP_KERNEL);
941 if (!rx_conf) {
942 ret = -ENOMEM;
943 goto out;
944 }
945
946 rx_conf->threshold = WL1271_RX_INTR_THRESHOLD_DEF;
947 rx_conf->timeout = WL1271_RX_INTR_TIMEOUT_DEF;
948 rx_conf->mblk_threshold = USHORT_MAX;
949 rx_conf->queue_type = RX_QUEUE_TYPE_RX_LOW_PRIORITY;
950
951 ret = wl1271_cmd_configure(wl, ACX_RX_CONFIG_OPT, rx_conf,
952 sizeof(*rx_conf));
953 if (ret < 0) {
954 wl1271_warning("wl1271 rx config opt failed: %d", ret);
955 goto out;
956 }
957
958out:
959 kfree(rx_conf);
960 return ret;
961}
962
