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>
30 #include <linux/slab.h>
33 #include "wl12xx_80211.h"
34 #include "wl1271_reg.h"
35 #include "wl1271_spi.h"
36 #include "wl1271_ps.h"
38 int wl1271_acx_wake_up_conditions(struct wl1271
*wl
)
40 struct acx_wake_up_condition
*wake_up
;
43 wl1271_debug(DEBUG_ACX
, "acx wake up conditions");
45 wake_up
= kzalloc(sizeof(*wake_up
), GFP_KERNEL
);
51 wake_up
->wake_up_event
= wl
->conf
.conn
.wake_up_event
;
52 wake_up
->listen_interval
= wl
->conf
.conn
.listen_interval
;
54 ret
= wl1271_cmd_configure(wl
, ACX_WAKE_UP_CONDITIONS
,
55 wake_up
, sizeof(*wake_up
));
57 wl1271_warning("could not set wake up conditions: %d", ret
);
66 int wl1271_acx_sleep_auth(struct wl1271
*wl
, u8 sleep_auth
)
68 struct acx_sleep_auth
*auth
;
71 wl1271_debug(DEBUG_ACX
, "acx sleep auth");
73 auth
= kzalloc(sizeof(*auth
), GFP_KERNEL
);
79 auth
->sleep_auth
= sleep_auth
;
81 ret
= wl1271_cmd_configure(wl
, ACX_SLEEP_AUTH
, auth
, sizeof(*auth
));
90 int wl1271_acx_fw_version(struct wl1271
*wl
, char *buf
, size_t len
)
92 struct acx_revision
*rev
;
95 wl1271_debug(DEBUG_ACX
, "acx fw rev");
97 rev
= kzalloc(sizeof(*rev
), GFP_KERNEL
);
103 ret
= wl1271_cmd_interrogate(wl
, ACX_FW_REV
, rev
, sizeof(*rev
));
105 wl1271_warning("ACX_FW_REV interrogate failed");
109 /* be careful with the buffer sizes */
110 strncpy(buf
, rev
->fw_version
, min(len
, sizeof(rev
->fw_version
)));
113 * if the firmware version string is exactly
114 * sizeof(rev->fw_version) long or fw_len is less than
115 * sizeof(rev->fw_version) it won't be null terminated
117 buf
[min(len
, sizeof(rev
->fw_version
)) - 1] = '\0';
124 int wl1271_acx_tx_power(struct wl1271
*wl
, int power
)
126 struct acx_current_tx_power
*acx
;
129 wl1271_debug(DEBUG_ACX
, "acx dot11_cur_tx_pwr");
131 if (power
< 0 || power
> 25)
134 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
141 * FIXME: This is a workaround needed while we don't the correct
142 * calibration, to avoid distortions
144 /* acx->current_tx_power = power * 10; */
145 acx
->current_tx_power
= 120;
147 ret
= wl1271_cmd_configure(wl
, DOT11_CUR_TX_PWR
, acx
, sizeof(*acx
));
149 wl1271_warning("configure of tx power failed: %d", ret
);
158 int wl1271_acx_feature_cfg(struct wl1271
*wl
)
160 struct acx_feature_config
*feature
;
163 wl1271_debug(DEBUG_ACX
, "acx feature cfg");
165 feature
= kzalloc(sizeof(*feature
), GFP_KERNEL
);
171 /* DF_ENCRYPTION_DISABLE and DF_SNIFF_MODE_ENABLE are disabled */
172 feature
->data_flow_options
= 0;
173 feature
->options
= 0;
175 ret
= wl1271_cmd_configure(wl
, ACX_FEATURE_CFG
,
176 feature
, sizeof(*feature
));
178 wl1271_error("Couldnt set HW encryption");
187 int wl1271_acx_mem_map(struct wl1271
*wl
, struct acx_header
*mem_map
,
192 wl1271_debug(DEBUG_ACX
, "acx mem map");
194 ret
= wl1271_cmd_interrogate(wl
, ACX_MEM_MAP
, mem_map
, len
);
201 int wl1271_acx_rx_msdu_life_time(struct wl1271
*wl
)
203 struct acx_rx_msdu_lifetime
*acx
;
206 wl1271_debug(DEBUG_ACX
, "acx rx msdu life time");
208 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
214 acx
->lifetime
= cpu_to_le32(wl
->conf
.rx
.rx_msdu_life_time
);
215 ret
= wl1271_cmd_configure(wl
, DOT11_RX_MSDU_LIFE_TIME
,
218 wl1271_warning("failed to set rx msdu life time: %d", ret
);
227 int wl1271_acx_rx_config(struct wl1271
*wl
, u32 config
, u32 filter
)
229 struct acx_rx_config
*rx_config
;
232 wl1271_debug(DEBUG_ACX
, "acx rx config");
234 rx_config
= kzalloc(sizeof(*rx_config
), GFP_KERNEL
);
240 rx_config
->config_options
= cpu_to_le32(config
);
241 rx_config
->filter_options
= cpu_to_le32(filter
);
243 ret
= wl1271_cmd_configure(wl
, ACX_RX_CFG
,
244 rx_config
, sizeof(*rx_config
));
246 wl1271_warning("failed to set rx config: %d", ret
);
255 int wl1271_acx_pd_threshold(struct wl1271
*wl
)
257 struct acx_packet_detection
*pd
;
260 wl1271_debug(DEBUG_ACX
, "acx data pd threshold");
262 pd
= kzalloc(sizeof(*pd
), GFP_KERNEL
);
268 pd
->threshold
= cpu_to_le32(wl
->conf
.rx
.packet_detection_threshold
);
270 ret
= wl1271_cmd_configure(wl
, ACX_PD_THRESHOLD
, pd
, sizeof(*pd
));
272 wl1271_warning("failed to set pd threshold: %d", ret
);
281 int wl1271_acx_slot(struct wl1271
*wl
, enum acx_slot_type slot_time
)
283 struct acx_slot
*slot
;
286 wl1271_debug(DEBUG_ACX
, "acx slot");
288 slot
= kzalloc(sizeof(*slot
), GFP_KERNEL
);
294 slot
->wone_index
= STATION_WONE_INDEX
;
295 slot
->slot_time
= slot_time
;
297 ret
= wl1271_cmd_configure(wl
, ACX_SLOT
, slot
, sizeof(*slot
));
299 wl1271_warning("failed to set slot time: %d", ret
);
308 int wl1271_acx_group_address_tbl(struct wl1271
*wl
, bool enable
,
309 void *mc_list
, u32 mc_list_len
)
311 struct acx_dot11_grp_addr_tbl
*acx
;
314 wl1271_debug(DEBUG_ACX
, "acx group address tbl");
316 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
323 acx
->enabled
= enable
;
324 acx
->num_groups
= mc_list_len
;
325 memcpy(acx
->mac_table
, mc_list
, mc_list_len
* ETH_ALEN
);
327 ret
= wl1271_cmd_configure(wl
, DOT11_GROUP_ADDRESS_TBL
,
330 wl1271_warning("failed to set group addr table: %d", ret
);
339 int wl1271_acx_service_period_timeout(struct wl1271
*wl
)
341 struct acx_rx_timeout
*rx_timeout
;
344 rx_timeout
= kzalloc(sizeof(*rx_timeout
), GFP_KERNEL
);
350 wl1271_debug(DEBUG_ACX
, "acx service period timeout");
352 rx_timeout
->ps_poll_timeout
= cpu_to_le16(wl
->conf
.rx
.ps_poll_timeout
);
353 rx_timeout
->upsd_timeout
= cpu_to_le16(wl
->conf
.rx
.upsd_timeout
);
355 ret
= wl1271_cmd_configure(wl
, ACX_SERVICE_PERIOD_TIMEOUT
,
356 rx_timeout
, sizeof(*rx_timeout
));
358 wl1271_warning("failed to set service period timeout: %d",
368 int wl1271_acx_rts_threshold(struct wl1271
*wl
, u16 rts_threshold
)
370 struct acx_rts_threshold
*rts
;
373 wl1271_debug(DEBUG_ACX
, "acx rts threshold");
375 rts
= kzalloc(sizeof(*rts
), GFP_KERNEL
);
381 rts
->threshold
= cpu_to_le16(rts_threshold
);
383 ret
= wl1271_cmd_configure(wl
, DOT11_RTS_THRESHOLD
, rts
, sizeof(*rts
));
385 wl1271_warning("failed to set rts threshold: %d", ret
);
394 int wl1271_acx_dco_itrim_params(struct wl1271
*wl
)
396 struct acx_dco_itrim_params
*dco
;
397 struct conf_itrim_settings
*c
= &wl
->conf
.itrim
;
400 wl1271_debug(DEBUG_ACX
, "acx dco itrim parameters");
402 dco
= kzalloc(sizeof(*dco
), GFP_KERNEL
);
408 dco
->enable
= c
->enable
;
409 dco
->timeout
= cpu_to_le32(c
->timeout
);
411 ret
= wl1271_cmd_configure(wl
, ACX_SET_DCO_ITRIM_PARAMS
,
414 wl1271_warning("failed to set dco itrim parameters: %d", ret
);
423 int wl1271_acx_beacon_filter_opt(struct wl1271
*wl
, bool enable_filter
)
425 struct acx_beacon_filter_option
*beacon_filter
= NULL
;
428 wl1271_debug(DEBUG_ACX
, "acx beacon filter opt");
431 wl
->conf
.conn
.bcn_filt_mode
== CONF_BCN_FILT_MODE_DISABLED
)
434 beacon_filter
= kzalloc(sizeof(*beacon_filter
), GFP_KERNEL
);
435 if (!beacon_filter
) {
440 beacon_filter
->enable
= enable_filter
;
443 * When set to zero, and the filter is enabled, beacons
444 * without the unicast TIM bit set are dropped.
446 beacon_filter
->max_num_beacons
= 0;
448 ret
= wl1271_cmd_configure(wl
, ACX_BEACON_FILTER_OPT
,
449 beacon_filter
, sizeof(*beacon_filter
));
451 wl1271_warning("failed to set beacon filter opt: %d", ret
);
456 kfree(beacon_filter
);
460 int wl1271_acx_beacon_filter_table(struct wl1271
*wl
)
462 struct acx_beacon_filter_ie_table
*ie_table
;
465 bool vendor_spec
= false;
467 wl1271_debug(DEBUG_ACX
, "acx beacon filter table");
469 ie_table
= kzalloc(sizeof(*ie_table
), GFP_KERNEL
);
475 /* configure default beacon pass-through rules */
476 ie_table
->num_ie
= 0;
477 for (i
= 0; i
< wl
->conf
.conn
.bcn_filt_ie_count
; i
++) {
478 struct conf_bcn_filt_rule
*r
= &(wl
->conf
.conn
.bcn_filt_ie
[i
]);
479 ie_table
->table
[idx
++] = r
->ie
;
480 ie_table
->table
[idx
++] = r
->rule
;
482 if (r
->ie
== WLAN_EID_VENDOR_SPECIFIC
) {
483 /* only one vendor specific ie allowed */
487 /* for vendor specific rules configure the
489 memcpy(&(ie_table
->table
[idx
]), r
->oui
,
490 CONF_BCN_IE_OUI_LEN
);
491 idx
+= CONF_BCN_IE_OUI_LEN
;
492 ie_table
->table
[idx
++] = r
->type
;
493 memcpy(&(ie_table
->table
[idx
]), r
->version
,
494 CONF_BCN_IE_VER_LEN
);
495 idx
+= CONF_BCN_IE_VER_LEN
;
502 ret
= wl1271_cmd_configure(wl
, ACX_BEACON_FILTER_TABLE
,
503 ie_table
, sizeof(*ie_table
));
505 wl1271_warning("failed to set beacon filter table: %d", ret
);
514 int wl1271_acx_conn_monit_params(struct wl1271
*wl
)
516 struct acx_conn_monit_params
*acx
;
519 wl1271_debug(DEBUG_ACX
, "acx connection monitor parameters");
521 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
527 acx
->synch_fail_thold
= cpu_to_le32(wl
->conf
.conn
.synch_fail_thold
);
528 acx
->bss_lose_timeout
= cpu_to_le32(wl
->conf
.conn
.bss_lose_timeout
);
530 ret
= wl1271_cmd_configure(wl
, ACX_CONN_MONIT_PARAMS
,
533 wl1271_warning("failed to set connection monitor "
534 "parameters: %d", ret
);
544 int wl1271_acx_sg_enable(struct wl1271
*wl
)
546 struct acx_bt_wlan_coex
*pta
;
549 wl1271_debug(DEBUG_ACX
, "acx sg enable");
551 pta
= kzalloc(sizeof(*pta
), GFP_KERNEL
);
557 pta
->enable
= SG_ENABLE
;
559 ret
= wl1271_cmd_configure(wl
, ACX_SG_ENABLE
, pta
, sizeof(*pta
));
561 wl1271_warning("failed to set softgemini enable: %d", ret
);
570 int wl1271_acx_sg_cfg(struct wl1271
*wl
)
572 struct acx_bt_wlan_coex_param
*param
;
573 struct conf_sg_settings
*c
= &wl
->conf
.sg
;
576 wl1271_debug(DEBUG_ACX
, "acx sg cfg");
578 param
= kzalloc(sizeof(*param
), GFP_KERNEL
);
584 /* BT-WLAN coext parameters */
585 param
->per_threshold
= cpu_to_le32(c
->per_threshold
);
586 param
->max_scan_compensation_time
=
587 cpu_to_le32(c
->max_scan_compensation_time
);
588 param
->nfs_sample_interval
= cpu_to_le16(c
->nfs_sample_interval
);
589 param
->load_ratio
= c
->load_ratio
;
590 param
->auto_ps_mode
= c
->auto_ps_mode
;
591 param
->probe_req_compensation
= c
->probe_req_compensation
;
592 param
->scan_window_compensation
= c
->scan_window_compensation
;
593 param
->antenna_config
= c
->antenna_config
;
594 param
->beacon_miss_threshold
= c
->beacon_miss_threshold
;
595 param
->rate_adaptation_threshold
=
596 cpu_to_le32(c
->rate_adaptation_threshold
);
597 param
->rate_adaptation_snr
= c
->rate_adaptation_snr
;
599 ret
= wl1271_cmd_configure(wl
, ACX_SG_CFG
, param
, sizeof(*param
));
601 wl1271_warning("failed to set sg config: %d", ret
);
610 int wl1271_acx_cca_threshold(struct wl1271
*wl
)
612 struct acx_energy_detection
*detection
;
615 wl1271_debug(DEBUG_ACX
, "acx cca threshold");
617 detection
= kzalloc(sizeof(*detection
), GFP_KERNEL
);
623 detection
->rx_cca_threshold
= cpu_to_le16(wl
->conf
.rx
.rx_cca_threshold
);
624 detection
->tx_energy_detection
= wl
->conf
.tx
.tx_energy_detection
;
626 ret
= wl1271_cmd_configure(wl
, ACX_CCA_THRESHOLD
,
627 detection
, sizeof(*detection
));
629 wl1271_warning("failed to set cca threshold: %d", ret
);
638 int wl1271_acx_bcn_dtim_options(struct wl1271
*wl
)
640 struct acx_beacon_broadcast
*bb
;
643 wl1271_debug(DEBUG_ACX
, "acx bcn dtim options");
645 bb
= kzalloc(sizeof(*bb
), GFP_KERNEL
);
651 bb
->beacon_rx_timeout
= cpu_to_le16(wl
->conf
.conn
.beacon_rx_timeout
);
652 bb
->broadcast_timeout
= cpu_to_le16(wl
->conf
.conn
.broadcast_timeout
);
653 bb
->rx_broadcast_in_ps
= wl
->conf
.conn
.rx_broadcast_in_ps
;
654 bb
->ps_poll_threshold
= wl
->conf
.conn
.ps_poll_threshold
;
656 ret
= wl1271_cmd_configure(wl
, ACX_BCN_DTIM_OPTIONS
, bb
, sizeof(*bb
));
658 wl1271_warning("failed to set rx config: %d", ret
);
667 int wl1271_acx_aid(struct wl1271
*wl
, u16 aid
)
669 struct acx_aid
*acx_aid
;
672 wl1271_debug(DEBUG_ACX
, "acx aid");
674 acx_aid
= kzalloc(sizeof(*acx_aid
), GFP_KERNEL
);
680 acx_aid
->aid
= cpu_to_le16(aid
);
682 ret
= wl1271_cmd_configure(wl
, ACX_AID
, acx_aid
, sizeof(*acx_aid
));
684 wl1271_warning("failed to set aid: %d", ret
);
693 int wl1271_acx_event_mbox_mask(struct wl1271
*wl
, u32 event_mask
)
695 struct acx_event_mask
*mask
;
698 wl1271_debug(DEBUG_ACX
, "acx event mbox mask");
700 mask
= kzalloc(sizeof(*mask
), GFP_KERNEL
);
706 /* high event mask is unused */
707 mask
->high_event_mask
= cpu_to_le32(0xffffffff);
708 mask
->event_mask
= cpu_to_le32(event_mask
);
710 ret
= wl1271_cmd_configure(wl
, ACX_EVENT_MBOX_MASK
,
711 mask
, sizeof(*mask
));
713 wl1271_warning("failed to set acx_event_mbox_mask: %d", ret
);
722 int wl1271_acx_set_preamble(struct wl1271
*wl
, enum acx_preamble_type preamble
)
724 struct acx_preamble
*acx
;
727 wl1271_debug(DEBUG_ACX
, "acx_set_preamble");
729 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
735 acx
->preamble
= preamble
;
737 ret
= wl1271_cmd_configure(wl
, ACX_PREAMBLE_TYPE
, acx
, sizeof(*acx
));
739 wl1271_warning("Setting of preamble failed: %d", ret
);
748 int wl1271_acx_cts_protect(struct wl1271
*wl
,
749 enum acx_ctsprotect_type ctsprotect
)
751 struct acx_ctsprotect
*acx
;
754 wl1271_debug(DEBUG_ACX
, "acx_set_ctsprotect");
756 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
762 acx
->ctsprotect
= ctsprotect
;
764 ret
= wl1271_cmd_configure(wl
, ACX_CTS_PROTECTION
, acx
, sizeof(*acx
));
766 wl1271_warning("Setting of ctsprotect failed: %d", ret
);
775 int wl1271_acx_statistics(struct wl1271
*wl
, struct acx_statistics
*stats
)
779 wl1271_debug(DEBUG_ACX
, "acx statistics");
781 ret
= wl1271_cmd_interrogate(wl
, ACX_STATISTICS
, stats
,
784 wl1271_warning("acx statistics failed: %d", ret
);
791 int wl1271_acx_rate_policies(struct wl1271
*wl
)
793 struct acx_rate_policy
*acx
;
794 struct conf_tx_rate_class
*c
= &wl
->conf
.tx
.rc_conf
;
798 wl1271_debug(DEBUG_ACX
, "acx rate policies");
800 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
807 /* configure one basic rate class */
808 idx
= ACX_TX_BASIC_RATE
;
809 acx
->rate_class
[idx
].enabled_rates
= cpu_to_le32(wl
->basic_rate_set
);
810 acx
->rate_class
[idx
].short_retry_limit
= c
->short_retry_limit
;
811 acx
->rate_class
[idx
].long_retry_limit
= c
->long_retry_limit
;
812 acx
->rate_class
[idx
].aflags
= c
->aflags
;
814 /* configure one AP supported rate class */
815 idx
= ACX_TX_AP_FULL_RATE
;
816 acx
->rate_class
[idx
].enabled_rates
= cpu_to_le32(wl
->rate_set
);
817 acx
->rate_class
[idx
].short_retry_limit
= c
->short_retry_limit
;
818 acx
->rate_class
[idx
].long_retry_limit
= c
->long_retry_limit
;
819 acx
->rate_class
[idx
].aflags
= c
->aflags
;
821 acx
->rate_class_cnt
= cpu_to_le32(ACX_TX_RATE_POLICY_CNT
);
823 ret
= wl1271_cmd_configure(wl
, ACX_RATE_POLICY
, acx
, sizeof(*acx
));
825 wl1271_warning("Setting of rate policies failed: %d", ret
);
834 int wl1271_acx_ac_cfg(struct wl1271
*wl
, u8 ac
, u8 cw_min
, u16 cw_max
,
837 struct acx_ac_cfg
*acx
;
840 wl1271_debug(DEBUG_ACX
, "acx ac cfg %d cw_ming %d cw_max %d "
841 "aifs %d txop %d", ac
, cw_min
, cw_max
, aifsn
, txop
);
843 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
851 acx
->cw_min
= cw_min
;
852 acx
->cw_max
= cpu_to_le16(cw_max
);
854 acx
->tx_op_limit
= cpu_to_le16(txop
);
856 ret
= wl1271_cmd_configure(wl
, ACX_AC_CFG
, acx
, sizeof(*acx
));
858 wl1271_warning("acx ac cfg failed: %d", ret
);
867 int wl1271_acx_tid_cfg(struct wl1271
*wl
, u8 queue_id
, u8 channel_type
,
868 u8 tsid
, u8 ps_scheme
, u8 ack_policy
,
869 u32 apsd_conf0
, u32 apsd_conf1
)
871 struct acx_tid_config
*acx
;
874 wl1271_debug(DEBUG_ACX
, "acx tid config");
876 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
883 acx
->queue_id
= queue_id
;
884 acx
->channel_type
= channel_type
;
886 acx
->ps_scheme
= ps_scheme
;
887 acx
->ack_policy
= ack_policy
;
888 acx
->apsd_conf
[0] = cpu_to_le32(apsd_conf0
);
889 acx
->apsd_conf
[1] = cpu_to_le32(apsd_conf1
);
891 ret
= wl1271_cmd_configure(wl
, ACX_TID_CFG
, acx
, sizeof(*acx
));
893 wl1271_warning("Setting of tid config failed: %d", ret
);
902 int wl1271_acx_frag_threshold(struct wl1271
*wl
)
904 struct acx_frag_threshold
*acx
;
907 wl1271_debug(DEBUG_ACX
, "acx frag threshold");
909 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
916 acx
->frag_threshold
= cpu_to_le16(wl
->conf
.tx
.frag_threshold
);
917 ret
= wl1271_cmd_configure(wl
, ACX_FRAG_CFG
, acx
, sizeof(*acx
));
919 wl1271_warning("Setting of frag threshold failed: %d", ret
);
928 int wl1271_acx_tx_config_options(struct wl1271
*wl
)
930 struct acx_tx_config_options
*acx
;
933 wl1271_debug(DEBUG_ACX
, "acx tx config options");
935 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
942 acx
->tx_compl_timeout
= cpu_to_le16(wl
->conf
.tx
.tx_compl_timeout
);
943 acx
->tx_compl_threshold
= cpu_to_le16(wl
->conf
.tx
.tx_compl_threshold
);
944 ret
= wl1271_cmd_configure(wl
, ACX_TX_CONFIG_OPT
, acx
, sizeof(*acx
));
946 wl1271_warning("Setting of tx options failed: %d", ret
);
955 int wl1271_acx_mem_cfg(struct wl1271
*wl
)
957 struct wl1271_acx_config_memory
*mem_conf
;
960 wl1271_debug(DEBUG_ACX
, "wl1271 mem cfg");
962 mem_conf
= kzalloc(sizeof(*mem_conf
), GFP_KERNEL
);
969 mem_conf
->num_stations
= DEFAULT_NUM_STATIONS
;
970 mem_conf
->rx_mem_block_num
= ACX_RX_MEM_BLOCKS
;
971 mem_conf
->tx_min_mem_block_num
= ACX_TX_MIN_MEM_BLOCKS
;
972 mem_conf
->num_ssid_profiles
= ACX_NUM_SSID_PROFILES
;
973 mem_conf
->total_tx_descriptors
= cpu_to_le32(ACX_TX_DESCRIPTORS
);
975 ret
= wl1271_cmd_configure(wl
, ACX_MEM_CFG
, mem_conf
,
978 wl1271_warning("wl1271 mem config failed: %d", ret
);
987 int wl1271_acx_init_mem_config(struct wl1271
*wl
)
991 ret
= wl1271_acx_mem_cfg(wl
);
995 wl
->target_mem_map
= kzalloc(sizeof(struct wl1271_acx_mem_map
),
997 if (!wl
->target_mem_map
) {
998 wl1271_error("couldn't allocate target memory map");
1002 /* we now ask for the firmware built memory map */
1003 ret
= wl1271_acx_mem_map(wl
, (void *)wl
->target_mem_map
,
1004 sizeof(struct wl1271_acx_mem_map
));
1006 wl1271_error("couldn't retrieve firmware memory map");
1007 kfree(wl
->target_mem_map
);
1008 wl
->target_mem_map
= NULL
;
1012 /* initialize TX block book keeping */
1013 wl
->tx_blocks_available
=
1014 le32_to_cpu(wl
->target_mem_map
->num_tx_mem_blocks
);
1015 wl1271_debug(DEBUG_TX
, "available tx blocks: %d",
1016 wl
->tx_blocks_available
);
1021 int wl1271_acx_init_rx_interrupt(struct wl1271
*wl
)
1023 struct wl1271_acx_rx_config_opt
*rx_conf
;
1026 wl1271_debug(DEBUG_ACX
, "wl1271 rx interrupt config");
1028 rx_conf
= kzalloc(sizeof(*rx_conf
), GFP_KERNEL
);
1034 rx_conf
->threshold
= cpu_to_le16(wl
->conf
.rx
.irq_pkt_threshold
);
1035 rx_conf
->timeout
= cpu_to_le16(wl
->conf
.rx
.irq_timeout
);
1036 rx_conf
->mblk_threshold
= cpu_to_le16(wl
->conf
.rx
.irq_blk_threshold
);
1037 rx_conf
->queue_type
= wl
->conf
.rx
.queue_type
;
1039 ret
= wl1271_cmd_configure(wl
, ACX_RX_CONFIG_OPT
, rx_conf
,
1042 wl1271_warning("wl1271 rx config opt failed: %d", ret
);
1051 int wl1271_acx_bet_enable(struct wl1271
*wl
, bool enable
)
1053 struct wl1271_acx_bet_enable
*acx
= NULL
;
1056 wl1271_debug(DEBUG_ACX
, "acx bet enable");
1058 if (enable
&& wl
->conf
.conn
.bet_enable
== CONF_BET_MODE_DISABLE
)
1061 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
1067 acx
->enable
= enable
? CONF_BET_MODE_ENABLE
: CONF_BET_MODE_DISABLE
;
1068 acx
->max_consecutive
= wl
->conf
.conn
.bet_max_consecutive
;
1070 ret
= wl1271_cmd_configure(wl
, ACX_BET_ENABLE
, acx
, sizeof(*acx
));
1072 wl1271_warning("acx bet enable failed: %d", ret
);
1081 int wl1271_acx_arp_ip_filter(struct wl1271
*wl
, bool enable
, u8
*address
,
1084 struct wl1271_acx_arp_filter
*acx
;
1087 wl1271_debug(DEBUG_ACX
, "acx arp ip filter, enable: %d", enable
);
1089 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
1095 acx
->version
= version
;
1096 acx
->enable
= enable
;
1098 if (enable
== true) {
1099 if (version
== ACX_IPV4_VERSION
)
1100 memcpy(acx
->address
, address
, ACX_IPV4_ADDR_SIZE
);
1101 else if (version
== ACX_IPV6_VERSION
)
1102 memcpy(acx
->address
, address
, sizeof(acx
->address
));
1104 wl1271_error("Invalid IP version");
1107 ret
= wl1271_cmd_configure(wl
, ACX_ARP_IP_FILTER
,
1110 wl1271_warning("failed to set arp ip filter: %d", ret
);
1119 int wl1271_acx_pm_config(struct wl1271
*wl
)
1121 struct wl1271_acx_pm_config
*acx
= NULL
;
1122 struct conf_pm_config_settings
*c
= &wl
->conf
.pm_config
;
1125 wl1271_debug(DEBUG_ACX
, "acx pm config");
1127 acx
= kzalloc(sizeof(*acx
), GFP_KERNEL
);
1133 acx
->host_clk_settling_time
= cpu_to_le32(c
->host_clk_settling_time
);
1134 acx
->host_fast_wakeup_support
= c
->host_fast_wakeup_support
;
1136 ret
= wl1271_cmd_configure(wl
, ACX_PM_CONFIG
, acx
, sizeof(*acx
));
1138 wl1271_warning("acx pm config failed: %d", ret
);