2 * This file is part of wl1271
4 * Copyright (C) 2008-2009 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include "wl1271_acx.h"
26 #include <linux/module.h>
27 #include <linux/platform_device.h>
28 #include <linux/crc7.h>
29 #include <linux/spi/spi.h>
32 #include "wl12xx_80211.h"
33 #include "wl1271_reg.h"
34 #include "wl1271_spi.h"
35 #include "wl1271_ps.h"
37 int wl1271_acx_wake_up_conditions(struct wl1271
*wl
)
39 struct acx_wake_up_condition
*wake_up
;
42 wl1271_debug(DEBUG_ACX
, "acx wake up conditions");
44 wake_up
= kzalloc(sizeof(*wake_up
), GFP_KERNEL
);
50 wake_up
->wake_up_event
= wl
->conf
.conn
.wake_up_event
;
51 wake_up
->listen_interval
= wl
->conf
.conn
.listen_interval
;
53 ret
= wl1271_cmd_configure(wl
, ACX_WAKE_UP_CONDITIONS
,
54 wake_up
, sizeof(*wake_up
));
56 wl1271_warning("could not set wake up conditions: %d", ret
);
65 int wl1271_acx_sleep_auth(struct wl1271
*wl
, u8 sleep_auth
)
67 struct acx_sleep_auth
*auth
;
70 wl1271_debug(DEBUG_ACX
, "acx sleep auth");
72 auth
= kzalloc(sizeof(*auth
), GFP_KERNEL
);
78 auth
->sleep_auth
= sleep_auth
;
80 ret
= wl1271_cmd_configure(wl
, ACX_SLEEP_AUTH
, auth
, sizeof(*auth
));
89 int wl1271_acx_fw_version(struct wl1271
*wl
, char *buf
, size_t len
)
91 struct acx_revision
*rev
;
94 wl1271_debug(DEBUG_ACX
, "acx fw rev");
96 rev
= kzalloc(sizeof(*rev
), GFP_KERNEL
);
102 ret
= wl1271_cmd_interrogate(wl
, ACX_FW_REV
, rev
, sizeof(*rev
));
104 wl1271_warning("ACX_FW_REV interrogate failed");
108 /* be careful with the buffer sizes */
109 strncpy(buf
, rev
->fw_version
, min(len
, sizeof(rev
->fw_version
)));
112 * if the firmware version string is exactly
113 * sizeof(rev->fw_version) long or fw_len is less than
114 * sizeof(rev->fw_version) it won't be null terminated
116 buf
[min(len
, sizeof(rev
->fw_version
)) - 1] = '\0';
123 int wl1271_acx_tx_power(struct wl1271
*wl
, int power
)
125 struct acx_current_tx_power
*acx
;
128 wl1271_debug(DEBUG_ACX
, "acx dot11_cur_tx_pwr");
130 if (power
< 0 || power
> 25)
133 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
140 * FIXME: This is a workaround needed while we don't the correct
141 * calibration, to avoid distortions
143 /* acx->current_tx_power = power * 10; */
144 acx
->current_tx_power
= 70;
146 ret
= wl1271_cmd_configure(wl
, DOT11_CUR_TX_PWR
, acx
, sizeof(*acx
));
148 wl1271_warning("configure of tx power failed: %d", ret
);
157 int wl1271_acx_feature_cfg(struct wl1271
*wl
)
159 struct acx_feature_config
*feature
;
162 wl1271_debug(DEBUG_ACX
, "acx feature cfg");
164 feature
= kzalloc(sizeof(*feature
), GFP_KERNEL
);
170 /* DF_ENCRYPTION_DISABLE and DF_SNIFF_MODE_ENABLE are disabled */
171 feature
->data_flow_options
= 0;
172 feature
->options
= 0;
174 ret
= wl1271_cmd_configure(wl
, ACX_FEATURE_CFG
,
175 feature
, sizeof(*feature
));
177 wl1271_error("Couldnt set HW encryption");
186 int wl1271_acx_mem_map(struct wl1271
*wl
, struct acx_header
*mem_map
,
191 wl1271_debug(DEBUG_ACX
, "acx mem map");
193 ret
= wl1271_cmd_interrogate(wl
, ACX_MEM_MAP
, mem_map
, len
);
200 int wl1271_acx_rx_msdu_life_time(struct wl1271
*wl
)
202 struct acx_rx_msdu_lifetime
*acx
;
205 wl1271_debug(DEBUG_ACX
, "acx rx msdu life time");
207 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
213 acx
->lifetime
= cpu_to_le32(wl
->conf
.rx
.rx_msdu_life_time
);
214 ret
= wl1271_cmd_configure(wl
, DOT11_RX_MSDU_LIFE_TIME
,
217 wl1271_warning("failed to set rx msdu life time: %d", ret
);
226 int wl1271_acx_rx_config(struct wl1271
*wl
, u32 config
, u32 filter
)
228 struct acx_rx_config
*rx_config
;
231 wl1271_debug(DEBUG_ACX
, "acx rx config");
233 rx_config
= kzalloc(sizeof(*rx_config
), GFP_KERNEL
);
239 rx_config
->config_options
= cpu_to_le32(config
);
240 rx_config
->filter_options
= cpu_to_le32(filter
);
242 ret
= wl1271_cmd_configure(wl
, ACX_RX_CFG
,
243 rx_config
, sizeof(*rx_config
));
245 wl1271_warning("failed to set rx config: %d", ret
);
254 int wl1271_acx_pd_threshold(struct wl1271
*wl
)
256 struct acx_packet_detection
*pd
;
259 wl1271_debug(DEBUG_ACX
, "acx data pd threshold");
261 pd
= kzalloc(sizeof(*pd
), GFP_KERNEL
);
267 pd
->threshold
= cpu_to_le32(wl
->conf
.rx
.packet_detection_threshold
);
269 ret
= wl1271_cmd_configure(wl
, ACX_PD_THRESHOLD
, pd
, sizeof(*pd
));
271 wl1271_warning("failed to set pd threshold: %d", ret
);
280 int wl1271_acx_slot(struct wl1271
*wl
, enum acx_slot_type slot_time
)
282 struct acx_slot
*slot
;
285 wl1271_debug(DEBUG_ACX
, "acx slot");
287 slot
= kzalloc(sizeof(*slot
), GFP_KERNEL
);
293 slot
->wone_index
= STATION_WONE_INDEX
;
294 slot
->slot_time
= slot_time
;
296 ret
= wl1271_cmd_configure(wl
, ACX_SLOT
, slot
, sizeof(*slot
));
298 wl1271_warning("failed to set slot time: %d", ret
);
307 int wl1271_acx_group_address_tbl(struct wl1271
*wl
, bool enable
,
308 void *mc_list
, u32 mc_list_len
)
310 struct acx_dot11_grp_addr_tbl
*acx
;
313 wl1271_debug(DEBUG_ACX
, "acx group address tbl");
315 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
322 acx
->enabled
= enable
;
323 acx
->num_groups
= mc_list_len
;
324 memcpy(acx
->mac_table
, mc_list
, mc_list_len
* ETH_ALEN
);
326 ret
= wl1271_cmd_configure(wl
, DOT11_GROUP_ADDRESS_TBL
,
329 wl1271_warning("failed to set group addr table: %d", ret
);
338 int wl1271_acx_service_period_timeout(struct wl1271
*wl
)
340 struct acx_rx_timeout
*rx_timeout
;
343 rx_timeout
= kzalloc(sizeof(*rx_timeout
), GFP_KERNEL
);
349 wl1271_debug(DEBUG_ACX
, "acx service period timeout");
351 rx_timeout
->ps_poll_timeout
= cpu_to_le16(wl
->conf
.rx
.ps_poll_timeout
);
352 rx_timeout
->upsd_timeout
= cpu_to_le16(wl
->conf
.rx
.upsd_timeout
);
354 ret
= wl1271_cmd_configure(wl
, ACX_SERVICE_PERIOD_TIMEOUT
,
355 rx_timeout
, sizeof(*rx_timeout
));
357 wl1271_warning("failed to set service period timeout: %d",
367 int wl1271_acx_rts_threshold(struct wl1271
*wl
, u16 rts_threshold
)
369 struct acx_rts_threshold
*rts
;
372 wl1271_debug(DEBUG_ACX
, "acx rts threshold");
374 rts
= kzalloc(sizeof(*rts
), GFP_KERNEL
);
380 rts
->threshold
= cpu_to_le16(rts_threshold
);
382 ret
= wl1271_cmd_configure(wl
, DOT11_RTS_THRESHOLD
, rts
, sizeof(*rts
));
384 wl1271_warning("failed to set rts threshold: %d", ret
);
393 int wl1271_acx_beacon_filter_opt(struct wl1271
*wl
, bool enable_filter
)
395 struct acx_beacon_filter_option
*beacon_filter
= NULL
;
398 wl1271_debug(DEBUG_ACX
, "acx beacon filter opt");
401 wl
->conf
.conn
.bcn_filt_mode
== CONF_BCN_FILT_MODE_DISABLED
)
404 beacon_filter
= kzalloc(sizeof(*beacon_filter
), GFP_KERNEL
);
405 if (!beacon_filter
) {
410 beacon_filter
->enable
= enable_filter
;
413 * When set to zero, and the filter is enabled, beacons
414 * without the unicast TIM bit set are dropped.
416 beacon_filter
->max_num_beacons
= 0;
418 ret
= wl1271_cmd_configure(wl
, ACX_BEACON_FILTER_OPT
,
419 beacon_filter
, sizeof(*beacon_filter
));
421 wl1271_warning("failed to set beacon filter opt: %d", ret
);
426 kfree(beacon_filter
);
430 int wl1271_acx_beacon_filter_table(struct wl1271
*wl
)
432 struct acx_beacon_filter_ie_table
*ie_table
;
435 bool vendor_spec
= false;
437 wl1271_debug(DEBUG_ACX
, "acx beacon filter table");
439 ie_table
= kzalloc(sizeof(*ie_table
), GFP_KERNEL
);
445 /* configure default beacon pass-through rules */
446 ie_table
->num_ie
= 0;
447 for (i
= 0; i
< wl
->conf
.conn
.bcn_filt_ie_count
; i
++) {
448 struct conf_bcn_filt_rule
*r
= &(wl
->conf
.conn
.bcn_filt_ie
[i
]);
449 ie_table
->table
[idx
++] = r
->ie
;
450 ie_table
->table
[idx
++] = r
->rule
;
452 if (r
->ie
== WLAN_EID_VENDOR_SPECIFIC
) {
453 /* only one vendor specific ie allowed */
457 /* for vendor specific rules configure the
459 memcpy(&(ie_table
->table
[idx
]), r
->oui
,
460 CONF_BCN_IE_OUI_LEN
);
461 idx
+= CONF_BCN_IE_OUI_LEN
;
462 ie_table
->table
[idx
++] = r
->type
;
463 memcpy(&(ie_table
->table
[idx
]), r
->version
,
464 CONF_BCN_IE_VER_LEN
);
465 idx
+= CONF_BCN_IE_VER_LEN
;
472 ret
= wl1271_cmd_configure(wl
, ACX_BEACON_FILTER_TABLE
,
473 ie_table
, sizeof(*ie_table
));
475 wl1271_warning("failed to set beacon filter table: %d", ret
);
484 int wl1271_acx_conn_monit_params(struct wl1271
*wl
)
486 struct acx_conn_monit_params
*acx
;
489 wl1271_debug(DEBUG_ACX
, "acx connection monitor parameters");
491 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
497 acx
->synch_fail_thold
= cpu_to_le32(wl
->conf
.conn
.synch_fail_thold
);
498 acx
->bss_lose_timeout
= cpu_to_le32(wl
->conf
.conn
.bss_lose_timeout
);
500 ret
= wl1271_cmd_configure(wl
, ACX_CONN_MONIT_PARAMS
,
503 wl1271_warning("failed to set connection monitor "
504 "parameters: %d", ret
);
514 int wl1271_acx_sg_enable(struct wl1271
*wl
)
516 struct acx_bt_wlan_coex
*pta
;
519 wl1271_debug(DEBUG_ACX
, "acx sg enable");
521 pta
= kzalloc(sizeof(*pta
), GFP_KERNEL
);
527 pta
->enable
= SG_ENABLE
;
529 ret
= wl1271_cmd_configure(wl
, ACX_SG_ENABLE
, pta
, sizeof(*pta
));
531 wl1271_warning("failed to set softgemini enable: %d", ret
);
540 int wl1271_acx_sg_cfg(struct wl1271
*wl
)
542 struct acx_bt_wlan_coex_param
*param
;
543 struct conf_sg_settings
*c
= &wl
->conf
.sg
;
546 wl1271_debug(DEBUG_ACX
, "acx sg cfg");
548 param
= kzalloc(sizeof(*param
), GFP_KERNEL
);
554 /* BT-WLAN coext parameters */
555 param
->per_threshold
= cpu_to_le32(c
->per_threshold
);
556 param
->max_scan_compensation_time
=
557 cpu_to_le32(c
->max_scan_compensation_time
);
558 param
->nfs_sample_interval
= cpu_to_le16(c
->nfs_sample_interval
);
559 param
->load_ratio
= c
->load_ratio
;
560 param
->auto_ps_mode
= c
->auto_ps_mode
;
561 param
->probe_req_compensation
= c
->probe_req_compensation
;
562 param
->scan_window_compensation
= c
->scan_window_compensation
;
563 param
->antenna_config
= c
->antenna_config
;
564 param
->beacon_miss_threshold
= c
->beacon_miss_threshold
;
565 param
->rate_adaptation_threshold
=
566 cpu_to_le32(c
->rate_adaptation_threshold
);
567 param
->rate_adaptation_snr
= c
->rate_adaptation_snr
;
569 ret
= wl1271_cmd_configure(wl
, ACX_SG_CFG
, param
, sizeof(*param
));
571 wl1271_warning("failed to set sg config: %d", ret
);
580 int wl1271_acx_cca_threshold(struct wl1271
*wl
)
582 struct acx_energy_detection
*detection
;
585 wl1271_debug(DEBUG_ACX
, "acx cca threshold");
587 detection
= kzalloc(sizeof(*detection
), GFP_KERNEL
);
593 detection
->rx_cca_threshold
= cpu_to_le16(wl
->conf
.rx
.rx_cca_threshold
);
594 detection
->tx_energy_detection
= wl
->conf
.tx
.tx_energy_detection
;
596 ret
= wl1271_cmd_configure(wl
, ACX_CCA_THRESHOLD
,
597 detection
, sizeof(*detection
));
599 wl1271_warning("failed to set cca threshold: %d", ret
);
608 int wl1271_acx_bcn_dtim_options(struct wl1271
*wl
)
610 struct acx_beacon_broadcast
*bb
;
613 wl1271_debug(DEBUG_ACX
, "acx bcn dtim options");
615 bb
= kzalloc(sizeof(*bb
), GFP_KERNEL
);
621 bb
->beacon_rx_timeout
= cpu_to_le16(wl
->conf
.conn
.beacon_rx_timeout
);
622 bb
->broadcast_timeout
= cpu_to_le16(wl
->conf
.conn
.broadcast_timeout
);
623 bb
->rx_broadcast_in_ps
= wl
->conf
.conn
.rx_broadcast_in_ps
;
624 bb
->ps_poll_threshold
= wl
->conf
.conn
.ps_poll_threshold
;
626 ret
= wl1271_cmd_configure(wl
, ACX_BCN_DTIM_OPTIONS
, bb
, sizeof(*bb
));
628 wl1271_warning("failed to set rx config: %d", ret
);
637 int wl1271_acx_aid(struct wl1271
*wl
, u16 aid
)
639 struct acx_aid
*acx_aid
;
642 wl1271_debug(DEBUG_ACX
, "acx aid");
644 acx_aid
= kzalloc(sizeof(*acx_aid
), GFP_KERNEL
);
650 acx_aid
->aid
= cpu_to_le16(aid
);
652 ret
= wl1271_cmd_configure(wl
, ACX_AID
, acx_aid
, sizeof(*acx_aid
));
654 wl1271_warning("failed to set aid: %d", ret
);
663 int wl1271_acx_event_mbox_mask(struct wl1271
*wl
, u32 event_mask
)
665 struct acx_event_mask
*mask
;
668 wl1271_debug(DEBUG_ACX
, "acx event mbox mask");
670 mask
= kzalloc(sizeof(*mask
), GFP_KERNEL
);
676 /* high event mask is unused */
677 mask
->high_event_mask
= cpu_to_le32(0xffffffff);
678 mask
->event_mask
= cpu_to_le32(event_mask
);
680 ret
= wl1271_cmd_configure(wl
, ACX_EVENT_MBOX_MASK
,
681 mask
, sizeof(*mask
));
683 wl1271_warning("failed to set acx_event_mbox_mask: %d", ret
);
692 int wl1271_acx_set_preamble(struct wl1271
*wl
, enum acx_preamble_type preamble
)
694 struct acx_preamble
*acx
;
697 wl1271_debug(DEBUG_ACX
, "acx_set_preamble");
699 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
705 acx
->preamble
= preamble
;
707 ret
= wl1271_cmd_configure(wl
, ACX_PREAMBLE_TYPE
, acx
, sizeof(*acx
));
709 wl1271_warning("Setting of preamble failed: %d", ret
);
718 int wl1271_acx_cts_protect(struct wl1271
*wl
,
719 enum acx_ctsprotect_type ctsprotect
)
721 struct acx_ctsprotect
*acx
;
724 wl1271_debug(DEBUG_ACX
, "acx_set_ctsprotect");
726 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
732 acx
->ctsprotect
= ctsprotect
;
734 ret
= wl1271_cmd_configure(wl
, ACX_CTS_PROTECTION
, acx
, sizeof(*acx
));
736 wl1271_warning("Setting of ctsprotect failed: %d", ret
);
745 int wl1271_acx_statistics(struct wl1271
*wl
, struct acx_statistics
*stats
)
749 wl1271_debug(DEBUG_ACX
, "acx statistics");
751 ret
= wl1271_cmd_interrogate(wl
, ACX_STATISTICS
, stats
,
754 wl1271_warning("acx statistics failed: %d", ret
);
761 int wl1271_acx_rate_policies(struct wl1271
*wl
, u32 enabled_rates
)
763 struct acx_rate_policy
*acx
;
764 struct conf_tx_rate_class
*c
= &wl
->conf
.tx
.rc_conf
;
767 wl1271_debug(DEBUG_ACX
, "acx rate policies");
769 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
776 /* configure one default (one-size-fits-all) rate class */
777 acx
->rate_class_cnt
= cpu_to_le32(1);
778 acx
->rate_class
[0].enabled_rates
= cpu_to_le32(enabled_rates
);
779 acx
->rate_class
[0].short_retry_limit
= c
->short_retry_limit
;
780 acx
->rate_class
[0].long_retry_limit
= c
->long_retry_limit
;
781 acx
->rate_class
[0].aflags
= c
->aflags
;
783 ret
= wl1271_cmd_configure(wl
, ACX_RATE_POLICY
, acx
, sizeof(*acx
));
785 wl1271_warning("Setting of rate policies failed: %d", ret
);
794 int wl1271_acx_ac_cfg(struct wl1271
*wl
)
796 struct acx_ac_cfg
*acx
;
799 wl1271_debug(DEBUG_ACX
, "acx access category config");
801 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
808 for (i
= 0; i
< wl
->conf
.tx
.ac_conf_count
; i
++) {
809 struct conf_tx_ac_category
*c
= &(wl
->conf
.tx
.ac_conf
[i
]);
811 acx
->cw_min
= c
->cw_min
;
812 acx
->cw_max
= cpu_to_le16(c
->cw_max
);
813 acx
->aifsn
= c
->aifsn
;
815 acx
->tx_op_limit
= cpu_to_le16(c
->tx_op_limit
);
817 ret
= wl1271_cmd_configure(wl
, ACX_AC_CFG
, acx
, sizeof(*acx
));
819 wl1271_warning("Setting of access category "
830 int wl1271_acx_tid_cfg(struct wl1271
*wl
)
832 struct acx_tid_config
*acx
;
835 wl1271_debug(DEBUG_ACX
, "acx tid config");
837 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
844 for (i
= 0; i
< wl
->conf
.tx
.tid_conf_count
; i
++) {
845 struct conf_tx_tid
*c
= &(wl
->conf
.tx
.tid_conf
[i
]);
846 acx
->queue_id
= c
->queue_id
;
847 acx
->channel_type
= c
->channel_type
;
849 acx
->ps_scheme
= c
->ps_scheme
;
850 acx
->ack_policy
= c
->ack_policy
;
851 acx
->apsd_conf
[0] = cpu_to_le32(c
->apsd_conf
[0]);
852 acx
->apsd_conf
[1] = cpu_to_le32(c
->apsd_conf
[1]);
854 ret
= wl1271_cmd_configure(wl
, ACX_TID_CFG
, acx
, sizeof(*acx
));
856 wl1271_warning("Setting of tid config failed: %d", ret
);
866 int wl1271_acx_frag_threshold(struct wl1271
*wl
)
868 struct acx_frag_threshold
*acx
;
871 wl1271_debug(DEBUG_ACX
, "acx frag threshold");
873 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
880 acx
->frag_threshold
= cpu_to_le16(wl
->conf
.tx
.frag_threshold
);
881 ret
= wl1271_cmd_configure(wl
, ACX_FRAG_CFG
, acx
, sizeof(*acx
));
883 wl1271_warning("Setting of frag threshold failed: %d", ret
);
892 int wl1271_acx_tx_config_options(struct wl1271
*wl
)
894 struct acx_tx_config_options
*acx
;
897 wl1271_debug(DEBUG_ACX
, "acx tx config options");
899 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
906 acx
->tx_compl_timeout
= cpu_to_le16(wl
->conf
.tx
.tx_compl_timeout
);
907 acx
->tx_compl_threshold
= cpu_to_le16(wl
->conf
.tx
.tx_compl_threshold
);
908 ret
= wl1271_cmd_configure(wl
, ACX_TX_CONFIG_OPT
, acx
, sizeof(*acx
));
910 wl1271_warning("Setting of tx options failed: %d", ret
);
919 int wl1271_acx_mem_cfg(struct wl1271
*wl
)
921 struct wl1271_acx_config_memory
*mem_conf
;
924 wl1271_debug(DEBUG_ACX
, "wl1271 mem cfg");
926 mem_conf
= kzalloc(sizeof(*mem_conf
), GFP_KERNEL
);
933 mem_conf
->num_stations
= DEFAULT_NUM_STATIONS
;
934 mem_conf
->rx_mem_block_num
= ACX_RX_MEM_BLOCKS
;
935 mem_conf
->tx_min_mem_block_num
= ACX_TX_MIN_MEM_BLOCKS
;
936 mem_conf
->num_ssid_profiles
= ACX_NUM_SSID_PROFILES
;
937 mem_conf
->total_tx_descriptors
= cpu_to_le32(ACX_TX_DESCRIPTORS
);
939 ret
= wl1271_cmd_configure(wl
, ACX_MEM_CFG
, mem_conf
,
942 wl1271_warning("wl1271 mem config failed: %d", ret
);
951 int wl1271_acx_init_mem_config(struct wl1271
*wl
)
955 ret
= wl1271_acx_mem_cfg(wl
);
959 wl
->target_mem_map
= kzalloc(sizeof(struct wl1271_acx_mem_map
),
961 if (!wl
->target_mem_map
) {
962 wl1271_error("couldn't allocate target memory map");
966 /* we now ask for the firmware built memory map */
967 ret
= wl1271_acx_mem_map(wl
, (void *)wl
->target_mem_map
,
968 sizeof(struct wl1271_acx_mem_map
));
970 wl1271_error("couldn't retrieve firmware memory map");
971 kfree(wl
->target_mem_map
);
972 wl
->target_mem_map
= NULL
;
976 /* initialize TX block book keeping */
977 wl
->tx_blocks_available
=
978 le32_to_cpu(wl
->target_mem_map
->num_tx_mem_blocks
);
979 wl1271_debug(DEBUG_TX
, "available tx blocks: %d",
980 wl
->tx_blocks_available
);
985 int wl1271_acx_init_rx_interrupt(struct wl1271
*wl
)
987 struct wl1271_acx_rx_config_opt
*rx_conf
;
990 wl1271_debug(DEBUG_ACX
, "wl1271 rx interrupt config");
992 rx_conf
= kzalloc(sizeof(*rx_conf
), GFP_KERNEL
);
998 rx_conf
->threshold
= cpu_to_le16(wl
->conf
.rx
.irq_pkt_threshold
);
999 rx_conf
->timeout
= cpu_to_le16(wl
->conf
.rx
.irq_timeout
);
1000 rx_conf
->mblk_threshold
= cpu_to_le16(wl
->conf
.rx
.irq_blk_threshold
);
1001 rx_conf
->queue_type
= wl
->conf
.rx
.queue_type
;
1003 ret
= wl1271_cmd_configure(wl
, ACX_RX_CONFIG_OPT
, rx_conf
,
1006 wl1271_warning("wl1271 rx config opt failed: %d", ret
);
1015 int wl1271_acx_smart_reflex(struct wl1271
*wl
)
1017 struct acx_smart_reflex_state
*sr_state
= NULL
;
1018 struct acx_smart_reflex_config_params
*sr_param
= NULL
;
1021 wl1271_debug(DEBUG_ACX
, "acx smart reflex");
1023 sr_param
= kzalloc(sizeof(*sr_param
), GFP_KERNEL
);
1029 for (i
= 0; i
< CONF_SR_ERR_TBL_COUNT
; i
++) {
1030 struct conf_mart_reflex_err_table
*e
=
1031 &(wl
->conf
.init
.sr_err_tbl
[i
]);
1033 sr_param
->error_table
[i
].len
= e
->len
;
1034 sr_param
->error_table
[i
].upper_limit
= e
->upper_limit
;
1035 memcpy(sr_param
->error_table
[i
].values
, e
->values
, e
->len
);
1038 ret
= wl1271_cmd_configure(wl
, ACX_SET_SMART_REFLEX_PARAMS
,
1039 sr_param
, sizeof(*sr_param
));
1041 wl1271_warning("failed to set smart reflex params: %d", ret
);
1045 sr_state
= kzalloc(sizeof(*sr_state
), GFP_KERNEL
);
1051 /* enable smart reflex */
1052 sr_state
->enable
= wl
->conf
.init
.sr_enable
;
1054 ret
= wl1271_cmd_configure(wl
, ACX_SET_SMART_REFLEX_STATE
,
1055 sr_state
, sizeof(*sr_state
));
1057 wl1271_warning("failed to set smart reflex params: %d", ret
);
1068 int wl1271_acx_bet_enable(struct wl1271
*wl
, bool enable
)
1070 struct wl1271_acx_bet_enable
*acx
= NULL
;
1073 wl1271_debug(DEBUG_ACX
, "acx bet enable");
1075 if (enable
&& wl
->conf
.conn
.bet_enable
== CONF_BET_MODE_DISABLE
)
1078 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
1084 acx
->enable
= enable
? CONF_BET_MODE_ENABLE
: CONF_BET_MODE_DISABLE
;
1085 acx
->max_consecutive
= wl
->conf
.conn
.bet_max_consecutive
;
1087 ret
= wl1271_cmd_configure(wl
, ACX_BET_ENABLE
, acx
, sizeof(*acx
));
1089 wl1271_warning("acx bet enable failed: %d", ret
);
1098 int wl1271_acx_arp_ip_filter(struct wl1271
*wl
, bool enable
, u8
*address
,
1101 struct wl1271_acx_arp_filter
*acx
;
1104 wl1271_debug(DEBUG_ACX
, "acx arp ip filter, enable: %d", enable
);
1106 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
1112 acx
->version
= version
;
1113 acx
->enable
= enable
;
1115 if (enable
== true) {
1116 if (version
== ACX_IPV4_VERSION
)
1117 memcpy(acx
->address
, address
, ACX_IPV4_ADDR_SIZE
);
1118 else if (version
== ACX_IPV6_VERSION
)
1119 memcpy(acx
->address
, address
, sizeof(acx
->address
));
1121 wl1271_error("Invalid IP version");
1124 ret
= wl1271_cmd_configure(wl
, ACX_ARP_IP_FILTER
,
1127 wl1271_warning("failed to set arp ip filter: %d", ret
);