2 * This file is part of wl1271
4 * Copyright (C) 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 <linux/kernel.h>
25 #include <linux/module.h>
28 #include "wl1271_io.h"
29 #include "wl1271_reg.h"
30 #include "wl1271_ps.h"
31 #include "wl1271_tx.h"
33 static int wl1271_tx_id(struct wl1271
*wl
, struct sk_buff
*skb
)
36 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
37 if (wl
->tx_frames
[i
] == NULL
) {
38 wl
->tx_frames
[i
] = skb
;
45 static int wl1271_tx_allocate(struct wl1271
*wl
, struct sk_buff
*skb
, u32 extra
)
47 struct wl1271_tx_hw_descr
*desc
;
48 u32 total_len
= skb
->len
+ sizeof(struct wl1271_tx_hw_descr
) + extra
;
49 u32 total_blocks
, excluded
;
52 /* allocate free identifier for the packet */
53 id
= wl1271_tx_id(wl
, skb
);
57 /* approximate the number of blocks required for this packet
59 /* FIXME: try to figure out what is done here and make it cleaner */
60 total_blocks
= (total_len
+ 20) >> TX_HW_BLOCK_SHIFT_DIV
;
61 excluded
= (total_blocks
<< 2) + ((total_len
+ 20) & 0xff) + 34;
62 total_blocks
+= (excluded
> 252) ? 2 : 1;
63 total_blocks
+= TX_HW_BLOCK_SPARE
;
65 if (total_blocks
<= wl
->tx_blocks_available
) {
66 desc
= (struct wl1271_tx_hw_descr
*)skb_push(
67 skb
, total_len
- skb
->len
);
69 desc
->extra_mem_blocks
= TX_HW_BLOCK_SPARE
;
70 desc
->total_mem_blocks
= total_blocks
;
73 wl
->tx_blocks_available
-= total_blocks
;
77 wl1271_debug(DEBUG_TX
,
78 "tx_allocate: size: %d, blocks: %d, id: %d",
79 total_len
, total_blocks
, id
);
81 wl
->tx_frames
[id
] = NULL
;
86 static int wl1271_tx_fill_hdr(struct wl1271
*wl
, struct sk_buff
*skb
,
87 u32 extra
, struct ieee80211_tx_info
*control
)
90 struct wl1271_tx_hw_descr
*desc
;
95 desc
= (struct wl1271_tx_hw_descr
*) skb
->data
;
97 /* relocate space for security header */
99 void *framestart
= skb
->data
+ sizeof(*desc
);
100 u16 fc
= *(u16
*)(framestart
+ extra
);
101 int hdrlen
= ieee80211_hdrlen(cpu_to_le16(fc
));
102 memmove(framestart
, framestart
+ extra
, hdrlen
);
105 /* configure packet life time */
107 hosttime
= (timespec_to_ns(&ts
) >> 10);
108 desc
->start_time
= cpu_to_le32(hosttime
- wl
->time_offset
);
109 desc
->life_time
= cpu_to_le16(TX_HW_MGMT_PKT_LIFETIME_TU
);
111 /* configure the tx attributes */
112 tx_attr
= wl
->session_counter
<< TX_HW_ATTR_OFST_SESSION_COUNTER
;
115 ac
= wl1271_tx_get_queue(skb_get_queue_mapping(skb
));
116 desc
->tid
= wl1271_tx_ac_to_tid(ac
);
118 desc
->aid
= TX_HW_DEFAULT_AID
;
121 /* align the length (and store in terms of words) */
122 pad
= WL1271_TX_ALIGN(skb
->len
);
123 desc
->length
= cpu_to_le16(pad
>> 2);
125 /* calculate number of padding bytes */
126 pad
= pad
- skb
->len
;
127 tx_attr
|= pad
<< TX_HW_ATTR_OFST_LAST_WORD_PAD
;
129 /* if the packets are destined for AP (have a STA entry) send them
130 with AP rate policies, otherwise use default basic rates */
131 if (control
->control
.sta
)
132 tx_attr
|= ACX_TX_AP_FULL_RATE
<< TX_HW_ATTR_OFST_RATE_POLICY
;
134 desc
->tx_attr
= cpu_to_le16(tx_attr
);
136 wl1271_debug(DEBUG_TX
, "tx_fill_hdr: pad: %d", pad
);
140 static int wl1271_tx_send_packet(struct wl1271
*wl
, struct sk_buff
*skb
,
141 struct ieee80211_tx_info
*control
)
144 struct wl1271_tx_hw_descr
*desc
;
147 /* FIXME: This is a workaround for getting non-aligned packets.
148 This happens at least with EAPOL packets from the user space.
149 Our DMA requires packets to be aligned on a 4-byte boundary.
151 if (unlikely((long)skb
->data
& 0x03)) {
152 int offset
= (4 - (long)skb
->data
) & 0x03;
153 wl1271_debug(DEBUG_TX
, "skb offset %d", offset
);
155 /* check whether the current skb can be used */
156 if (!skb_cloned(skb
) && (skb_tailroom(skb
) >= offset
)) {
157 unsigned char *src
= skb
->data
;
159 /* align the buffer on a 4-byte boundary */
160 skb_reserve(skb
, offset
);
161 memmove(skb
->data
, src
, skb
->len
);
163 wl1271_info("No handler, fixme!");
168 len
= WL1271_TX_ALIGN(skb
->len
);
170 /* perform a fixed address block write with the packet */
171 wl1271_write(wl
, WL1271_SLV_MEM_DATA
, skb
->data
, len
, true);
173 /* write packet new counter into the write access register */
174 wl
->tx_packets_count
++;
176 desc
= (struct wl1271_tx_hw_descr
*) skb
->data
;
177 wl1271_debug(DEBUG_TX
, "tx id %u skb 0x%p payload %u (%u words)",
178 desc
->id
, skb
, len
, desc
->length
);
183 /* caller must hold wl->mutex */
184 static int wl1271_tx_frame(struct wl1271
*wl
, struct sk_buff
*skb
)
186 struct ieee80211_tx_info
*info
;
194 info
= IEEE80211_SKB_CB(skb
);
196 if (info
->control
.hw_key
&&
197 info
->control
.hw_key
->alg
== ALG_TKIP
)
198 extra
= WL1271_TKIP_IV_SPACE
;
200 if (info
->control
.hw_key
) {
201 idx
= info
->control
.hw_key
->hw_key_idx
;
203 /* FIXME: do we have to do this if we're not using WEP? */
204 if (unlikely(wl
->default_key
!= idx
)) {
205 ret
= wl1271_cmd_set_default_wep_key(wl
, idx
);
208 wl
->default_key
= idx
;
212 ret
= wl1271_tx_allocate(wl
, skb
, extra
);
216 ret
= wl1271_tx_fill_hdr(wl
, skb
, extra
, info
);
220 ret
= wl1271_tx_send_packet(wl
, skb
, info
);
227 static u32
wl1271_tx_enabled_rates_get(struct wl1271
*wl
, u32 rate_set
)
229 struct ieee80211_supported_band
*band
;
230 u32 enabled_rates
= 0;
233 band
= wl
->hw
->wiphy
->bands
[wl
->band
];
234 for (bit
= 0; bit
< band
->n_bitrates
; bit
++) {
236 enabled_rates
|= band
->bitrates
[bit
].hw_value
;
240 return enabled_rates
;
243 void wl1271_tx_work(struct work_struct
*work
)
245 struct wl1271
*wl
= container_of(work
, struct wl1271
, tx_work
);
247 bool woken_up
= false;
249 u32 prev_tx_packets_count
;
252 /* check if the rates supported by the AP have changed */
253 if (unlikely(test_and_clear_bit(WL1271_FLAG_STA_RATES_CHANGED
,
256 spin_lock_irqsave(&wl
->wl_lock
, flags
);
257 sta_rates
= wl
->sta_rate_set
;
258 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
261 mutex_lock(&wl
->mutex
);
263 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
266 prev_tx_packets_count
= wl
->tx_packets_count
;
268 /* if rates have changed, re-configure the rate policy */
269 if (unlikely(sta_rates
)) {
270 wl
->rate_set
= wl1271_tx_enabled_rates_get(wl
, sta_rates
);
271 wl1271_acx_rate_policies(wl
);
274 while ((skb
= skb_dequeue(&wl
->tx_queue
))) {
276 ret
= wl1271_ps_elp_wakeup(wl
, false);
282 ret
= wl1271_tx_frame(wl
, skb
);
284 /* firmware buffer is full, lets stop transmitting. */
285 skb_queue_head(&wl
->tx_queue
, skb
);
287 } else if (ret
< 0) {
294 /* interrupt the firmware with the new packets */
295 if (prev_tx_packets_count
!= wl
->tx_packets_count
)
296 wl1271_write32(wl
, WL1271_HOST_WR_ACCESS
, wl
->tx_packets_count
);
300 wl1271_ps_elp_sleep(wl
);
302 mutex_unlock(&wl
->mutex
);
305 static void wl1271_tx_complete_packet(struct wl1271
*wl
,
306 struct wl1271_tx_hw_res_descr
*result
)
308 struct ieee80211_tx_info
*info
;
313 /* check for id legality */
314 if (unlikely(id
>= ACX_TX_DESCRIPTORS
|| wl
->tx_frames
[id
] == NULL
)) {
315 wl1271_warning("TX result illegal id: %d", id
);
319 skb
= wl
->tx_frames
[id
];
320 info
= IEEE80211_SKB_CB(skb
);
322 /* update packet status */
323 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
)) {
324 if (result
->status
== TX_SUCCESS
)
325 info
->flags
|= IEEE80211_TX_STAT_ACK
;
326 if (result
->status
& TX_RETRY_EXCEEDED
) {
328 /* info->status.excessive_retries = 1; */
329 wl
->stats
.excessive_retries
++;
334 /* info->status.retry_count = result->ack_failures; */
335 wl
->stats
.retry_count
+= result
->ack_failures
;
337 /* update security sequence number */
338 seq
= wl
->tx_security_seq_16
+
339 (result
->lsb_security_sequence_number
-
340 wl
->tx_security_last_seq
);
341 wl
->tx_security_last_seq
= result
->lsb_security_sequence_number
;
343 if (seq
< wl
->tx_security_seq_16
)
344 wl
->tx_security_seq_32
++;
345 wl
->tx_security_seq_16
= seq
;
347 /* remove private header from packet */
348 skb_pull(skb
, sizeof(struct wl1271_tx_hw_descr
));
350 /* remove TKIP header space if present */
351 if (info
->control
.hw_key
&&
352 info
->control
.hw_key
->alg
== ALG_TKIP
) {
353 int hdrlen
= ieee80211_get_hdrlen_from_skb(skb
);
354 memmove(skb
->data
+ WL1271_TKIP_IV_SPACE
, skb
->data
, hdrlen
);
355 skb_pull(skb
, WL1271_TKIP_IV_SPACE
);
358 wl1271_debug(DEBUG_TX
, "tx status id %u skb 0x%p failures %u rate 0x%x"
360 result
->id
, skb
, result
->ack_failures
,
361 result
->rate_class_index
, result
->status
);
363 /* return the packet to the stack */
364 ieee80211_tx_status(wl
->hw
, skb
);
365 wl
->tx_frames
[result
->id
] = NULL
;
368 /* Called upon reception of a TX complete interrupt */
369 void wl1271_tx_complete(struct wl1271
*wl
)
371 struct wl1271_acx_mem_map
*memmap
=
372 (struct wl1271_acx_mem_map
*)wl
->target_mem_map
;
373 u32 count
, fw_counter
;
376 /* read the tx results from the chipset */
377 wl1271_read(wl
, le32_to_cpu(memmap
->tx_result
),
378 wl
->tx_res_if
, sizeof(*wl
->tx_res_if
), false);
379 fw_counter
= le32_to_cpu(wl
->tx_res_if
->tx_result_fw_counter
);
381 /* write host counter to chipset (to ack) */
382 wl1271_write32(wl
, le32_to_cpu(memmap
->tx_result
) +
383 offsetof(struct wl1271_tx_hw_res_if
,
384 tx_result_host_counter
), fw_counter
);
386 count
= fw_counter
- wl
->tx_results_count
;
387 wl1271_debug(DEBUG_TX
, "tx_complete received, packets: %d", count
);
389 /* verify that the result buffer is not getting overrun */
390 if (unlikely(count
> TX_HW_RESULT_QUEUE_LEN
))
391 wl1271_warning("TX result overflow from chipset: %d", count
);
393 /* process the results */
394 for (i
= 0; i
< count
; i
++) {
395 struct wl1271_tx_hw_res_descr
*result
;
396 u8 offset
= wl
->tx_results_count
& TX_HW_RESULT_QUEUE_LEN_MASK
;
398 /* process the packet */
399 result
= &(wl
->tx_res_if
->tx_results_queue
[offset
]);
400 wl1271_tx_complete_packet(wl
, result
);
402 wl
->tx_results_count
++;
405 if (test_bit(WL1271_FLAG_TX_QUEUE_STOPPED
, &wl
->flags
) &&
406 skb_queue_len(&wl
->tx_queue
) <= WL1271_TX_QUEUE_LOW_WATERMARK
) {
409 /* firmware buffer has space, restart queues */
410 wl1271_debug(DEBUG_TX
, "tx_complete: waking queues");
411 spin_lock_irqsave(&wl
->wl_lock
, flags
);
412 ieee80211_wake_queues(wl
->hw
);
413 clear_bit(WL1271_FLAG_TX_QUEUE_STOPPED
, &wl
->flags
);
414 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
415 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
419 /* caller must hold wl->mutex */
420 void wl1271_tx_flush(struct wl1271
*wl
)
424 struct ieee80211_tx_info
*info
;
427 /* control->flags = 0; FIXME */
429 while ((skb
= skb_dequeue(&wl
->tx_queue
))) {
430 info
= IEEE80211_SKB_CB(skb
);
432 wl1271_debug(DEBUG_TX
, "flushing skb 0x%p", skb
);
434 if (!(info
->flags
& IEEE80211_TX_CTL_REQ_TX_STATUS
))
437 ieee80211_tx_status(wl
->hw
, skb
);
440 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
441 if (wl
->tx_frames
[i
] != NULL
) {
442 skb
= wl
->tx_frames
[i
];
443 info
= IEEE80211_SKB_CB(skb
);
445 if (!(info
->flags
& IEEE80211_TX_CTL_REQ_TX_STATUS
))
448 ieee80211_tx_status(wl
->hw
, skb
);
449 wl
->tx_frames
[i
] = NULL
;