1#include "acx.h"
2
3#include <linux/module.h>
4#include <linux/slab.h>
5#include <linux/crc7.h>
6
7#include "wl1251.h"
8#include "reg.h"
9#include "cmd.h"
10#include "ps.h"
11
12int wl1251_acx_frame_rates(struct wl1251 *wl, u8 ctrl_rate, u8 ctrl_mod,
13 u8 mgt_rate, u8 mgt_mod)
14{
15 struct acx_fw_gen_frame_rates *rates;
16 int ret;
17
18 wl1251_debug(DEBUG_ACX, "acx frame rates");
19
20 rates = kzalloc(sizeof(*rates), GFP_KERNEL);
21 if (!rates)
22 return -ENOMEM;
23
24 rates->tx_ctrl_frame_rate = ctrl_rate;
25 rates->tx_ctrl_frame_mod = ctrl_mod;
26 rates->tx_mgt_frame_rate = mgt_rate;
27 rates->tx_mgt_frame_mod = mgt_mod;
28
29 ret = wl1251_cmd_configure(wl, ACX_FW_GEN_FRAME_RATES,
30 rates, sizeof(*rates));
31 if (ret < 0) {
32 wl1251_error("Failed to set FW rates and modulation");
33 goto out;
34 }
35
36out:
37 kfree(rates);
38 return ret;
39}
40
41
42int wl1251_acx_station_id(struct wl1251 *wl)
43{
44 struct acx_dot11_station_id *mac;
45 int ret, i;
46
47 wl1251_debug(DEBUG_ACX, "acx dot11_station_id");
48
49 mac = kzalloc(sizeof(*mac), GFP_KERNEL);
50 if (!mac)
51 return -ENOMEM;
52
53 for (i = 0; i < ETH_ALEN; i++)
54 mac->mac[i] = wl->mac_addr[ETH_ALEN - 1 - i];
55
56 ret = wl1251_cmd_configure(wl, DOT11_STATION_ID, mac, sizeof(*mac));
57 if (ret < 0)
58 goto out;
59
60out:
61 kfree(mac);
62 return ret;
63}
64
65int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id)
66{
67 struct acx_dot11_default_key *default_key;
68 int ret;
69
70 wl1251_debug(DEBUG_ACX, "acx dot11_default_key (%d)", key_id);
71
72 default_key = kzalloc(sizeof(*default_key), GFP_KERNEL);
73 if (!default_key)
74 return -ENOMEM;
75
76 default_key->id = key_id;
77
78 ret = wl1251_cmd_configure(wl, DOT11_DEFAULT_KEY,
79 default_key, sizeof(*default_key));
80 if (ret < 0) {
81 wl1251_error("Couldn't set default key");
82 goto out;
83 }
84
85 wl->default_key = key_id;
86
87out:
88 kfree(default_key);
89 return ret;
90}
91
92int wl1251_acx_wake_up_conditions(struct wl1251 *wl, u8 wake_up_event,
93 u8 listen_interval)
94{
95 struct acx_wake_up_condition *wake_up;
96 int ret;
97
98 wl1251_debug(DEBUG_ACX, "acx wake up conditions");
99
100 wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
101 if (!wake_up)
102 return -ENOMEM;
103
104 wake_up->wake_up_event = wake_up_event;
105 wake_up->listen_interval = listen_interval;
106
107 ret = wl1251_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
108 wake_up, sizeof(*wake_up));
109 if (ret < 0) {
110 wl1251_warning("could not set wake up conditions: %d", ret);
111 goto out;
112 }
113
114out:
115 kfree(wake_up);
116 return ret;
117}
118
119int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth)
120{
121 struct acx_sleep_auth *auth;
122 int ret;
123
124 wl1251_debug(DEBUG_ACX, "acx sleep auth");
125
126 auth = kzalloc(sizeof(*auth), GFP_KERNEL);
127 if (!auth)
128 return -ENOMEM;
129
130 auth->sleep_auth = sleep_auth;
131
132 ret = wl1251_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
133
134 kfree(auth);
135 return ret;
136}
137
138int wl1251_acx_fw_version(struct wl1251 *wl, char *buf, size_t len)
139{
140 struct acx_revision *rev;
141 int ret;
142
143 wl1251_debug(DEBUG_ACX, "acx fw rev");
144
145 rev = kzalloc(sizeof(*rev), GFP_KERNEL);
146 if (!rev)
147 return -ENOMEM;
148
149 ret = wl1251_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
150 if (ret < 0) {
151 wl1251_warning("ACX_FW_REV interrogate failed");
152 goto out;
153 }
154
155
156 strncpy(buf, rev->fw_version, min(len, sizeof(rev->fw_version)));
157
158
159
160
161
162
163 buf[min(len, sizeof(rev->fw_version)) - 1] = '\0';
164
165out:
166 kfree(rev);
167 return ret;
168}
169
170int wl1251_acx_tx_power(struct wl1251 *wl, int power)
171{
172 struct acx_current_tx_power *acx;
173 int ret;
174
175 wl1251_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
176
177 if (power < 0 || power > 25)
178 return -EINVAL;
179
180 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
181 if (!acx)
182 return -ENOMEM;
183
184 acx->current_tx_power = power * 10;
185
186 ret = wl1251_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
187 if (ret < 0) {
188 wl1251_warning("configure of tx power failed: %d", ret);
189 goto out;
190 }
191
192out:
193 kfree(acx);
194 return ret;
195}
196
197int wl1251_acx_feature_cfg(struct wl1251 *wl, u32 data_flow_options)
198{
199 struct acx_feature_config *feature;
200 int ret;
201
202 wl1251_debug(DEBUG_ACX, "acx feature cfg");
203
204 feature = kzalloc(sizeof(*feature), GFP_KERNEL);
205 if (!feature)
206 return -ENOMEM;
207
208
209 feature->data_flow_options = data_flow_options;
210 feature->options = 0;
211
212 ret = wl1251_cmd_configure(wl, ACX_FEATURE_CFG,
213 feature, sizeof(*feature));
214 if (ret < 0) {
215 wl1251_error("Couldn't set HW encryption");
216 goto out;
217 }
218
219out:
220 kfree(feature);
221 return ret;
222}
223
224int wl1251_acx_mem_map(struct wl1251 *wl, struct acx_header *mem_map,
225 size_t len)
226{
227 int ret;
228
229 wl1251_debug(DEBUG_ACX, "acx mem map");
230
231 ret = wl1251_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
232 if (ret < 0)
233 return ret;
234
235 return 0;
236}
237
238int wl1251_acx_data_path_params(struct wl1251 *wl,
239 struct acx_data_path_params_resp *resp)
240{
241 struct acx_data_path_params *params;
242 int ret;
243
244 wl1251_debug(DEBUG_ACX, "acx data path params");
245
246 params = kzalloc(sizeof(*params), GFP_KERNEL);
247 if (!params)
248 return -ENOMEM;
249
250 params->rx_packet_ring_chunk_size = DP_RX_PACKET_RING_CHUNK_SIZE;
251 params->tx_packet_ring_chunk_size = DP_TX_PACKET_RING_CHUNK_SIZE;
252
253 params->rx_packet_ring_chunk_num = DP_RX_PACKET_RING_CHUNK_NUM;
254 params->tx_packet_ring_chunk_num = DP_TX_PACKET_RING_CHUNK_NUM;
255
256 params->tx_complete_threshold = 1;
257
258 params->tx_complete_ring_depth = FW_TX_CMPLT_BLOCK_SIZE;
259
260 params->tx_complete_timeout = DP_TX_COMPLETE_TIME_OUT;
261
262 ret = wl1251_cmd_configure(wl, ACX_DATA_PATH_PARAMS,
263 params, sizeof(*params));
264 if (ret < 0)
265 goto out;
266
267
268 ret = wl1251_cmd_interrogate(wl, ACX_DATA_PATH_PARAMS,
269 resp, sizeof(*resp));
270
271 if (ret < 0) {
272 wl1251_warning("failed to read data path parameters: %d", ret);
273 goto out;
274 } else if (resp->header.cmd.status != CMD_STATUS_SUCCESS) {
275 wl1251_warning("data path parameter acx status failed");
276 ret = -EIO;
277 goto out;
278 }
279
280out:
281 kfree(params);
282 return ret;
283}
284
285int wl1251_acx_rx_msdu_life_time(struct wl1251 *wl, u32 life_time)
286{
287 struct acx_rx_msdu_lifetime *acx;
288 int ret;
289
290 wl1251_debug(DEBUG_ACX, "acx rx msdu life time");
291
292 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
293 if (!acx)
294 return -ENOMEM;
295
296 acx->lifetime = life_time;
297 ret = wl1251_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
298 acx, sizeof(*acx));
299 if (ret < 0) {
300 wl1251_warning("failed to set rx msdu life time: %d", ret);
301 goto out;
302 }
303
304out:
305 kfree(acx);
306 return ret;
307}
308
309int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter)
310{
311 struct acx_rx_config *rx_config;
312 int ret;
313
314 wl1251_debug(DEBUG_ACX, "acx rx config");
315
316 rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
317 if (!rx_config)
318 return -ENOMEM;
319
320 rx_config->config_options = config;
321 rx_config->filter_options = filter;
322
323 ret = wl1251_cmd_configure(wl, ACX_RX_CFG,
324 rx_config, sizeof(*rx_config));
325 if (ret < 0) {
326 wl1251_warning("failed to set rx config: %d", ret);
327 goto out;
328 }
329
330out:
331 kfree(rx_config);
332 return ret;
333}
334
335int wl1251_acx_pd_threshold(struct wl1251 *wl)
336{
337 struct acx_packet_detection *pd;
338 int ret;
339
340 wl1251_debug(DEBUG_ACX, "acx data pd threshold");
341
342 pd = kzalloc(sizeof(*pd), GFP_KERNEL);
343 if (!pd)
344 return -ENOMEM;
345
346
347
348 ret = wl1251_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
349 if (ret < 0) {
350 wl1251_warning("failed to set pd threshold: %d", ret);
351 goto out;
352 }
353
354out:
355 kfree(pd);
356 return ret;
357}
358
359int wl1251_acx_slot(struct wl1251 *wl, enum acx_slot_type slot_time)
360{
361 struct acx_slot *slot;
362 int ret;
363
364 wl1251_debug(DEBUG_ACX, "acx slot");
365
366 slot = kzalloc(sizeof(*slot), GFP_KERNEL);
367 if (!slot)
368 return -ENOMEM;
369
370 slot->wone_index = STATION_WONE_INDEX;
371 slot->slot_time = slot_time;
372
373 ret = wl1251_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
374 if (ret < 0) {
375 wl1251_warning("failed to set slot time: %d", ret);
376 goto out;
377 }
378
379out:
380 kfree(slot);
381 return ret;
382}
383
384int wl1251_acx_group_address_tbl(struct wl1251 *wl, bool enable,
385 void *mc_list, u32 mc_list_len)
386{
387 struct acx_dot11_grp_addr_tbl *acx;
388 int ret;
389
390 wl1251_debug(DEBUG_ACX, "acx group address tbl");
391
392 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
393 if (!acx)
394 return -ENOMEM;
395
396
397 acx->enabled = enable;
398 acx->num_groups = mc_list_len;
399 memcpy(acx->mac_table, mc_list, mc_list_len * ETH_ALEN);
400
401 ret = wl1251_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
402 acx, sizeof(*acx));
403 if (ret < 0) {
404 wl1251_warning("failed to set group addr table: %d", ret);
405 goto out;
406 }
407
408out:
409 kfree(acx);
410 return ret;
411}
412
413int wl1251_acx_service_period_timeout(struct wl1251 *wl)
414{
415 struct acx_rx_timeout *rx_timeout;
416 int ret;
417
418 rx_timeout = kzalloc(sizeof(*rx_timeout), GFP_KERNEL);
419 if (!rx_timeout)
420 return -ENOMEM;
421
422 wl1251_debug(DEBUG_ACX, "acx service period timeout");
423
424 rx_timeout->ps_poll_timeout = RX_TIMEOUT_PS_POLL_DEF;
425 rx_timeout->upsd_timeout = RX_TIMEOUT_UPSD_DEF;
426
427 ret = wl1251_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
428 rx_timeout, sizeof(*rx_timeout));
429 if (ret < 0) {
430 wl1251_warning("failed to set service period timeout: %d",
431 ret);
432 goto out;
433 }
434
435out:
436 kfree(rx_timeout);
437 return ret;
438}
439
440int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold)
441{
442 struct acx_rts_threshold *rts;
443 int ret;
444
445 wl1251_debug(DEBUG_ACX, "acx rts threshold");
446
447 rts = kzalloc(sizeof(*rts), GFP_KERNEL);
448 if (!rts)
449 return -ENOMEM;
450
451 rts->threshold = rts_threshold;
452
453 ret = wl1251_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
454 if (ret < 0) {
455 wl1251_warning("failed to set rts threshold: %d", ret);
456 goto out;
457 }
458
459out:
460 kfree(rts);
461 return ret;
462}
463
464int wl1251_acx_beacon_filter_opt(struct wl1251 *wl, bool enable_filter)
465{
466 struct acx_beacon_filter_option *beacon_filter;
467 int ret;
468
469 wl1251_debug(DEBUG_ACX, "acx beacon filter opt");
470
471 beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
472 if (!beacon_filter)
473 return -ENOMEM;
474
475 beacon_filter->enable = enable_filter;
476 beacon_filter->max_num_beacons = 0;
477
478 ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
479 beacon_filter, sizeof(*beacon_filter));
480 if (ret < 0) {
481 wl1251_warning("failed to set beacon filter opt: %d", ret);
482 goto out;
483 }
484
485out:
486 kfree(beacon_filter);
487 return ret;
488}
489
490int wl1251_acx_beacon_filter_table(struct wl1251 *wl)
491{
492 struct acx_beacon_filter_ie_table *ie_table;
493 int idx = 0;
494 int ret;
495
496 wl1251_debug(DEBUG_ACX, "acx beacon filter table");
497
498 ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
499 if (!ie_table)
500 return -ENOMEM;
501
502
503 ie_table->num_ie = 1;
504 ie_table->table[idx++] = BEACON_FILTER_IE_ID_CHANNEL_SWITCH_ANN;
505 ie_table->table[idx++] = BEACON_RULE_PASS_ON_APPEARANCE;
506
507 ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
508 ie_table, sizeof(*ie_table));
509 if (ret < 0) {
510 wl1251_warning("failed to set beacon filter table: %d", ret);
511 goto out;
512 }
513
514out:
515 kfree(ie_table);
516 return ret;
517}
518
519int wl1251_acx_conn_monit_params(struct wl1251 *wl)
520{
521 struct acx_conn_monit_params *acx;
522 int ret;
523
524 wl1251_debug(DEBUG_ACX, "acx connection monitor parameters");
525
526 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
527 if (!acx)
528 return -ENOMEM;
529
530 acx->synch_fail_thold = SYNCH_FAIL_DEFAULT_THRESHOLD;
531 acx->bss_lose_timeout = NO_BEACON_DEFAULT_TIMEOUT;
532
533 ret = wl1251_cmd_configure(wl, ACX_CONN_MONIT_PARAMS,
534 acx, sizeof(*acx));
535 if (ret < 0) {
536 wl1251_warning("failed to set connection monitor "
537 "parameters: %d", ret);
538 goto out;
539 }
540
541out:
542 kfree(acx);
543 return ret;
544}
545
546int wl1251_acx_sg_enable(struct wl1251 *wl)
547{
548 struct acx_bt_wlan_coex *pta;
549 int ret;
550
551 wl1251_debug(DEBUG_ACX, "acx sg enable");
552
553 pta = kzalloc(sizeof(*pta), GFP_KERNEL);
554 if (!pta)
555 return -ENOMEM;
556
557 pta->enable = SG_ENABLE;
558
559 ret = wl1251_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
560 if (ret < 0) {
561 wl1251_warning("failed to set softgemini enable: %d", ret);
562 goto out;
563 }
564
565out:
566 kfree(pta);
567 return ret;
568}
569
570int wl1251_acx_sg_cfg(struct wl1251 *wl)
571{
572 struct acx_bt_wlan_coex_param *param;
573 int ret;
574
575 wl1251_debug(DEBUG_ACX, "acx sg cfg");
576
577 param = kzalloc(sizeof(*param), GFP_KERNEL);
578 if (!param)
579 return -ENOMEM;
580
581
582 param->min_rate = RATE_INDEX_24MBPS;
583 param->bt_hp_max_time = PTA_BT_HP_MAXTIME_DEF;
584 param->wlan_hp_max_time = PTA_WLAN_HP_MAX_TIME_DEF;
585 param->sense_disable_timer = PTA_SENSE_DISABLE_TIMER_DEF;
586 param->rx_time_bt_hp = PTA_PROTECTIVE_RX_TIME_DEF;
587 param->tx_time_bt_hp = PTA_PROTECTIVE_TX_TIME_DEF;
588 param->rx_time_bt_hp_fast = PTA_PROTECTIVE_RX_TIME_FAST_DEF;
589 param->tx_time_bt_hp_fast = PTA_PROTECTIVE_TX_TIME_FAST_DEF;
590 param->wlan_cycle_fast = PTA_CYCLE_TIME_FAST_DEF;
591 param->bt_anti_starvation_period = PTA_ANTI_STARVE_PERIOD_DEF;
592 param->next_bt_lp_packet = PTA_TIMEOUT_NEXT_BT_LP_PACKET_DEF;
593 param->wake_up_beacon = PTA_TIME_BEFORE_BEACON_DEF;
594 param->hp_dm_max_guard_time = PTA_HPDM_MAX_TIME_DEF;
595 param->next_wlan_packet = PTA_TIME_OUT_NEXT_WLAN_DEF;
596 param->antenna_type = PTA_ANTENNA_TYPE_DEF;
597 param->signal_type = PTA_SIGNALING_TYPE_DEF;
598 param->afh_leverage_on = PTA_AFH_LEVERAGE_ON_DEF;
599 param->quiet_cycle_num = PTA_NUMBER_QUIET_CYCLE_DEF;
600 param->max_cts = PTA_MAX_NUM_CTS_DEF;
601 param->wlan_packets_num = PTA_NUMBER_OF_WLAN_PACKETS_DEF;
602 param->bt_packets_num = PTA_NUMBER_OF_BT_PACKETS_DEF;
603 param->missed_rx_avalanche = PTA_RX_FOR_AVALANCHE_DEF;
604 param->wlan_elp_hp = PTA_ELP_HP_DEF;
605 param->bt_anti_starvation_cycles = PTA_ANTI_STARVE_NUM_CYCLE_DEF;
606 param->ack_mode_dual_ant = PTA_ACK_MODE_DEF;
607 param->pa_sd_enable = PTA_ALLOW_PA_SD_DEF;
608 param->pta_auto_mode_enable = PTA_AUTO_MODE_NO_CTS_DEF;
609 param->bt_hp_respected_num = PTA_BT_HP_RESPECTED_DEF;
610
611 ret = wl1251_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
612 if (ret < 0) {
613 wl1251_warning("failed to set sg config: %d", ret);
614 goto out;
615 }
616
617out:
618 kfree(param);
619 return ret;
620}
621
622int wl1251_acx_cca_threshold(struct wl1251 *wl)
623{
624 struct acx_energy_detection *detection;
625 int ret;
626
627 wl1251_debug(DEBUG_ACX, "acx cca threshold");
628
629 detection = kzalloc(sizeof(*detection), GFP_KERNEL);
630 if (!detection)
631 return -ENOMEM;
632
633 detection->rx_cca_threshold = CCA_THRSH_DISABLE_ENERGY_D;
634 detection->tx_energy_detection = 0;
635
636 ret = wl1251_cmd_configure(wl, ACX_CCA_THRESHOLD,
637 detection, sizeof(*detection));
638 if (ret < 0)
639 wl1251_warning("failed to set cca threshold: %d", ret);
640
641 kfree(detection);
642 return ret;
643}
644
645int wl1251_acx_bcn_dtim_options(struct wl1251 *wl)
646{
647 struct acx_beacon_broadcast *bb;
648 int ret;
649
650 wl1251_debug(DEBUG_ACX, "acx bcn dtim options");
651
652 bb = kzalloc(sizeof(*bb), GFP_KERNEL);
653 if (!bb)
654 return -ENOMEM;
655
656 bb->beacon_rx_timeout = BCN_RX_TIMEOUT_DEF_VALUE;
657 bb->broadcast_timeout = BROADCAST_RX_TIMEOUT_DEF_VALUE;
658 bb->rx_broadcast_in_ps = RX_BROADCAST_IN_PS_DEF_VALUE;
659 bb->ps_poll_threshold = CONSECUTIVE_PS_POLL_FAILURE_DEF;
660
661 ret = wl1251_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
662 if (ret < 0) {
663 wl1251_warning("failed to set rx config: %d", ret);
664 goto out;
665 }
666
667out:
668 kfree(bb);
669 return ret;
670}
671
672int wl1251_acx_aid(struct wl1251 *wl, u16 aid)
673{
674 struct acx_aid *acx_aid;
675 int ret;
676
677 wl1251_debug(DEBUG_ACX, "acx aid");
678
679 acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
680 if (!acx_aid)
681 return -ENOMEM;
682
683 acx_aid->aid = aid;
684
685 ret = wl1251_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
686 if (ret < 0) {
687 wl1251_warning("failed to set aid: %d", ret);
688 goto out;
689 }
690
691out:
692 kfree(acx_aid);
693 return ret;
694}
695
696int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask)
697{
698 struct acx_event_mask *mask;
699 int ret;
700
701 wl1251_debug(DEBUG_ACX, "acx event mbox mask");
702
703 mask = kzalloc(sizeof(*mask), GFP_KERNEL);
704 if (!mask)
705 return -ENOMEM;
706
707
708 mask->high_event_mask = 0xffffffff;
709
710 mask->event_mask = event_mask;
711
712 ret = wl1251_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
713 mask, sizeof(*mask));
714 if (ret < 0) {
715 wl1251_warning("failed to set acx_event_mbox_mask: %d", ret);
716 goto out;
717 }
718
719out:
720 kfree(mask);
721 return ret;
722}
723
724int wl1251_acx_low_rssi(struct wl1251 *wl, s8 threshold, u8 weight,
725 u8 depth, enum wl1251_acx_low_rssi_type type)
726{
727 struct acx_low_rssi *rssi;
728 int ret;
729
730 wl1251_debug(DEBUG_ACX, "acx low rssi");
731
732 rssi = kzalloc(sizeof(*rssi), GFP_KERNEL);
733 if (!rssi)
734 return -ENOMEM;
735
736 rssi->threshold = threshold;
737 rssi->weight = weight;
738 rssi->depth = depth;
739 rssi->type = type;
740
741 ret = wl1251_cmd_configure(wl, ACX_LOW_RSSI, rssi, sizeof(*rssi));
742 if (ret < 0)
743 wl1251_warning("failed to set low rssi threshold: %d", ret);
744
745 kfree(rssi);
746 return ret;
747}
748
749int wl1251_acx_set_preamble(struct wl1251 *wl, enum acx_preamble_type preamble)
750{
751 struct acx_preamble *acx;
752 int ret;
753
754 wl1251_debug(DEBUG_ACX, "acx_set_preamble");
755
756 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
757 if (!acx)
758 return -ENOMEM;
759
760 acx->preamble = preamble;
761
762 ret = wl1251_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
763 if (ret < 0) {
764 wl1251_warning("Setting of preamble failed: %d", ret);
765 goto out;
766 }
767
768out:
769 kfree(acx);
770 return ret;
771}
772
773int wl1251_acx_cts_protect(struct wl1251 *wl,
774 enum acx_ctsprotect_type ctsprotect)
775{
776 struct acx_ctsprotect *acx;
777 int ret;
778
779 wl1251_debug(DEBUG_ACX, "acx_set_ctsprotect");
780
781 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
782 if (!acx)
783 return -ENOMEM;
784
785 acx->ctsprotect = ctsprotect;
786
787 ret = wl1251_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
788 if (ret < 0) {
789 wl1251_warning("Setting of ctsprotect failed: %d", ret);
790 goto out;
791 }
792
793out:
794 kfree(acx);
795 return ret;
796}
797
798int wl1251_acx_tsf_info(struct wl1251 *wl, u64 *mactime)
799{
800 struct acx_tsf_info *tsf_info;
801 int ret;
802
803 tsf_info = kzalloc(sizeof(*tsf_info), GFP_KERNEL);
804 if (!tsf_info)
805 return -ENOMEM;
806
807 ret = wl1251_cmd_interrogate(wl, ACX_TSF_INFO,
808 tsf_info, sizeof(*tsf_info));
809 if (ret < 0) {
810 wl1251_warning("ACX_FW_REV interrogate failed");
811 goto out;
812 }
813
814 *mactime = tsf_info->current_tsf_lsb |
815 ((u64)tsf_info->current_tsf_msb << 32);
816
817out:
818 kfree(tsf_info);
819 return ret;
820}
821
822int wl1251_acx_statistics(struct wl1251 *wl, struct acx_statistics *stats)
823{
824 int ret;
825
826 wl1251_debug(DEBUG_ACX, "acx statistics");
827
828 ret = wl1251_cmd_interrogate(wl, ACX_STATISTICS, stats,
829 sizeof(*stats));
830 if (ret < 0) {
831 wl1251_warning("acx statistics failed: %d", ret);
832 return -ENOMEM;
833 }
834
835 return 0;
836}
837
838int wl1251_acx_rate_policies(struct wl1251 *wl)
839{
840 struct acx_rate_policy *acx;
841 int ret = 0;
842
843 wl1251_debug(DEBUG_ACX, "acx rate policies");
844
845 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
846 if (!acx)
847 return -ENOMEM;
848
849
850 acx->rate_class_cnt = 2;
851 acx->rate_class[0].enabled_rates = ACX_RATE_MASK_UNSPECIFIED;
852 acx->rate_class[0].short_retry_limit = ACX_RATE_RETRY_LIMIT;
853 acx->rate_class[0].long_retry_limit = ACX_RATE_RETRY_LIMIT;
854 acx->rate_class[0].aflags = 0;
855
856
857 acx->rate_class[1].enabled_rates = ACX_RATE_MASK_UNSPECIFIED;
858 acx->rate_class[1].short_retry_limit = 0;
859 acx->rate_class[1].long_retry_limit = 0;
860 acx->rate_class[1].aflags = 0;
861
862 ret = wl1251_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
863 if (ret < 0) {
864 wl1251_warning("Setting of rate policies failed: %d", ret);
865 goto out;
866 }
867
868out:
869 kfree(acx);
870 return ret;
871}
872
873int wl1251_acx_mem_cfg(struct wl1251 *wl)
874{
875 struct wl1251_acx_config_memory *mem_conf;
876 int ret, i;
877
878 wl1251_debug(DEBUG_ACX, "acx mem cfg");
879
880 mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
881 if (!mem_conf)
882 return -ENOMEM;
883
884
885 mem_conf->mem_config.num_stations = cpu_to_le16(DEFAULT_NUM_STATIONS);
886 mem_conf->mem_config.rx_mem_block_num = 35;
887 mem_conf->mem_config.tx_min_mem_block_num = 64;
888 mem_conf->mem_config.num_tx_queues = MAX_TX_QUEUES;
889 mem_conf->mem_config.host_if_options = HOSTIF_PKT_RING;
890 mem_conf->mem_config.num_ssid_profiles = 1;
891 mem_conf->mem_config.debug_buffer_size =
892 cpu_to_le16(TRACE_BUFFER_MAX_SIZE);
893
894
895 mem_conf->rx_queue_config.dma_address = 0;
896 mem_conf->rx_queue_config.num_descs = ACX_RX_DESC_DEF;
897 mem_conf->rx_queue_config.priority = DEFAULT_RXQ_PRIORITY;
898 mem_conf->rx_queue_config.type = DEFAULT_RXQ_TYPE;
899
900
901 for (i = 0; i < MAX_TX_QUEUES; i++) {
902 mem_conf->tx_queue_config[i].num_descs = ACX_TX_DESC_DEF;
903 mem_conf->tx_queue_config[i].attributes = i;
904 }
905
906 ret = wl1251_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
907 sizeof(*mem_conf));
908 if (ret < 0) {
909 wl1251_warning("wl1251 mem config failed: %d", ret);
910 goto out;
911 }
912
913out:
914 kfree(mem_conf);
915 return ret;
916}
917
918int wl1251_acx_wr_tbtt_and_dtim(struct wl1251 *wl, u16 tbtt, u8 dtim)
919{
920 struct wl1251_acx_wr_tbtt_and_dtim *acx;
921 int ret;
922
923 wl1251_debug(DEBUG_ACX, "acx tbtt and dtim");
924
925 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
926 if (!acx)
927 return -ENOMEM;
928
929 acx->tbtt = tbtt;
930 acx->dtim = dtim;
931
932 ret = wl1251_cmd_configure(wl, ACX_WR_TBTT_AND_DTIM,
933 acx, sizeof(*acx));
934 if (ret < 0) {
935 wl1251_warning("failed to set tbtt and dtim: %d", ret);
936 goto out;
937 }
938
939out:
940 kfree(acx);
941 return ret;
942}
943
944int wl1251_acx_bet_enable(struct wl1251 *wl, enum wl1251_acx_bet_mode mode,
945 u8 max_consecutive)
946{
947 struct wl1251_acx_bet_enable *acx;
948 int ret;
949
950 wl1251_debug(DEBUG_ACX, "acx bet enable");
951
952 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
953 if (!acx)
954 return -ENOMEM;
955
956 acx->enable = mode;
957 acx->max_consecutive = max_consecutive;
958
959 ret = wl1251_cmd_configure(wl, ACX_BET_ENABLE, acx, sizeof(*acx));
960 if (ret < 0) {
961 wl1251_warning("wl1251 acx bet enable failed: %d", ret);
962 goto out;
963 }
964
965out:
966 kfree(acx);
967 return ret;
968}
969
970int wl1251_acx_arp_ip_filter(struct wl1251 *wl, bool enable, __be32 address)
971{
972 struct wl1251_acx_arp_filter *acx;
973 int ret;
974
975 wl1251_debug(DEBUG_ACX, "acx arp ip filter, enable: %d", enable);
976
977 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
978 if (!acx)
979 return -ENOMEM;
980
981 acx->version = ACX_IPV4_VERSION;
982 acx->enable = enable;
983
984 if (enable)
985 memcpy(acx->address, &address, ACX_IPV4_ADDR_SIZE);
986
987 ret = wl1251_cmd_configure(wl, ACX_ARP_IP_FILTER,
988 acx, sizeof(*acx));
989 if (ret < 0)
990 wl1251_warning("failed to set arp ip filter: %d", ret);
991
992 kfree(acx);
993 return ret;
994}
995
996int wl1251_acx_ac_cfg(struct wl1251 *wl, u8 ac, u8 cw_min, u16 cw_max,
997 u8 aifs, u16 txop)
998{
999 struct wl1251_acx_ac_cfg *acx;
1000 int ret = 0;
1001
1002 wl1251_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d "
1003 "aifs %d txop %d", ac, cw_min, cw_max, aifs, txop);
1004
1005 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
1006 if (!acx)
1007 return -ENOMEM;
1008
1009 acx->ac = ac;
1010 acx->cw_min = cw_min;
1011 acx->cw_max = cw_max;
1012 acx->aifsn = aifs;
1013 acx->txop_limit = txop;
1014
1015 ret = wl1251_cmd_configure(wl, ACX_AC_CFG, acx, sizeof(*acx));
1016 if (ret < 0) {
1017 wl1251_warning("acx ac cfg failed: %d", ret);
1018 goto out;
1019 }
1020
1021out:
1022 kfree(acx);
1023 return ret;
1024}
1025
1026int wl1251_acx_tid_cfg(struct wl1251 *wl, u8 queue,
1027 enum wl1251_acx_channel_type type,
1028 u8 tsid, enum wl1251_acx_ps_scheme ps_scheme,
1029 enum wl1251_acx_ack_policy ack_policy)
1030{
1031 struct wl1251_acx_tid_cfg *acx;
1032 int ret = 0;
1033
1034 wl1251_debug(DEBUG_ACX, "acx tid cfg %d type %d tsid %d "
1035 "ps_scheme %d ack_policy %d", queue, type, tsid,
1036 ps_scheme, ack_policy);
1037
1038 acx = kzalloc(sizeof(*acx), GFP_KERNEL);
1039 if (!acx)
1040 return -ENOMEM;
1041
1042 acx->queue = queue;
1043 acx->type = type;
1044 acx->tsid = tsid;
1045 acx->ps_scheme = ps_scheme;
1046 acx->ack_policy = ack_policy;
1047
1048 ret = wl1251_cmd_configure(wl, ACX_TID_CFG, acx, sizeof(*acx));
1049 if (ret < 0) {
1050 wl1251_warning("acx tid cfg failed: %d", ret);
1051 goto out;
1052 }
1053
1054out:
1055 kfree(acx);
1056 return ret;
1057}
1058
