wl12xx: Fix incorrect warning message.
[linux-2.6.git] / drivers / net / wireless / wl12xx / acx.c
1 #include "acx.h"
2
3 #include <linux/module.h>
4 #include <linux/crc7.h>
5 #include <linux/spi/spi.h>
6
7 #include "wl12xx.h"
8 #include "wl12xx_80211.h"
9 #include "reg.h"
10 #include "spi.h"
11 #include "ps.h"
12
13 int wl12xx_acx_frame_rates(struct wl12xx *wl, u8 ctrl_rate, u8 ctrl_mod,
14                            u8 mgt_rate, u8 mgt_mod)
15 {
16         struct acx_fw_gen_frame_rates *rates;
17         int ret;
18
19         wl12xx_debug(DEBUG_ACX, "acx frame rates");
20
21         rates = kzalloc(sizeof(*rates), GFP_KERNEL);
22         if (!rates) {
23                 ret = -ENOMEM;
24                 goto out;
25         }
26
27         rates->tx_ctrl_frame_rate = ctrl_rate;
28         rates->tx_ctrl_frame_mod = ctrl_mod;
29         rates->tx_mgt_frame_rate = mgt_rate;
30         rates->tx_mgt_frame_mod = mgt_mod;
31
32         ret = wl12xx_cmd_configure(wl, ACX_FW_GEN_FRAME_RATES,
33                                    rates, sizeof(*rates));
34         if (ret < 0) {
35                 wl12xx_error("Failed to set FW rates and modulation");
36                 goto out;
37         }
38
39 out:
40         kfree(rates);
41         return ret;
42 }
43
44
45 int wl12xx_acx_station_id(struct wl12xx *wl)
46 {
47         struct acx_dot11_station_id *mac;
48         int ret, i;
49
50         wl12xx_debug(DEBUG_ACX, "acx dot11_station_id");
51
52         mac = kzalloc(sizeof(*mac), GFP_KERNEL);
53         if (!mac) {
54                 ret = -ENOMEM;
55                 goto out;
56         }
57
58         for (i = 0; i < ETH_ALEN; i++)
59                 mac->mac[i] = wl->mac_addr[ETH_ALEN - 1 - i];
60
61         ret = wl12xx_cmd_configure(wl, DOT11_STATION_ID, mac, sizeof(*mac));
62         if (ret < 0)
63                 goto out;
64
65 out:
66         kfree(mac);
67         return ret;
68 }
69
70 int wl12xx_acx_default_key(struct wl12xx *wl, u8 key_id)
71 {
72         struct acx_dot11_default_key *default_key;
73         int ret;
74
75         wl12xx_debug(DEBUG_ACX, "acx dot11_default_key (%d)", key_id);
76
77         default_key = kzalloc(sizeof(*default_key), GFP_KERNEL);
78         if (!default_key) {
79                 ret = -ENOMEM;
80                 goto out;
81         }
82
83         default_key->id = key_id;
84
85         ret = wl12xx_cmd_configure(wl, DOT11_DEFAULT_KEY,
86                                    default_key, sizeof(*default_key));
87         if (ret < 0) {
88                 wl12xx_error("Couldnt set default key");
89                 goto out;
90         }
91
92         wl->default_key = key_id;
93
94 out:
95         kfree(default_key);
96         return ret;
97 }
98
99 int wl12xx_acx_wake_up_conditions(struct wl12xx *wl, u8 wake_up_event,
100                                   u8 listen_interval)
101 {
102         struct acx_wake_up_condition *wake_up;
103         int ret;
104
105         wl12xx_debug(DEBUG_ACX, "acx wake up conditions");
106
107         wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
108         if (!wake_up) {
109                 ret = -ENOMEM;
110                 goto out;
111         }
112
113         wake_up->wake_up_event = wake_up_event;
114         wake_up->listen_interval = listen_interval;
115
116         ret = wl12xx_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
117                                    wake_up, sizeof(*wake_up));
118         if (ret < 0) {
119                 wl12xx_warning("could not set wake up conditions: %d", ret);
120                 goto out;
121         }
122
123 out:
124         kfree(wake_up);
125         return ret;
126 }
127
128 int wl12xx_acx_sleep_auth(struct wl12xx *wl, u8 sleep_auth)
129 {
130         struct acx_sleep_auth *auth;
131         int ret;
132
133         wl12xx_debug(DEBUG_ACX, "acx sleep auth");
134
135         auth = kzalloc(sizeof(*auth), GFP_KERNEL);
136         if (!auth) {
137                 ret = -ENOMEM;
138                 goto out;
139         }
140
141         auth->sleep_auth = sleep_auth;
142
143         ret = wl12xx_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
144         if (ret < 0)
145                 return ret;
146
147 out:
148         kfree(auth);
149         return ret;
150 }
151
152 int wl12xx_acx_fw_version(struct wl12xx *wl, char *buf, size_t len)
153 {
154         struct acx_revision *rev;
155         int ret;
156
157         wl12xx_debug(DEBUG_ACX, "acx fw rev");
158
159         rev = kzalloc(sizeof(*rev), GFP_KERNEL);
160         if (!rev) {
161                 ret = -ENOMEM;
162                 goto out;
163         }
164
165         ret = wl12xx_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
166         if (ret < 0) {
167                 wl12xx_warning("ACX_FW_REV interrogate failed");
168                 goto out;
169         }
170
171         /* be careful with the buffer sizes */
172         strncpy(buf, rev->fw_version, min(len, sizeof(rev->fw_version)));
173
174         /*
175          * if the firmware version string is exactly
176          * sizeof(rev->fw_version) long or fw_len is less than
177          * sizeof(rev->fw_version) it won't be null terminated
178          */
179         buf[min(len, sizeof(rev->fw_version)) - 1] = '\0';
180
181 out:
182         kfree(rev);
183         return ret;
184 }
185
186 int wl12xx_acx_tx_power(struct wl12xx *wl, int power)
187 {
188         struct acx_current_tx_power *acx;
189         int ret;
190
191         wl12xx_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
192
193         if (power < 0 || power > 25)
194                 return -EINVAL;
195
196         acx = kzalloc(sizeof(*acx), GFP_KERNEL);
197         if (!acx) {
198                 ret = -ENOMEM;
199                 goto out;
200         }
201
202         acx->current_tx_power = power * 10;
203
204         ret = wl12xx_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
205         if (ret < 0) {
206                 wl12xx_warning("configure of tx power failed: %d", ret);
207                 goto out;
208         }
209
210 out:
211         kfree(acx);
212         return ret;
213 }
214
215 int wl12xx_acx_feature_cfg(struct wl12xx *wl)
216 {
217         struct acx_feature_config *feature;
218         int ret;
219
220         wl12xx_debug(DEBUG_ACX, "acx feature cfg");
221
222         feature = kzalloc(sizeof(*feature), GFP_KERNEL);
223         if (!feature) {
224                 ret = -ENOMEM;
225                 goto out;
226         }
227
228         /* DF_ENCRYPTION_DISABLE and DF_SNIFF_MODE_ENABLE are disabled */
229         feature->data_flow_options = 0;
230         feature->options = 0;
231
232         ret = wl12xx_cmd_configure(wl, ACX_FEATURE_CFG,
233                                    feature, sizeof(*feature));
234         if (ret < 0) {
235                 wl12xx_error("Couldnt set HW encryption");
236                 goto out;
237         }
238
239 out:
240         kfree(feature);
241         return ret;
242 }
243
244 int wl12xx_acx_mem_map(struct wl12xx *wl, struct acx_header *mem_map,
245                        size_t len)
246 {
247         int ret;
248
249         wl12xx_debug(DEBUG_ACX, "acx mem map");
250
251         ret = wl12xx_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
252         if (ret < 0)
253                 return ret;
254
255         return 0;
256 }
257
258 int wl12xx_acx_data_path_params(struct wl12xx *wl,
259                                 struct acx_data_path_params_resp *resp)
260 {
261         struct acx_data_path_params *params;
262         int ret;
263
264         wl12xx_debug(DEBUG_ACX, "acx data path params");
265
266         params = kzalloc(sizeof(*params), GFP_KERNEL);
267         if (!params) {
268                 ret = -ENOMEM;
269                 goto out;
270         }
271
272         params->rx_packet_ring_chunk_size = DP_RX_PACKET_RING_CHUNK_SIZE;
273         params->tx_packet_ring_chunk_size = DP_TX_PACKET_RING_CHUNK_SIZE;
274
275         params->rx_packet_ring_chunk_num = DP_RX_PACKET_RING_CHUNK_NUM;
276         params->tx_packet_ring_chunk_num = DP_TX_PACKET_RING_CHUNK_NUM;
277
278         params->tx_complete_threshold = 1;
279
280         params->tx_complete_ring_depth = FW_TX_CMPLT_BLOCK_SIZE;
281
282         params->tx_complete_timeout = DP_TX_COMPLETE_TIME_OUT;
283
284         ret = wl12xx_cmd_configure(wl, ACX_DATA_PATH_PARAMS,
285                                    params, sizeof(*params));
286         if (ret < 0)
287                 goto out;
288
289         /* FIXME: shouldn't this be ACX_DATA_PATH_RESP_PARAMS? */
290         ret = wl12xx_cmd_interrogate(wl, ACX_DATA_PATH_PARAMS,
291                                      resp, sizeof(*resp));
292
293         if (ret < 0) {
294                 wl12xx_warning("failed to read data path parameters: %d", ret);
295                 goto out;
296         } else if (resp->header.cmd.status != CMD_STATUS_SUCCESS) {
297                 wl12xx_warning("data path parameter acx status failed");
298                 ret = -EIO;
299                 goto out;
300         }
301
302 out:
303         kfree(params);
304         return ret;
305 }
306
307 int wl12xx_acx_rx_msdu_life_time(struct wl12xx *wl, u32 life_time)
308 {
309         struct acx_rx_msdu_lifetime *acx;
310         int ret;
311
312         wl12xx_debug(DEBUG_ACX, "acx rx msdu life time");
313
314         acx = kzalloc(sizeof(*acx), GFP_KERNEL);
315         if (!acx) {
316                 ret = -ENOMEM;
317                 goto out;
318         }
319
320         ret = wl12xx_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
321                                    acx, sizeof(*acx));
322         if (ret < 0) {
323                 wl12xx_warning("failed to set rx msdu life time: %d", ret);
324                 goto out;
325         }
326
327 out:
328         kfree(acx);
329         return ret;
330 }
331
332 int wl12xx_acx_rx_config(struct wl12xx *wl, u32 config, u32 filter)
333 {
334         struct acx_rx_config *rx_config;
335         int ret;
336
337         wl12xx_debug(DEBUG_ACX, "acx rx config");
338
339         rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
340         if (!rx_config) {
341                 ret = -ENOMEM;
342                 goto out;
343         }
344
345         rx_config->config_options = config;
346         rx_config->filter_options = filter;
347
348         ret = wl12xx_cmd_configure(wl, ACX_RX_CFG,
349                                    rx_config, sizeof(*rx_config));
350         if (ret < 0) {
351                 wl12xx_warning("failed to set rx config: %d", ret);
352                 goto out;
353         }
354
355 out:
356         kfree(rx_config);
357         return ret;
358 }
359
360 int wl12xx_acx_pd_threshold(struct wl12xx *wl)
361 {
362         struct acx_packet_detection *pd;
363         int ret;
364
365         wl12xx_debug(DEBUG_ACX, "acx data pd threshold");
366
367         pd = kzalloc(sizeof(*pd), GFP_KERNEL);
368         if (!pd) {
369                 ret = -ENOMEM;
370                 goto out;
371         }
372
373         /* FIXME: threshold value not set */
374
375         ret = wl12xx_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
376         if (ret < 0) {
377                 wl12xx_warning("failed to set pd threshold: %d", ret);
378                 goto out;
379         }
380
381 out:
382         kfree(pd);
383         return 0;
384 }
385
386 int wl12xx_acx_slot(struct wl12xx *wl, enum acx_slot_type slot_time)
387 {
388         struct acx_slot *slot;
389         int ret;
390
391         wl12xx_debug(DEBUG_ACX, "acx slot");
392
393         slot = kzalloc(sizeof(*slot), GFP_KERNEL);
394         if (!slot) {
395                 ret = -ENOMEM;
396                 goto out;
397         }
398
399         slot->wone_index = STATION_WONE_INDEX;
400         slot->slot_time = slot_time;
401
402         ret = wl12xx_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
403         if (ret < 0) {
404                 wl12xx_warning("failed to set slot time: %d", ret);
405                 goto out;
406         }
407
408 out:
409         kfree(slot);
410         return ret;
411 }
412
413 int wl12xx_acx_group_address_tbl(struct wl12xx *wl)
414 {
415         struct acx_dot11_grp_addr_tbl *acx;
416         int ret;
417
418         wl12xx_debug(DEBUG_ACX, "acx group address tbl");
419
420         acx = kzalloc(sizeof(*acx), GFP_KERNEL);
421         if (!acx) {
422                 ret = -ENOMEM;
423                 goto out;
424         }
425
426         /* MAC filtering */
427         acx->enabled = 0;
428         acx->num_groups = 0;
429         memset(acx->mac_table, 0, ADDRESS_GROUP_MAX_LEN);
430
431         ret = wl12xx_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
432                                    acx, sizeof(*acx));
433         if (ret < 0) {
434                 wl12xx_warning("failed to set group addr table: %d", ret);
435                 goto out;
436         }
437
438 out:
439         kfree(acx);
440         return ret;
441 }
442
443 int wl12xx_acx_service_period_timeout(struct wl12xx *wl)
444 {
445         struct acx_rx_timeout *rx_timeout;
446         int ret;
447
448         rx_timeout = kzalloc(sizeof(*rx_timeout), GFP_KERNEL);
449         if (!rx_timeout) {
450                 ret = -ENOMEM;
451                 goto out;
452         }
453
454         wl12xx_debug(DEBUG_ACX, "acx service period timeout");
455
456         rx_timeout->ps_poll_timeout = RX_TIMEOUT_PS_POLL_DEF;
457         rx_timeout->upsd_timeout = RX_TIMEOUT_UPSD_DEF;
458
459         ret = wl12xx_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
460                                    rx_timeout, sizeof(*rx_timeout));
461         if (ret < 0) {
462                 wl12xx_warning("failed to set service period timeout: %d",
463                                ret);
464                 goto out;
465         }
466
467 out:
468         kfree(rx_timeout);
469         return ret;
470 }
471
472 int wl12xx_acx_rts_threshold(struct wl12xx *wl, u16 rts_threshold)
473 {
474         struct acx_rts_threshold *rts;
475         int ret;
476
477         wl12xx_debug(DEBUG_ACX, "acx rts threshold");
478
479         rts = kzalloc(sizeof(*rts), GFP_KERNEL);
480         if (!rts) {
481                 ret = -ENOMEM;
482                 goto out;
483         }
484
485         rts->threshold = rts_threshold;
486
487         ret = wl12xx_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
488         if (ret < 0) {
489                 wl12xx_warning("failed to set rts threshold: %d", ret);
490                 goto out;
491         }
492
493 out:
494         kfree(rts);
495         return ret;
496 }
497
498 int wl12xx_acx_beacon_filter_opt(struct wl12xx *wl)
499 {
500         struct acx_beacon_filter_option *beacon_filter;
501         int ret;
502
503         wl12xx_debug(DEBUG_ACX, "acx beacon filter opt");
504
505         beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
506         if (!beacon_filter) {
507                 ret = -ENOMEM;
508                 goto out;
509         }
510
511         beacon_filter->enable = 0;
512         beacon_filter->max_num_beacons = 0;
513
514         ret = wl12xx_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
515                                    beacon_filter, sizeof(*beacon_filter));
516         if (ret < 0) {
517                 wl12xx_warning("failed to set beacon filter opt: %d", ret);
518                 goto out;
519         }
520
521 out:
522         kfree(beacon_filter);
523         return ret;
524 }
525
526 int wl12xx_acx_beacon_filter_table(struct wl12xx *wl)
527 {
528         struct acx_beacon_filter_ie_table *ie_table;
529         int ret;
530
531         wl12xx_debug(DEBUG_ACX, "acx beacon filter table");
532
533         ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
534         if (!ie_table) {
535                 ret = -ENOMEM;
536                 goto out;
537         }
538
539         ie_table->num_ie = 0;
540         memset(ie_table->table, 0, BEACON_FILTER_TABLE_MAX_SIZE);
541
542         ret = wl12xx_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
543                                    ie_table, sizeof(*ie_table));
544         if (ret < 0) {
545                 wl12xx_warning("failed to set beacon filter table: %d", ret);
546                 goto out;
547         }
548
549 out:
550         kfree(ie_table);
551         return ret;
552 }
553
554 int wl12xx_acx_sg_enable(struct wl12xx *wl)
555 {
556         struct acx_bt_wlan_coex *pta;
557         int ret;
558
559         wl12xx_debug(DEBUG_ACX, "acx sg enable");
560
561         pta = kzalloc(sizeof(*pta), GFP_KERNEL);
562         if (!pta) {
563                 ret = -ENOMEM;
564                 goto out;
565         }
566
567         pta->enable = SG_ENABLE;
568
569         ret = wl12xx_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
570         if (ret < 0) {
571                 wl12xx_warning("failed to set softgemini enable: %d", ret);
572                 goto out;
573         }
574
575 out:
576         kfree(pta);
577         return ret;
578 }
579
580 int wl12xx_acx_sg_cfg(struct wl12xx *wl)
581 {
582         struct acx_bt_wlan_coex_param *param;
583         int ret;
584
585         wl12xx_debug(DEBUG_ACX, "acx sg cfg");
586
587         param = kzalloc(sizeof(*param), GFP_KERNEL);
588         if (!param) {
589                 ret = -ENOMEM;
590                 goto out;
591         }
592
593         /* BT-WLAN coext parameters */
594         param->min_rate = RATE_INDEX_24MBPS;
595         param->bt_hp_max_time = PTA_BT_HP_MAXTIME_DEF;
596         param->wlan_hp_max_time = PTA_WLAN_HP_MAX_TIME_DEF;
597         param->sense_disable_timer = PTA_SENSE_DISABLE_TIMER_DEF;
598         param->rx_time_bt_hp = PTA_PROTECTIVE_RX_TIME_DEF;
599         param->tx_time_bt_hp = PTA_PROTECTIVE_TX_TIME_DEF;
600         param->rx_time_bt_hp_fast = PTA_PROTECTIVE_RX_TIME_FAST_DEF;
601         param->tx_time_bt_hp_fast = PTA_PROTECTIVE_TX_TIME_FAST_DEF;
602         param->wlan_cycle_fast = PTA_CYCLE_TIME_FAST_DEF;
603         param->bt_anti_starvation_period = PTA_ANTI_STARVE_PERIOD_DEF;
604         param->next_bt_lp_packet = PTA_TIMEOUT_NEXT_BT_LP_PACKET_DEF;
605         param->wake_up_beacon = PTA_TIME_BEFORE_BEACON_DEF;
606         param->hp_dm_max_guard_time = PTA_HPDM_MAX_TIME_DEF;
607         param->next_wlan_packet = PTA_TIME_OUT_NEXT_WLAN_DEF;
608         param->antenna_type = PTA_ANTENNA_TYPE_DEF;
609         param->signal_type = PTA_SIGNALING_TYPE_DEF;
610         param->afh_leverage_on = PTA_AFH_LEVERAGE_ON_DEF;
611         param->quiet_cycle_num = PTA_NUMBER_QUIET_CYCLE_DEF;
612         param->max_cts = PTA_MAX_NUM_CTS_DEF;
613         param->wlan_packets_num = PTA_NUMBER_OF_WLAN_PACKETS_DEF;
614         param->bt_packets_num = PTA_NUMBER_OF_BT_PACKETS_DEF;
615         param->missed_rx_avalanche = PTA_RX_FOR_AVALANCHE_DEF;
616         param->wlan_elp_hp = PTA_ELP_HP_DEF;
617         param->bt_anti_starvation_cycles = PTA_ANTI_STARVE_NUM_CYCLE_DEF;
618         param->ack_mode_dual_ant = PTA_ACK_MODE_DEF;
619         param->pa_sd_enable = PTA_ALLOW_PA_SD_DEF;
620         param->pta_auto_mode_enable = PTA_AUTO_MODE_NO_CTS_DEF;
621         param->bt_hp_respected_num = PTA_BT_HP_RESPECTED_DEF;
622
623         ret = wl12xx_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
624         if (ret < 0) {
625                 wl12xx_warning("failed to set sg config: %d", ret);
626                 goto out;
627         }
628
629 out:
630         kfree(param);
631         return ret;
632 }
633
634 int wl12xx_acx_cca_threshold(struct wl12xx *wl)
635 {
636         struct acx_energy_detection *detection;
637         int ret;
638
639         wl12xx_debug(DEBUG_ACX, "acx cca threshold");
640
641         detection = kzalloc(sizeof(*detection), GFP_KERNEL);
642         if (!detection) {
643                 ret = -ENOMEM;
644                 goto out;
645         }
646
647         detection->rx_cca_threshold = CCA_THRSH_DISABLE_ENERGY_D;
648         detection->tx_energy_detection = 0;
649
650         ret = wl12xx_cmd_configure(wl, ACX_CCA_THRESHOLD,
651                                    detection, sizeof(*detection));
652         if (ret < 0) {
653                 wl12xx_warning("failed to set cca threshold: %d", ret);
654                 return ret;
655         }
656
657 out:
658         kfree(detection);
659         return ret;
660 }
661
662 int wl12xx_acx_bcn_dtim_options(struct wl12xx *wl)
663 {
664         struct acx_beacon_broadcast *bb;
665         int ret;
666
667         wl12xx_debug(DEBUG_ACX, "acx bcn dtim options");
668
669         bb = kzalloc(sizeof(*bb), GFP_KERNEL);
670         if (!bb) {
671                 ret = -ENOMEM;
672                 goto out;
673         }
674
675         bb->beacon_rx_timeout = BCN_RX_TIMEOUT_DEF_VALUE;
676         bb->broadcast_timeout = BROADCAST_RX_TIMEOUT_DEF_VALUE;
677         bb->rx_broadcast_in_ps = RX_BROADCAST_IN_PS_DEF_VALUE;
678         bb->ps_poll_threshold = CONSECUTIVE_PS_POLL_FAILURE_DEF;
679
680         ret = wl12xx_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
681         if (ret < 0) {
682                 wl12xx_warning("failed to set rx config: %d", ret);
683                 goto out;
684         }
685
686 out:
687         kfree(bb);
688         return ret;
689 }
690
691 int wl12xx_acx_aid(struct wl12xx *wl, u16 aid)
692 {
693         struct acx_aid *acx_aid;
694         int ret;
695
696         wl12xx_debug(DEBUG_ACX, "acx aid");
697
698         acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
699         if (!acx_aid) {
700                 ret = -ENOMEM;
701                 goto out;
702         }
703
704         acx_aid->aid = aid;
705
706         ret = wl12xx_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
707         if (ret < 0) {
708                 wl12xx_warning("failed to set aid: %d", ret);
709                 goto out;
710         }
711
712 out:
713         kfree(acx_aid);
714         return ret;
715 }
716
717 int wl12xx_acx_event_mbox_mask(struct wl12xx *wl, u32 event_mask)
718 {
719         struct acx_event_mask *mask;
720         int ret;
721
722         wl12xx_debug(DEBUG_ACX, "acx event mbox mask");
723
724         mask = kzalloc(sizeof(*mask), GFP_KERNEL);
725         if (!mask) {
726                 ret = -ENOMEM;
727                 goto out;
728         }
729
730         /* high event mask is unused */
731         mask->high_event_mask = 0xffffffff;
732
733         mask->event_mask = event_mask;
734
735         ret = wl12xx_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
736                                    mask, sizeof(*mask));
737         if (ret < 0) {
738                 wl12xx_warning("failed to set acx_event_mbox_mask: %d", ret);
739                 goto out;
740         }
741
742 out:
743         kfree(mask);
744         return ret;
745 }
746
747 int wl12xx_acx_set_preamble(struct wl12xx *wl, enum acx_preamble_type preamble)
748 {
749         struct acx_preamble *acx;
750         int ret;
751
752         wl12xx_debug(DEBUG_ACX, "acx_set_preamble");
753
754         acx = kzalloc(sizeof(*acx), GFP_KERNEL);
755         if (!acx) {
756                 ret = -ENOMEM;
757                 goto out;
758         }
759
760         acx->preamble = preamble;
761
762         ret = wl12xx_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
763         if (ret < 0) {
764                 wl12xx_warning("Setting of preamble failed: %d", ret);
765                 goto out;
766         }
767
768 out:
769         kfree(acx);
770         return ret;
771 }
772
773 int wl12xx_acx_cts_protect(struct wl12xx *wl,
774                            enum acx_ctsprotect_type ctsprotect)
775 {
776         struct acx_ctsprotect *acx;
777         int ret;
778
779         wl12xx_debug(DEBUG_ACX, "acx_set_ctsprotect");
780
781         acx = kzalloc(sizeof(*acx), GFP_KERNEL);
782         if (!acx) {
783                 ret = -ENOMEM;
784                 goto out;
785         }
786
787         acx->ctsprotect = ctsprotect;
788
789         ret = wl12xx_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
790         if (ret < 0) {
791                 wl12xx_warning("Setting of ctsprotect failed: %d", ret);
792                 goto out;
793         }
794
795 out:
796         kfree(acx);
797         return ret;
798 }
799
800 int wl12xx_acx_tsf_info(struct wl12xx *wl, u64 *mactime)
801 {
802         struct acx_tsf_info *tsf_info;
803         int ret;
804
805         tsf_info = kzalloc(sizeof(*tsf_info), GFP_KERNEL);
806         if (!tsf_info) {
807                 ret = -ENOMEM;
808                 goto out;
809         }
810
811         ret = wl12xx_cmd_interrogate(wl, ACX_TSF_INFO,
812                                      tsf_info, sizeof(*tsf_info));
813         if (ret < 0) {
814                 wl12xx_warning("ACX_FW_REV interrogate failed");
815                 goto out;
816         }
817
818         *mactime = tsf_info->current_tsf_lsb |
819                 (tsf_info->current_tsf_msb << 31);
820
821 out:
822         kfree(tsf_info);
823         return ret;
824 }
825
826 int wl12xx_acx_statistics(struct wl12xx *wl, struct acx_statistics *stats)
827 {
828         int ret;
829
830         wl12xx_debug(DEBUG_ACX, "acx statistics");
831
832         ret = wl12xx_cmd_interrogate(wl, ACX_STATISTICS, stats,
833                                      sizeof(*stats));
834         if (ret < 0) {
835                 wl12xx_warning("acx statistics failed: %d", ret);
836                 return -ENOMEM;
837         }
838
839         return 0;
840 }