2 * This file is part of wl1271
4 * Copyright (C) 2009-2010 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 <linux/module.h>
25 #include <linux/platform_device.h>
26 #include <linux/spi/spi.h>
27 #include <linux/etherdevice.h>
28 #include <linux/ieee80211.h>
29 #include <linux/slab.h>
35 #include "wl12xx_80211.h"
41 #define WL1271_CMD_FAST_POLL_COUNT 50
42 #define WL1271_WAIT_EVENT_FAST_POLL_COUNT 20
45 * send command to firmware
49 * @buf: buffer containing the command, must work with dma
50 * @len: length of the buffer
51 * return the cmd status code on success.
53 static int __wlcore_cmd_send(struct wl1271
*wl
, u16 id
, void *buf
,
54 size_t len
, size_t res_len
)
56 struct wl1271_cmd_header
*cmd
;
57 unsigned long timeout
;
63 if (unlikely(wl
->state
== WLCORE_STATE_RESTARTING
&&
64 id
!= CMD_STOP_FWLOGGER
))
67 if (WARN_ON_ONCE(len
< sizeof(*cmd
)))
71 cmd
->id
= cpu_to_le16(id
);
74 WARN_ON(len
% 4 != 0);
75 WARN_ON(test_bit(WL1271_FLAG_IN_ELP
, &wl
->flags
));
77 ret
= wlcore_write(wl
, wl
->cmd_box_addr
, buf
, len
, false);
82 * TODO: we just need this because one bit is in a different
83 * place. Is there any better way?
85 ret
= wl
->ops
->trigger_cmd(wl
, wl
->cmd_box_addr
, buf
, len
);
89 timeout
= jiffies
+ msecs_to_jiffies(WL1271_COMMAND_TIMEOUT
);
91 ret
= wlcore_read_reg(wl
, REG_INTERRUPT_NO_CLEAR
, &intr
);
95 while (!(intr
& WL1271_ACX_INTR_CMD_COMPLETE
)) {
96 if (time_after(jiffies
, timeout
)) {
97 wl1271_error("command complete timeout");
102 if (poll_count
< WL1271_CMD_FAST_POLL_COUNT
)
107 ret
= wlcore_read_reg(wl
, REG_INTERRUPT_NO_CLEAR
, &intr
);
112 /* read back the status code of the command */
114 res_len
= sizeof(struct wl1271_cmd_header
);
116 ret
= wlcore_read(wl
, wl
->cmd_box_addr
, cmd
, res_len
, false);
120 status
= le16_to_cpu(cmd
->status
);
122 ret
= wlcore_write_reg(wl
, REG_INTERRUPT_ACK
,
123 WL1271_ACX_INTR_CMD_COMPLETE
);
131 * send command to fw and return cmd status on success
132 * valid_rets contains a bitmap of allowed error codes
134 static int wlcore_cmd_send_failsafe(struct wl1271
*wl
, u16 id
, void *buf
,
135 size_t len
, size_t res_len
,
136 unsigned long valid_rets
)
138 int ret
= __wlcore_cmd_send(wl
, id
, buf
, len
, res_len
);
143 /* success is always a valid status */
144 valid_rets
|= BIT(CMD_STATUS_SUCCESS
);
146 if (ret
>= MAX_COMMAND_STATUS
||
147 !test_bit(ret
, &valid_rets
)) {
148 wl1271_error("command execute failure %d", ret
);
154 wl12xx_queue_recovery_work(wl
);
159 * wrapper for wlcore_cmd_send that accept only CMD_STATUS_SUCCESS
160 * return 0 on success.
162 int wl1271_cmd_send(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
,
165 int ret
= wlcore_cmd_send_failsafe(wl
, id
, buf
, len
, res_len
, 0);
171 EXPORT_SYMBOL_GPL(wl1271_cmd_send
);
174 * Poll the mailbox event field until any of the bits in the mask is set or a
175 * timeout occurs (WL1271_EVENT_TIMEOUT in msecs)
177 int wlcore_cmd_wait_for_event_or_timeout(struct wl1271
*wl
,
178 u32 mask
, bool *timeout
)
182 unsigned long timeout_time
;
188 events_vector
= kmalloc(sizeof(*events_vector
), GFP_KERNEL
| GFP_DMA
);
192 timeout_time
= jiffies
+ msecs_to_jiffies(WL1271_EVENT_TIMEOUT
);
195 if (time_after(jiffies
, timeout_time
)) {
196 wl1271_debug(DEBUG_CMD
, "timeout waiting for event %d",
203 if (poll_count
< WL1271_WAIT_EVENT_FAST_POLL_COUNT
)
204 usleep_range(50, 51);
206 usleep_range(1000, 5000);
208 /* read from both event fields */
209 ret
= wlcore_read(wl
, wl
->mbox_ptr
[0], events_vector
,
210 sizeof(*events_vector
), false);
214 event
= *events_vector
& mask
;
216 ret
= wlcore_read(wl
, wl
->mbox_ptr
[1], events_vector
,
217 sizeof(*events_vector
), false);
221 event
|= *events_vector
& mask
;
225 kfree(events_vector
);
228 EXPORT_SYMBOL_GPL(wlcore_cmd_wait_for_event_or_timeout
);
230 int wl12xx_cmd_role_enable(struct wl1271
*wl
, u8
*addr
, u8 role_type
,
233 struct wl12xx_cmd_role_enable
*cmd
;
236 wl1271_debug(DEBUG_CMD
, "cmd role enable");
238 if (WARN_ON(*role_id
!= WL12XX_INVALID_ROLE_ID
))
241 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
248 cmd
->role_id
= find_first_zero_bit(wl
->roles_map
, WL12XX_MAX_ROLES
);
249 if (cmd
->role_id
>= WL12XX_MAX_ROLES
) {
254 memcpy(cmd
->mac_address
, addr
, ETH_ALEN
);
255 cmd
->role_type
= role_type
;
257 ret
= wl1271_cmd_send(wl
, CMD_ROLE_ENABLE
, cmd
, sizeof(*cmd
), 0);
259 wl1271_error("failed to initiate cmd role enable");
263 __set_bit(cmd
->role_id
, wl
->roles_map
);
264 *role_id
= cmd
->role_id
;
273 int wl12xx_cmd_role_disable(struct wl1271
*wl
, u8
*role_id
)
275 struct wl12xx_cmd_role_disable
*cmd
;
278 wl1271_debug(DEBUG_CMD
, "cmd role disable");
280 if (WARN_ON(*role_id
== WL12XX_INVALID_ROLE_ID
))
283 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
288 cmd
->role_id
= *role_id
;
290 ret
= wl1271_cmd_send(wl
, CMD_ROLE_DISABLE
, cmd
, sizeof(*cmd
), 0);
292 wl1271_error("failed to initiate cmd role disable");
296 __clear_bit(*role_id
, wl
->roles_map
);
297 *role_id
= WL12XX_INVALID_ROLE_ID
;
306 static int wlcore_get_new_session_id(struct wl1271
*wl
, u8 hlid
)
308 if (wl
->session_ids
[hlid
] >= SESSION_COUNTER_MAX
)
309 wl
->session_ids
[hlid
] = 0;
311 wl
->session_ids
[hlid
]++;
313 return wl
->session_ids
[hlid
];
316 int wl12xx_allocate_link(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
, u8
*hlid
)
319 u8 link
= find_first_zero_bit(wl
->links_map
, wl
->num_links
);
320 if (link
>= wl
->num_links
)
323 wl
->session_ids
[link
] = wlcore_get_new_session_id(wl
, link
);
325 /* these bits are used by op_tx */
326 spin_lock_irqsave(&wl
->wl_lock
, flags
);
327 __set_bit(link
, wl
->links_map
);
328 __set_bit(link
, wlvif
->links_map
);
329 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
332 * take the last "freed packets" value from the current FW status.
333 * on recovery, we might not have fw_status yet, and
334 * tx_lnk_free_pkts will be NULL. check for it.
336 if (wl
->fw_status
->counters
.tx_lnk_free_pkts
)
337 wl
->links
[link
].prev_freed_pkts
=
338 wl
->fw_status
->counters
.tx_lnk_free_pkts
[link
];
339 wl
->links
[link
].wlvif
= wlvif
;
342 * Take saved value for total freed packets from wlvif, in case this is
345 if (wlvif
->bss_type
!= BSS_TYPE_AP_BSS
)
346 wl
->links
[link
].total_freed_pkts
= wlvif
->total_freed_pkts
;
350 wl
->active_link_count
++;
354 void wl12xx_free_link(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
, u8
*hlid
)
358 if (*hlid
== WL12XX_INVALID_LINK_ID
)
361 /* these bits are used by op_tx */
362 spin_lock_irqsave(&wl
->wl_lock
, flags
);
363 __clear_bit(*hlid
, wl
->links_map
);
364 __clear_bit(*hlid
, wlvif
->links_map
);
365 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
367 wl
->links
[*hlid
].allocated_pkts
= 0;
368 wl
->links
[*hlid
].prev_freed_pkts
= 0;
369 wl
->links
[*hlid
].ba_bitmap
= 0;
370 memset(wl
->links
[*hlid
].addr
, 0, ETH_ALEN
);
373 * At this point op_tx() will not add more packets to the queues. We
376 wl1271_tx_reset_link_queues(wl
, *hlid
);
377 wl
->links
[*hlid
].wlvif
= NULL
;
379 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
&&
380 *hlid
== wlvif
->ap
.bcast_hlid
) {
381 u32 sqn_padding
= WL1271_TX_SQN_POST_RECOVERY_PADDING
;
383 * save the total freed packets in the wlvif, in case this is
384 * recovery or suspend
386 wlvif
->total_freed_pkts
= wl
->links
[*hlid
].total_freed_pkts
;
389 * increment the initial seq number on recovery to account for
390 * transmitted packets that we haven't yet got in the FW status
392 if (wlvif
->encryption_type
== KEY_GEM
)
393 sqn_padding
= WL1271_TX_SQN_POST_RECOVERY_PADDING_GEM
;
395 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
396 wlvif
->total_freed_pkts
+= sqn_padding
;
399 wl
->links
[*hlid
].total_freed_pkts
= 0;
401 *hlid
= WL12XX_INVALID_LINK_ID
;
402 wl
->active_link_count
--;
403 WARN_ON_ONCE(wl
->active_link_count
< 0);
406 static u8
wlcore_get_native_channel_type(u8 nl_channel_type
)
408 switch (nl_channel_type
) {
409 case NL80211_CHAN_NO_HT
:
410 return WLCORE_CHAN_NO_HT
;
411 case NL80211_CHAN_HT20
:
412 return WLCORE_CHAN_HT20
;
413 case NL80211_CHAN_HT40MINUS
:
414 return WLCORE_CHAN_HT40MINUS
;
415 case NL80211_CHAN_HT40PLUS
:
416 return WLCORE_CHAN_HT40PLUS
;
419 return WLCORE_CHAN_NO_HT
;
423 static int wl12xx_cmd_role_start_dev(struct wl1271
*wl
,
424 struct wl12xx_vif
*wlvif
,
425 enum ieee80211_band band
,
428 struct wl12xx_cmd_role_start
*cmd
;
431 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
437 wl1271_debug(DEBUG_CMD
, "cmd role start dev %d", wlvif
->dev_role_id
);
439 cmd
->role_id
= wlvif
->dev_role_id
;
440 if (band
== IEEE80211_BAND_5GHZ
)
441 cmd
->band
= WLCORE_BAND_5GHZ
;
442 cmd
->channel
= channel
;
444 if (wlvif
->dev_hlid
== WL12XX_INVALID_LINK_ID
) {
445 ret
= wl12xx_allocate_link(wl
, wlvif
, &wlvif
->dev_hlid
);
449 cmd
->device
.hlid
= wlvif
->dev_hlid
;
450 cmd
->device
.session
= wl
->session_ids
[wlvif
->dev_hlid
];
452 wl1271_debug(DEBUG_CMD
, "role start: roleid=%d, hlid=%d, session=%d",
453 cmd
->role_id
, cmd
->device
.hlid
, cmd
->device
.session
);
455 ret
= wl1271_cmd_send(wl
, CMD_ROLE_START
, cmd
, sizeof(*cmd
), 0);
457 wl1271_error("failed to initiate cmd role enable");
464 /* clear links on error */
465 wl12xx_free_link(wl
, wlvif
, &wlvif
->dev_hlid
);
474 static int wl12xx_cmd_role_stop_dev(struct wl1271
*wl
,
475 struct wl12xx_vif
*wlvif
)
477 struct wl12xx_cmd_role_stop
*cmd
;
480 if (WARN_ON(wlvif
->dev_hlid
== WL12XX_INVALID_LINK_ID
))
483 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
489 wl1271_debug(DEBUG_CMD
, "cmd role stop dev");
491 cmd
->role_id
= wlvif
->dev_role_id
;
492 cmd
->disc_type
= DISCONNECT_IMMEDIATE
;
493 cmd
->reason
= cpu_to_le16(WLAN_REASON_UNSPECIFIED
);
495 ret
= wl1271_cmd_send(wl
, CMD_ROLE_STOP
, cmd
, sizeof(*cmd
), 0);
497 wl1271_error("failed to initiate cmd role stop");
501 wl12xx_free_link(wl
, wlvif
, &wlvif
->dev_hlid
);
510 int wl12xx_cmd_role_start_sta(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
512 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
513 struct wl12xx_cmd_role_start
*cmd
;
517 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
523 wl1271_debug(DEBUG_CMD
, "cmd role start sta %d", wlvif
->role_id
);
525 cmd
->role_id
= wlvif
->role_id
;
526 if (wlvif
->band
== IEEE80211_BAND_5GHZ
)
527 cmd
->band
= WLCORE_BAND_5GHZ
;
528 cmd
->channel
= wlvif
->channel
;
529 cmd
->sta
.basic_rate_set
= cpu_to_le32(wlvif
->basic_rate_set
);
530 cmd
->sta
.beacon_interval
= cpu_to_le16(wlvif
->beacon_int
);
531 cmd
->sta
.ssid_type
= WL12XX_SSID_TYPE_ANY
;
532 cmd
->sta
.ssid_len
= wlvif
->ssid_len
;
533 memcpy(cmd
->sta
.ssid
, wlvif
->ssid
, wlvif
->ssid_len
);
534 memcpy(cmd
->sta
.bssid
, vif
->bss_conf
.bssid
, ETH_ALEN
);
536 supported_rates
= CONF_TX_ENABLED_RATES
| CONF_TX_MCS_RATES
|
537 wlcore_hw_sta_get_ap_rate_mask(wl
, wlvif
);
539 supported_rates
&= ~CONF_TX_CCK_RATES
;
541 cmd
->sta
.local_rates
= cpu_to_le32(supported_rates
);
543 cmd
->channel_type
= wlcore_get_native_channel_type(wlvif
->channel_type
);
545 if (wlvif
->sta
.hlid
== WL12XX_INVALID_LINK_ID
) {
546 ret
= wl12xx_allocate_link(wl
, wlvif
, &wlvif
->sta
.hlid
);
550 cmd
->sta
.hlid
= wlvif
->sta
.hlid
;
551 cmd
->sta
.session
= wl
->session_ids
[wlvif
->sta
.hlid
];
553 * We don't have the correct remote rates in this stage. The
554 * rates will be reconfigured later, after association, if the
555 * firmware supports ACX_PEER_CAP. Otherwise, there's nothing
556 * we can do, so use all supported_rates here.
558 cmd
->sta
.remote_rates
= cpu_to_le32(supported_rates
);
560 wl1271_debug(DEBUG_CMD
, "role start: roleid=%d, hlid=%d, session=%d "
561 "basic_rate_set: 0x%x, remote_rates: 0x%x",
562 wlvif
->role_id
, cmd
->sta
.hlid
, cmd
->sta
.session
,
563 wlvif
->basic_rate_set
, wlvif
->rate_set
);
565 ret
= wl1271_cmd_send(wl
, CMD_ROLE_START
, cmd
, sizeof(*cmd
), 0);
567 wl1271_error("failed to initiate cmd role start sta");
571 wlvif
->sta
.role_chan_type
= wlvif
->channel_type
;
575 /* clear links on error. */
576 wl12xx_free_link(wl
, wlvif
, &wlvif
->sta
.hlid
);
585 /* use this function to stop ibss as well */
586 int wl12xx_cmd_role_stop_sta(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
588 struct wl12xx_cmd_role_stop
*cmd
;
591 if (WARN_ON(wlvif
->sta
.hlid
== WL12XX_INVALID_LINK_ID
))
594 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
600 wl1271_debug(DEBUG_CMD
, "cmd role stop sta %d", wlvif
->role_id
);
602 cmd
->role_id
= wlvif
->role_id
;
603 cmd
->disc_type
= DISCONNECT_IMMEDIATE
;
604 cmd
->reason
= cpu_to_le16(WLAN_REASON_UNSPECIFIED
);
606 ret
= wl1271_cmd_send(wl
, CMD_ROLE_STOP
, cmd
, sizeof(*cmd
), 0);
608 wl1271_error("failed to initiate cmd role stop sta");
612 wl12xx_free_link(wl
, wlvif
, &wlvif
->sta
.hlid
);
621 int wl12xx_cmd_role_start_ap(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
623 struct wl12xx_cmd_role_start
*cmd
;
624 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
625 struct ieee80211_bss_conf
*bss_conf
= &vif
->bss_conf
;
629 wl1271_debug(DEBUG_CMD
, "cmd role start ap %d", wlvif
->role_id
);
631 /* trying to use hidden SSID with an old hostapd version */
632 if (wlvif
->ssid_len
== 0 && !bss_conf
->hidden_ssid
) {
633 wl1271_error("got a null SSID from beacon/bss");
638 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
644 ret
= wl12xx_allocate_link(wl
, wlvif
, &wlvif
->ap
.global_hlid
);
648 ret
= wl12xx_allocate_link(wl
, wlvif
, &wlvif
->ap
.bcast_hlid
);
650 goto out_free_global
;
652 /* use the previous security seq, if this is a recovery/resume */
653 wl
->links
[wlvif
->ap
.bcast_hlid
].total_freed_pkts
=
654 wlvif
->total_freed_pkts
;
656 cmd
->role_id
= wlvif
->role_id
;
657 cmd
->ap
.aging_period
= cpu_to_le16(wl
->conf
.tx
.ap_aging_period
);
658 cmd
->ap
.bss_index
= WL1271_AP_BSS_INDEX
;
659 cmd
->ap
.global_hlid
= wlvif
->ap
.global_hlid
;
660 cmd
->ap
.broadcast_hlid
= wlvif
->ap
.bcast_hlid
;
661 cmd
->ap
.global_session_id
= wl
->session_ids
[wlvif
->ap
.global_hlid
];
662 cmd
->ap
.bcast_session_id
= wl
->session_ids
[wlvif
->ap
.bcast_hlid
];
663 cmd
->ap
.basic_rate_set
= cpu_to_le32(wlvif
->basic_rate_set
);
664 cmd
->ap
.beacon_interval
= cpu_to_le16(wlvif
->beacon_int
);
665 cmd
->ap
.dtim_interval
= bss_conf
->dtim_period
;
666 cmd
->ap
.beacon_expiry
= WL1271_AP_DEF_BEACON_EXP
;
667 /* FIXME: Change when adding DFS */
668 cmd
->ap
.reset_tsf
= 1; /* By default reset AP TSF */
669 cmd
->ap
.wmm
= wlvif
->wmm_enabled
;
670 cmd
->channel
= wlvif
->channel
;
671 cmd
->channel_type
= wlcore_get_native_channel_type(wlvif
->channel_type
);
673 if (!bss_conf
->hidden_ssid
) {
674 /* take the SSID from the beacon for backward compatibility */
675 cmd
->ap
.ssid_type
= WL12XX_SSID_TYPE_PUBLIC
;
676 cmd
->ap
.ssid_len
= wlvif
->ssid_len
;
677 memcpy(cmd
->ap
.ssid
, wlvif
->ssid
, wlvif
->ssid_len
);
679 cmd
->ap
.ssid_type
= WL12XX_SSID_TYPE_HIDDEN
;
680 cmd
->ap
.ssid_len
= bss_conf
->ssid_len
;
681 memcpy(cmd
->ap
.ssid
, bss_conf
->ssid
, bss_conf
->ssid_len
);
684 supported_rates
= CONF_TX_ENABLED_RATES
| CONF_TX_MCS_RATES
|
685 wlcore_hw_ap_get_mimo_wide_rate_mask(wl
, wlvif
);
687 supported_rates
&= ~CONF_TX_CCK_RATES
;
689 wl1271_debug(DEBUG_CMD
, "cmd role start ap with supported_rates 0x%08x",
692 cmd
->ap
.local_rates
= cpu_to_le32(supported_rates
);
694 switch (wlvif
->band
) {
695 case IEEE80211_BAND_2GHZ
:
696 cmd
->band
= WLCORE_BAND_2_4GHZ
;
698 case IEEE80211_BAND_5GHZ
:
699 cmd
->band
= WLCORE_BAND_5GHZ
;
702 wl1271_warning("ap start - unknown band: %d", (int)wlvif
->band
);
703 cmd
->band
= WLCORE_BAND_2_4GHZ
;
707 ret
= wl1271_cmd_send(wl
, CMD_ROLE_START
, cmd
, sizeof(*cmd
), 0);
709 wl1271_error("failed to initiate cmd role start ap");
716 wl12xx_free_link(wl
, wlvif
, &wlvif
->ap
.bcast_hlid
);
719 wl12xx_free_link(wl
, wlvif
, &wlvif
->ap
.global_hlid
);
728 int wl12xx_cmd_role_stop_ap(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
730 struct wl12xx_cmd_role_stop
*cmd
;
733 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
739 wl1271_debug(DEBUG_CMD
, "cmd role stop ap %d", wlvif
->role_id
);
741 cmd
->role_id
= wlvif
->role_id
;
743 ret
= wl1271_cmd_send(wl
, CMD_ROLE_STOP
, cmd
, sizeof(*cmd
), 0);
745 wl1271_error("failed to initiate cmd role stop ap");
749 wl12xx_free_link(wl
, wlvif
, &wlvif
->ap
.bcast_hlid
);
750 wl12xx_free_link(wl
, wlvif
, &wlvif
->ap
.global_hlid
);
759 int wl12xx_cmd_role_start_ibss(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
761 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
762 struct wl12xx_cmd_role_start
*cmd
;
763 struct ieee80211_bss_conf
*bss_conf
= &vif
->bss_conf
;
766 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
772 wl1271_debug(DEBUG_CMD
, "cmd role start ibss %d", wlvif
->role_id
);
774 cmd
->role_id
= wlvif
->role_id
;
775 if (wlvif
->band
== IEEE80211_BAND_5GHZ
)
776 cmd
->band
= WLCORE_BAND_5GHZ
;
777 cmd
->channel
= wlvif
->channel
;
778 cmd
->ibss
.basic_rate_set
= cpu_to_le32(wlvif
->basic_rate_set
);
779 cmd
->ibss
.beacon_interval
= cpu_to_le16(wlvif
->beacon_int
);
780 cmd
->ibss
.dtim_interval
= bss_conf
->dtim_period
;
781 cmd
->ibss
.ssid_type
= WL12XX_SSID_TYPE_ANY
;
782 cmd
->ibss
.ssid_len
= wlvif
->ssid_len
;
783 memcpy(cmd
->ibss
.ssid
, wlvif
->ssid
, wlvif
->ssid_len
);
784 memcpy(cmd
->ibss
.bssid
, vif
->bss_conf
.bssid
, ETH_ALEN
);
785 cmd
->sta
.local_rates
= cpu_to_le32(wlvif
->rate_set
);
787 if (wlvif
->sta
.hlid
== WL12XX_INVALID_LINK_ID
) {
788 ret
= wl12xx_allocate_link(wl
, wlvif
, &wlvif
->sta
.hlid
);
792 cmd
->ibss
.hlid
= wlvif
->sta
.hlid
;
793 cmd
->ibss
.remote_rates
= cpu_to_le32(wlvif
->rate_set
);
795 wl1271_debug(DEBUG_CMD
, "role start: roleid=%d, hlid=%d, session=%d "
796 "basic_rate_set: 0x%x, remote_rates: 0x%x",
797 wlvif
->role_id
, cmd
->sta
.hlid
, cmd
->sta
.session
,
798 wlvif
->basic_rate_set
, wlvif
->rate_set
);
800 wl1271_debug(DEBUG_CMD
, "vif->bss_conf.bssid = %pM",
801 vif
->bss_conf
.bssid
);
803 ret
= wl1271_cmd_send(wl
, CMD_ROLE_START
, cmd
, sizeof(*cmd
), 0);
805 wl1271_error("failed to initiate cmd role enable");
812 /* clear links on error. */
813 wl12xx_free_link(wl
, wlvif
, &wlvif
->sta
.hlid
);
824 * send test command to firmware
827 * @buf: buffer containing the command, with all headers, must work with dma
828 * @len: length of the buffer
829 * @answer: is answer needed
831 int wl1271_cmd_test(struct wl1271
*wl
, void *buf
, size_t buf_len
, u8 answer
)
836 wl1271_debug(DEBUG_CMD
, "cmd test");
841 ret
= wl1271_cmd_send(wl
, CMD_TEST
, buf
, buf_len
, res_len
);
844 wl1271_warning("TEST command failed");
850 EXPORT_SYMBOL_GPL(wl1271_cmd_test
);
853 * read acx from firmware
857 * @buf: buffer for the response, including all headers, must work with dma
858 * @len: length of buf
860 int wl1271_cmd_interrogate(struct wl1271
*wl
, u16 id
, void *buf
,
861 size_t cmd_len
, size_t res_len
)
863 struct acx_header
*acx
= buf
;
866 wl1271_debug(DEBUG_CMD
, "cmd interrogate");
868 acx
->id
= cpu_to_le16(id
);
870 /* response payload length, does not include any headers */
871 acx
->len
= cpu_to_le16(res_len
- sizeof(*acx
));
873 ret
= wl1271_cmd_send(wl
, CMD_INTERROGATE
, acx
, cmd_len
, res_len
);
875 wl1271_error("INTERROGATE command failed");
881 * write acx value to firmware
885 * @buf: buffer containing acx, including all headers, must work with dma
886 * @len: length of buf
887 * @valid_rets: bitmap of valid cmd status codes (i.e. return values).
888 * return the cmd status on success.
890 int wlcore_cmd_configure_failsafe(struct wl1271
*wl
, u16 id
, void *buf
,
891 size_t len
, unsigned long valid_rets
)
893 struct acx_header
*acx
= buf
;
896 wl1271_debug(DEBUG_CMD
, "cmd configure (%d)", id
);
898 if (WARN_ON_ONCE(len
< sizeof(*acx
)))
901 acx
->id
= cpu_to_le16(id
);
903 /* payload length, does not include any headers */
904 acx
->len
= cpu_to_le16(len
- sizeof(*acx
));
906 ret
= wlcore_cmd_send_failsafe(wl
, CMD_CONFIGURE
, acx
, len
, 0,
909 wl1271_warning("CONFIGURE command NOK");
917 * wrapper for wlcore_cmd_configure that accepts only success status.
918 * return 0 on success
920 int wl1271_cmd_configure(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
)
922 int ret
= wlcore_cmd_configure_failsafe(wl
, id
, buf
, len
, 0);
928 EXPORT_SYMBOL_GPL(wl1271_cmd_configure
);
930 int wl1271_cmd_data_path(struct wl1271
*wl
, bool enable
)
932 struct cmd_enabledisable_path
*cmd
;
936 wl1271_debug(DEBUG_CMD
, "cmd data path");
938 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
944 /* the channel here is only used for calibration, so hardcoded to 1 */
948 cmd_rx
= CMD_ENABLE_RX
;
949 cmd_tx
= CMD_ENABLE_TX
;
951 cmd_rx
= CMD_DISABLE_RX
;
952 cmd_tx
= CMD_DISABLE_TX
;
955 ret
= wl1271_cmd_send(wl
, cmd_rx
, cmd
, sizeof(*cmd
), 0);
957 wl1271_error("rx %s cmd for channel %d failed",
958 enable
? "start" : "stop", cmd
->channel
);
962 wl1271_debug(DEBUG_BOOT
, "rx %s cmd channel %d",
963 enable
? "start" : "stop", cmd
->channel
);
965 ret
= wl1271_cmd_send(wl
, cmd_tx
, cmd
, sizeof(*cmd
), 0);
967 wl1271_error("tx %s cmd for channel %d failed",
968 enable
? "start" : "stop", cmd
->channel
);
972 wl1271_debug(DEBUG_BOOT
, "tx %s cmd channel %d",
973 enable
? "start" : "stop", cmd
->channel
);
979 EXPORT_SYMBOL_GPL(wl1271_cmd_data_path
);
981 int wl1271_cmd_ps_mode(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
982 u8 ps_mode
, u16 auto_ps_timeout
)
984 struct wl1271_cmd_ps_params
*ps_params
= NULL
;
987 wl1271_debug(DEBUG_CMD
, "cmd set ps mode");
989 ps_params
= kzalloc(sizeof(*ps_params
), GFP_KERNEL
);
995 ps_params
->role_id
= wlvif
->role_id
;
996 ps_params
->ps_mode
= ps_mode
;
997 ps_params
->auto_ps_timeout
= auto_ps_timeout
;
999 ret
= wl1271_cmd_send(wl
, CMD_SET_PS_MODE
, ps_params
,
1000 sizeof(*ps_params
), 0);
1002 wl1271_error("cmd set_ps_mode failed");
1011 int wl1271_cmd_template_set(struct wl1271
*wl
, u8 role_id
,
1012 u16 template_id
, void *buf
, size_t buf_len
,
1013 int index
, u32 rates
)
1015 struct wl1271_cmd_template_set
*cmd
;
1018 wl1271_debug(DEBUG_CMD
, "cmd template_set %d (role %d)",
1019 template_id
, role_id
);
1021 WARN_ON(buf_len
> WL1271_CMD_TEMPL_MAX_SIZE
);
1022 buf_len
= min_t(size_t, buf_len
, WL1271_CMD_TEMPL_MAX_SIZE
);
1024 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1030 /* during initialization wlvif is NULL */
1031 cmd
->role_id
= role_id
;
1032 cmd
->len
= cpu_to_le16(buf_len
);
1033 cmd
->template_type
= template_id
;
1034 cmd
->enabled_rates
= cpu_to_le32(rates
);
1035 cmd
->short_retry_limit
= wl
->conf
.tx
.tmpl_short_retry_limit
;
1036 cmd
->long_retry_limit
= wl
->conf
.tx
.tmpl_long_retry_limit
;
1040 memcpy(cmd
->template_data
, buf
, buf_len
);
1042 ret
= wl1271_cmd_send(wl
, CMD_SET_TEMPLATE
, cmd
, sizeof(*cmd
), 0);
1044 wl1271_warning("cmd set_template failed: %d", ret
);
1055 int wl12xx_cmd_build_null_data(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
1057 struct sk_buff
*skb
= NULL
;
1063 if (wlvif
->bss_type
== BSS_TYPE_IBSS
) {
1064 size
= sizeof(struct wl12xx_null_data_template
);
1067 skb
= ieee80211_nullfunc_get(wl
->hw
,
1068 wl12xx_wlvif_to_vif(wlvif
));
1075 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
,
1076 CMD_TEMPL_NULL_DATA
, ptr
, size
, 0,
1082 wl1271_warning("cmd buld null data failed %d", ret
);
1088 int wl12xx_cmd_build_klv_null_data(struct wl1271
*wl
,
1089 struct wl12xx_vif
*wlvif
)
1091 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
1092 struct sk_buff
*skb
= NULL
;
1095 skb
= ieee80211_nullfunc_get(wl
->hw
, vif
);
1099 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
, CMD_TEMPL_KLV
,
1100 skb
->data
, skb
->len
,
1101 wlvif
->sta
.klv_template_id
,
1107 wl1271_warning("cmd build klv null data failed %d", ret
);
1113 int wl1271_cmd_build_ps_poll(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1116 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
1117 struct sk_buff
*skb
;
1120 skb
= ieee80211_pspoll_get(wl
->hw
, vif
);
1124 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
,
1125 CMD_TEMPL_PS_POLL
, skb
->data
,
1126 skb
->len
, 0, wlvif
->basic_rate_set
);
1133 int wl12xx_cmd_build_probe_req(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1134 u8 role_id
, u8 band
,
1135 const u8
*ssid
, size_t ssid_len
,
1136 const u8
*ie0
, size_t ie0_len
, const u8
*ie1
,
1137 size_t ie1_len
, bool sched_scan
)
1139 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
1140 struct sk_buff
*skb
;
1143 u16 template_id_2_4
= wl
->scan_templ_id_2_4
;
1144 u16 template_id_5
= wl
->scan_templ_id_5
;
1146 wl1271_debug(DEBUG_SCAN
, "build probe request band %d", band
);
1148 skb
= ieee80211_probereq_get(wl
->hw
, vif
, ssid
, ssid_len
,
1155 memcpy(skb_put(skb
, ie0_len
), ie0
, ie0_len
);
1157 memcpy(skb_put(skb
, ie1_len
), ie1
, ie1_len
);
1160 (wl
->quirks
& WLCORE_QUIRK_DUAL_PROBE_TMPL
)) {
1161 template_id_2_4
= wl
->sched_scan_templ_id_2_4
;
1162 template_id_5
= wl
->sched_scan_templ_id_5
;
1165 rate
= wl1271_tx_min_rate_get(wl
, wlvif
->bitrate_masks
[band
]);
1166 if (band
== IEEE80211_BAND_2GHZ
)
1167 ret
= wl1271_cmd_template_set(wl
, role_id
,
1169 skb
->data
, skb
->len
, 0, rate
);
1171 ret
= wl1271_cmd_template_set(wl
, role_id
,
1173 skb
->data
, skb
->len
, 0, rate
);
1179 EXPORT_SYMBOL_GPL(wl12xx_cmd_build_probe_req
);
1181 struct sk_buff
*wl1271_cmd_build_ap_probe_req(struct wl1271
*wl
,
1182 struct wl12xx_vif
*wlvif
,
1183 struct sk_buff
*skb
)
1185 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
1190 skb
= ieee80211_ap_probereq_get(wl
->hw
, vif
);
1194 wl1271_debug(DEBUG_SCAN
, "set ap probe request template");
1196 rate
= wl1271_tx_min_rate_get(wl
, wlvif
->bitrate_masks
[wlvif
->band
]);
1197 if (wlvif
->band
== IEEE80211_BAND_2GHZ
)
1198 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
,
1199 CMD_TEMPL_CFG_PROBE_REQ_2_4
,
1200 skb
->data
, skb
->len
, 0, rate
);
1202 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
,
1203 CMD_TEMPL_CFG_PROBE_REQ_5
,
1204 skb
->data
, skb
->len
, 0, rate
);
1207 wl1271_error("Unable to set ap probe request template.");
1213 int wl1271_cmd_build_arp_rsp(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
1217 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
1218 struct sk_buff
*skb
;
1219 struct wl12xx_arp_rsp_template
*tmpl
;
1220 struct ieee80211_hdr_3addr
*hdr
;
1221 struct arphdr
*arp_hdr
;
1223 skb
= dev_alloc_skb(sizeof(*hdr
) + sizeof(__le16
) + sizeof(*tmpl
) +
1224 WL1271_EXTRA_SPACE_MAX
);
1226 wl1271_error("failed to allocate buffer for arp rsp template");
1230 skb_reserve(skb
, sizeof(*hdr
) + WL1271_EXTRA_SPACE_MAX
);
1232 tmpl
= (struct wl12xx_arp_rsp_template
*)skb_put(skb
, sizeof(*tmpl
));
1233 memset(tmpl
, 0, sizeof(*tmpl
));
1236 memcpy(tmpl
->llc_hdr
, rfc1042_header
, sizeof(rfc1042_header
));
1237 tmpl
->llc_type
= cpu_to_be16(ETH_P_ARP
);
1240 arp_hdr
= &tmpl
->arp_hdr
;
1241 arp_hdr
->ar_hrd
= cpu_to_be16(ARPHRD_ETHER
);
1242 arp_hdr
->ar_pro
= cpu_to_be16(ETH_P_IP
);
1243 arp_hdr
->ar_hln
= ETH_ALEN
;
1244 arp_hdr
->ar_pln
= 4;
1245 arp_hdr
->ar_op
= cpu_to_be16(ARPOP_REPLY
);
1248 memcpy(tmpl
->sender_hw
, vif
->addr
, ETH_ALEN
);
1249 tmpl
->sender_ip
= wlvif
->ip_addr
;
1251 /* encryption space */
1252 switch (wlvif
->encryption_type
) {
1254 if (wl
->quirks
& WLCORE_QUIRK_TKIP_HEADER_SPACE
)
1255 extra
= WL1271_EXTRA_SPACE_TKIP
;
1258 extra
= WL1271_EXTRA_SPACE_AES
;
1266 wl1271_warning("Unknown encryption type: %d",
1267 wlvif
->encryption_type
);
1273 u8
*space
= skb_push(skb
, extra
);
1274 memset(space
, 0, extra
);
1277 /* QoS header - BE */
1279 memset(skb_push(skb
, sizeof(__le16
)), 0, sizeof(__le16
));
1281 /* mac80211 header */
1282 hdr
= (struct ieee80211_hdr_3addr
*)skb_push(skb
, sizeof(*hdr
));
1283 memset(hdr
, 0, sizeof(*hdr
));
1284 fc
= IEEE80211_FTYPE_DATA
| IEEE80211_FCTL_TODS
;
1286 fc
|= IEEE80211_STYPE_QOS_DATA
;
1288 fc
|= IEEE80211_STYPE_DATA
;
1289 if (wlvif
->encryption_type
!= KEY_NONE
)
1290 fc
|= IEEE80211_FCTL_PROTECTED
;
1292 hdr
->frame_control
= cpu_to_le16(fc
);
1293 memcpy(hdr
->addr1
, vif
->bss_conf
.bssid
, ETH_ALEN
);
1294 memcpy(hdr
->addr2
, vif
->addr
, ETH_ALEN
);
1295 memset(hdr
->addr3
, 0xff, ETH_ALEN
);
1297 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
, CMD_TEMPL_ARP_RSP
,
1298 skb
->data
, skb
->len
, 0,
1305 int wl1271_build_qos_null_data(struct wl1271
*wl
, struct ieee80211_vif
*vif
)
1307 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
1308 struct ieee80211_qos_hdr
template;
1310 memset(&template, 0, sizeof(template));
1312 memcpy(template.addr1
, vif
->bss_conf
.bssid
, ETH_ALEN
);
1313 memcpy(template.addr2
, vif
->addr
, ETH_ALEN
);
1314 memcpy(template.addr3
, vif
->bss_conf
.bssid
, ETH_ALEN
);
1316 template.frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
1317 IEEE80211_STYPE_QOS_NULLFUNC
|
1318 IEEE80211_FCTL_TODS
);
1320 /* FIXME: not sure what priority to use here */
1321 template.qos_ctrl
= cpu_to_le16(0);
1323 return wl1271_cmd_template_set(wl
, wlvif
->role_id
,
1324 CMD_TEMPL_QOS_NULL_DATA
, &template,
1325 sizeof(template), 0,
1329 int wl12xx_cmd_set_default_wep_key(struct wl1271
*wl
, u8 id
, u8 hlid
)
1331 struct wl1271_cmd_set_keys
*cmd
;
1334 wl1271_debug(DEBUG_CMD
, "cmd set_default_wep_key %d", id
);
1336 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1344 cmd
->lid_key_type
= WEP_DEFAULT_LID_TYPE
;
1345 cmd
->key_action
= cpu_to_le16(KEY_SET_ID
);
1346 cmd
->key_type
= KEY_WEP
;
1348 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
1350 wl1271_warning("cmd set_default_wep_key failed: %d", ret
);
1360 int wl1271_cmd_set_sta_key(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1361 u16 action
, u8 id
, u8 key_type
,
1362 u8 key_size
, const u8
*key
, const u8
*addr
,
1363 u32 tx_seq_32
, u16 tx_seq_16
)
1365 struct wl1271_cmd_set_keys
*cmd
;
1368 /* hlid might have already been deleted */
1369 if (wlvif
->sta
.hlid
== WL12XX_INVALID_LINK_ID
)
1372 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1378 cmd
->hlid
= wlvif
->sta
.hlid
;
1380 if (key_type
== KEY_WEP
)
1381 cmd
->lid_key_type
= WEP_DEFAULT_LID_TYPE
;
1382 else if (is_broadcast_ether_addr(addr
))
1383 cmd
->lid_key_type
= BROADCAST_LID_TYPE
;
1385 cmd
->lid_key_type
= UNICAST_LID_TYPE
;
1387 cmd
->key_action
= cpu_to_le16(action
);
1388 cmd
->key_size
= key_size
;
1389 cmd
->key_type
= key_type
;
1391 cmd
->ac_seq_num16
[0] = cpu_to_le16(tx_seq_16
);
1392 cmd
->ac_seq_num32
[0] = cpu_to_le32(tx_seq_32
);
1396 if (key_type
== KEY_TKIP
) {
1398 * We get the key in the following form:
1399 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
1400 * but the target is expecting:
1401 * TKIP - RX MIC - TX MIC
1403 memcpy(cmd
->key
, key
, 16);
1404 memcpy(cmd
->key
+ 16, key
+ 24, 8);
1405 memcpy(cmd
->key
+ 24, key
+ 16, 8);
1408 memcpy(cmd
->key
, key
, key_size
);
1411 wl1271_dump(DEBUG_CRYPT
, "TARGET KEY: ", cmd
, sizeof(*cmd
));
1413 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
1415 wl1271_warning("could not set keys");
1426 * TODO: merge with sta/ibss into 1 set_key function.
1427 * note there are slight diffs
1429 int wl1271_cmd_set_ap_key(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1430 u16 action
, u8 id
, u8 key_type
,
1431 u8 key_size
, const u8
*key
, u8 hlid
, u32 tx_seq_32
,
1434 struct wl1271_cmd_set_keys
*cmd
;
1438 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1442 if (hlid
== wlvif
->ap
.bcast_hlid
) {
1443 if (key_type
== KEY_WEP
)
1444 lid_type
= WEP_DEFAULT_LID_TYPE
;
1446 lid_type
= BROADCAST_LID_TYPE
;
1448 lid_type
= UNICAST_LID_TYPE
;
1451 wl1271_debug(DEBUG_CRYPT
, "ap key action: %d id: %d lid: %d type: %d"
1452 " hlid: %d", (int)action
, (int)id
, (int)lid_type
,
1453 (int)key_type
, (int)hlid
);
1455 cmd
->lid_key_type
= lid_type
;
1457 cmd
->key_action
= cpu_to_le16(action
);
1458 cmd
->key_size
= key_size
;
1459 cmd
->key_type
= key_type
;
1461 cmd
->ac_seq_num16
[0] = cpu_to_le16(tx_seq_16
);
1462 cmd
->ac_seq_num32
[0] = cpu_to_le32(tx_seq_32
);
1464 if (key_type
== KEY_TKIP
) {
1466 * We get the key in the following form:
1467 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
1468 * but the target is expecting:
1469 * TKIP - RX MIC - TX MIC
1471 memcpy(cmd
->key
, key
, 16);
1472 memcpy(cmd
->key
+ 16, key
+ 24, 8);
1473 memcpy(cmd
->key
+ 24, key
+ 16, 8);
1475 memcpy(cmd
->key
, key
, key_size
);
1478 wl1271_dump(DEBUG_CRYPT
, "TARGET AP KEY: ", cmd
, sizeof(*cmd
));
1480 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
1482 wl1271_warning("could not set ap keys");
1491 int wl12xx_cmd_set_peer_state(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1494 struct wl12xx_cmd_set_peer_state
*cmd
;
1497 wl1271_debug(DEBUG_CMD
, "cmd set peer state (hlid=%d)", hlid
);
1499 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1506 cmd
->state
= WL1271_CMD_STA_STATE_CONNECTED
;
1508 /* wmm param is valid only for station role */
1509 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
)
1510 cmd
->wmm
= wlvif
->wmm_enabled
;
1512 ret
= wl1271_cmd_send(wl
, CMD_SET_PEER_STATE
, cmd
, sizeof(*cmd
), 0);
1514 wl1271_error("failed to send set peer state command");
1525 int wl12xx_cmd_add_peer(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1526 struct ieee80211_sta
*sta
, u8 hlid
)
1528 struct wl12xx_cmd_add_peer
*cmd
;
1532 wl1271_debug(DEBUG_CMD
, "cmd add peer %d", (int)hlid
);
1534 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1540 memcpy(cmd
->addr
, sta
->addr
, ETH_ALEN
);
1541 cmd
->bss_index
= WL1271_AP_BSS_INDEX
;
1542 cmd
->aid
= sta
->aid
;
1544 cmd
->sp_len
= sta
->max_sp
;
1545 cmd
->wmm
= sta
->wme
? 1 : 0;
1546 cmd
->session_id
= wl
->session_ids
[hlid
];
1547 cmd
->role_id
= wlvif
->role_id
;
1549 for (i
= 0; i
< NUM_ACCESS_CATEGORIES_COPY
; i
++)
1550 if (sta
->wme
&& (sta
->uapsd_queues
& BIT(i
)))
1551 cmd
->psd_type
[NUM_ACCESS_CATEGORIES_COPY
-1-i
] =
1552 WL1271_PSD_UPSD_TRIGGER
;
1554 cmd
->psd_type
[NUM_ACCESS_CATEGORIES_COPY
-1-i
] =
1558 sta_rates
= sta
->supp_rates
[wlvif
->band
];
1559 if (sta
->ht_cap
.ht_supported
)
1561 (sta
->ht_cap
.mcs
.rx_mask
[0] << HW_HT_RATES_OFFSET
) |
1562 (sta
->ht_cap
.mcs
.rx_mask
[1] << HW_MIMO_RATES_OFFSET
);
1564 cmd
->supported_rates
=
1565 cpu_to_le32(wl1271_tx_enabled_rates_get(wl
, sta_rates
,
1568 wl1271_debug(DEBUG_CMD
, "new peer rates=0x%x queues=0x%x",
1569 cmd
->supported_rates
, sta
->uapsd_queues
);
1571 ret
= wl1271_cmd_send(wl
, CMD_ADD_PEER
, cmd
, sizeof(*cmd
), 0);
1573 wl1271_error("failed to initiate cmd add peer");
1584 int wl12xx_cmd_remove_peer(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1587 struct wl12xx_cmd_remove_peer
*cmd
;
1589 bool timeout
= false;
1591 wl1271_debug(DEBUG_CMD
, "cmd remove peer %d", (int)hlid
);
1593 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1600 /* We never send a deauth, mac80211 is in charge of this */
1601 cmd
->reason_opcode
= 0;
1602 cmd
->send_deauth_flag
= 0;
1603 cmd
->role_id
= wlvif
->role_id
;
1605 ret
= wl1271_cmd_send(wl
, CMD_REMOVE_PEER
, cmd
, sizeof(*cmd
), 0);
1607 wl1271_error("failed to initiate cmd remove peer");
1611 ret
= wl
->ops
->wait_for_event(wl
,
1612 WLCORE_EVENT_PEER_REMOVE_COMPLETE
,
1616 * We are ok with a timeout here. The event is sometimes not sent
1617 * due to a firmware bug. In case of another error (like SDIO timeout)
1621 wl12xx_queue_recovery_work(wl
);
1630 static int wlcore_get_reg_conf_ch_idx(enum ieee80211_band band
, u16 ch
)
1633 * map the given band/channel to the respective predefined
1634 * bit expected by the fw
1637 case IEEE80211_BAND_2GHZ
:
1638 /* channels 1..14 are mapped to 0..13 */
1639 if (ch
>= 1 && ch
<= 14)
1642 case IEEE80211_BAND_5GHZ
:
1645 /* channels 8,12,16 are mapped to 18,19,20 */
1646 return 18 + (ch
-8)/4;
1648 /* channels 34,36..48 are mapped to 21..28 */
1649 return 21 + (ch
-34)/2;
1651 /* channels 52,56..64 are mapped to 29..32 */
1652 return 29 + (ch
-52)/4;
1654 /* channels 100,104..140 are mapped to 33..43 */
1655 return 33 + (ch
-100)/4;
1657 /* channels 149,153..165 are mapped to 44..48 */
1658 return 44 + (ch
-149)/4;
1667 wl1271_error("%s: unknown band/channel: %d/%d", __func__
, band
, ch
);
1671 void wlcore_set_pending_regdomain_ch(struct wl1271
*wl
, u16 channel
,
1672 enum ieee80211_band band
)
1676 if (!(wl
->quirks
& WLCORE_QUIRK_REGDOMAIN_CONF
))
1679 ch_bit_idx
= wlcore_get_reg_conf_ch_idx(band
, channel
);
1681 if (ch_bit_idx
>= 0 && ch_bit_idx
<= WL1271_MAX_CHANNELS
)
1682 set_bit(ch_bit_idx
, (long *)wl
->reg_ch_conf_pending
);
1685 int wlcore_cmd_regdomain_config_locked(struct wl1271
*wl
)
1687 struct wl12xx_cmd_regdomain_dfs_config
*cmd
= NULL
;
1688 int ret
= 0, i
, b
, ch_bit_idx
;
1689 struct ieee80211_channel
*channel
;
1690 u32 tmp_ch_bitmap
[2];
1692 struct wiphy
*wiphy
= wl
->hw
->wiphy
;
1693 struct ieee80211_supported_band
*band
;
1694 bool timeout
= false;
1696 if (!(wl
->quirks
& WLCORE_QUIRK_REGDOMAIN_CONF
))
1699 wl1271_debug(DEBUG_CMD
, "cmd reg domain config");
1701 memset(tmp_ch_bitmap
, 0, sizeof(tmp_ch_bitmap
));
1703 for (b
= IEEE80211_BAND_2GHZ
; b
<= IEEE80211_BAND_5GHZ
; b
++) {
1704 band
= wiphy
->bands
[b
];
1705 for (i
= 0; i
< band
->n_channels
; i
++) {
1706 channel
= &band
->channels
[i
];
1707 ch
= channel
->hw_value
;
1709 if (channel
->flags
& (IEEE80211_CHAN_DISABLED
|
1710 IEEE80211_CHAN_RADAR
|
1711 IEEE80211_CHAN_NO_IR
))
1714 ch_bit_idx
= wlcore_get_reg_conf_ch_idx(b
, ch
);
1718 set_bit(ch_bit_idx
, (long *)tmp_ch_bitmap
);
1722 tmp_ch_bitmap
[0] |= wl
->reg_ch_conf_pending
[0];
1723 tmp_ch_bitmap
[1] |= wl
->reg_ch_conf_pending
[1];
1725 if (!memcmp(tmp_ch_bitmap
, wl
->reg_ch_conf_last
, sizeof(tmp_ch_bitmap
)))
1728 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1734 cmd
->ch_bit_map1
= cpu_to_le32(tmp_ch_bitmap
[0]);
1735 cmd
->ch_bit_map2
= cpu_to_le32(tmp_ch_bitmap
[1]);
1737 wl1271_debug(DEBUG_CMD
,
1738 "cmd reg domain bitmap1: 0x%08x, bitmap2: 0x%08x",
1739 cmd
->ch_bit_map1
, cmd
->ch_bit_map2
);
1741 ret
= wl1271_cmd_send(wl
, CMD_DFS_CHANNEL_CONFIG
, cmd
, sizeof(*cmd
), 0);
1743 wl1271_error("failed to send reg domain dfs config");
1747 ret
= wl
->ops
->wait_for_event(wl
,
1748 WLCORE_EVENT_DFS_CONFIG_COMPLETE
,
1750 if (ret
< 0 || timeout
) {
1751 wl1271_error("reg domain conf %serror",
1752 timeout
? "completion " : "");
1753 ret
= timeout
? -ETIMEDOUT
: ret
;
1757 memcpy(wl
->reg_ch_conf_last
, tmp_ch_bitmap
, sizeof(tmp_ch_bitmap
));
1758 memset(wl
->reg_ch_conf_pending
, 0, sizeof(wl
->reg_ch_conf_pending
));
1765 int wl12xx_cmd_config_fwlog(struct wl1271
*wl
)
1767 struct wl12xx_cmd_config_fwlog
*cmd
;
1770 wl1271_debug(DEBUG_CMD
, "cmd config firmware logger");
1772 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1778 cmd
->logger_mode
= wl
->conf
.fwlog
.mode
;
1779 cmd
->log_severity
= wl
->conf
.fwlog
.severity
;
1780 cmd
->timestamp
= wl
->conf
.fwlog
.timestamp
;
1781 cmd
->output
= wl
->conf
.fwlog
.output
;
1782 cmd
->threshold
= wl
->conf
.fwlog
.threshold
;
1784 ret
= wl1271_cmd_send(wl
, CMD_CONFIG_FWLOGGER
, cmd
, sizeof(*cmd
), 0);
1786 wl1271_error("failed to send config firmware logger command");
1797 int wl12xx_cmd_start_fwlog(struct wl1271
*wl
)
1799 struct wl12xx_cmd_start_fwlog
*cmd
;
1802 wl1271_debug(DEBUG_CMD
, "cmd start firmware logger");
1804 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1810 ret
= wl1271_cmd_send(wl
, CMD_START_FWLOGGER
, cmd
, sizeof(*cmd
), 0);
1812 wl1271_error("failed to send start firmware logger command");
1823 int wl12xx_cmd_stop_fwlog(struct wl1271
*wl
)
1825 struct wl12xx_cmd_stop_fwlog
*cmd
;
1828 wl1271_debug(DEBUG_CMD
, "cmd stop firmware logger");
1830 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1836 ret
= wl1271_cmd_send(wl
, CMD_STOP_FWLOGGER
, cmd
, sizeof(*cmd
), 0);
1838 wl1271_error("failed to send stop firmware logger command");
1849 static int wl12xx_cmd_roc(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1850 u8 role_id
, enum ieee80211_band band
, u8 channel
)
1852 struct wl12xx_cmd_roc
*cmd
;
1855 wl1271_debug(DEBUG_CMD
, "cmd roc %d (%d)", channel
, role_id
);
1857 if (WARN_ON(role_id
== WL12XX_INVALID_ROLE_ID
))
1860 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1866 cmd
->role_id
= role_id
;
1867 cmd
->channel
= channel
;
1869 case IEEE80211_BAND_2GHZ
:
1870 cmd
->band
= WLCORE_BAND_2_4GHZ
;
1872 case IEEE80211_BAND_5GHZ
:
1873 cmd
->band
= WLCORE_BAND_5GHZ
;
1876 wl1271_error("roc - unknown band: %d", (int)wlvif
->band
);
1882 ret
= wl1271_cmd_send(wl
, CMD_REMAIN_ON_CHANNEL
, cmd
, sizeof(*cmd
), 0);
1884 wl1271_error("failed to send ROC command");
1895 static int wl12xx_cmd_croc(struct wl1271
*wl
, u8 role_id
)
1897 struct wl12xx_cmd_croc
*cmd
;
1900 wl1271_debug(DEBUG_CMD
, "cmd croc (%d)", role_id
);
1902 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1907 cmd
->role_id
= role_id
;
1909 ret
= wl1271_cmd_send(wl
, CMD_CANCEL_REMAIN_ON_CHANNEL
, cmd
,
1912 wl1271_error("failed to send ROC command");
1923 int wl12xx_roc(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
, u8 role_id
,
1924 enum ieee80211_band band
, u8 channel
)
1928 if (WARN_ON(test_bit(role_id
, wl
->roc_map
)))
1931 ret
= wl12xx_cmd_roc(wl
, wlvif
, role_id
, band
, channel
);
1935 __set_bit(role_id
, wl
->roc_map
);
1940 int wl12xx_croc(struct wl1271
*wl
, u8 role_id
)
1944 if (WARN_ON(!test_bit(role_id
, wl
->roc_map
)))
1947 ret
= wl12xx_cmd_croc(wl
, role_id
);
1951 __clear_bit(role_id
, wl
->roc_map
);
1954 * Rearm the tx watchdog when removing the last ROC. This prevents
1955 * recoveries due to just finished ROCs - when Tx hasn't yet had
1956 * a chance to get out.
1958 if (find_first_bit(wl
->roc_map
, WL12XX_MAX_ROLES
) >= WL12XX_MAX_ROLES
)
1959 wl12xx_rearm_tx_watchdog_locked(wl
);
1964 int wl12xx_cmd_stop_channel_switch(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
1966 struct wl12xx_cmd_stop_channel_switch
*cmd
;
1969 wl1271_debug(DEBUG_ACX
, "cmd stop channel switch");
1971 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1977 cmd
->role_id
= wlvif
->role_id
;
1979 ret
= wl1271_cmd_send(wl
, CMD_STOP_CHANNEL_SWICTH
, cmd
, sizeof(*cmd
), 0);
1981 wl1271_error("failed to stop channel switch command");
1992 /* start dev role and roc on its channel */
1993 int wl12xx_start_dev(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
1994 enum ieee80211_band band
, int channel
)
1998 if (WARN_ON(!(wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
1999 wlvif
->bss_type
== BSS_TYPE_IBSS
)))
2002 ret
= wl12xx_cmd_role_enable(wl
,
2003 wl12xx_wlvif_to_vif(wlvif
)->addr
,
2005 &wlvif
->dev_role_id
);
2009 ret
= wl12xx_cmd_role_start_dev(wl
, wlvif
, band
, channel
);
2013 ret
= wl12xx_roc(wl
, wlvif
, wlvif
->dev_role_id
, band
, channel
);
2020 wl12xx_cmd_role_stop_dev(wl
, wlvif
);
2022 wl12xx_cmd_role_disable(wl
, &wlvif
->dev_role_id
);
2027 /* croc dev hlid, and stop the role */
2028 int wl12xx_stop_dev(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2032 if (WARN_ON(!(wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
2033 wlvif
->bss_type
== BSS_TYPE_IBSS
)))
2036 /* flush all pending packets */
2037 ret
= wlcore_tx_work_locked(wl
);
2041 if (test_bit(wlvif
->dev_role_id
, wl
->roc_map
)) {
2042 ret
= wl12xx_croc(wl
, wlvif
->dev_role_id
);
2047 ret
= wl12xx_cmd_role_stop_dev(wl
, wlvif
);
2051 ret
= wl12xx_cmd_role_disable(wl
, &wlvif
->dev_role_id
);