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_spi.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
)
89 struct wl1271_tx_hw_descr
*desc
;
93 desc
= (struct wl1271_tx_hw_descr
*) skb
->data
;
95 /* relocate space for security header */
97 void *framestart
= skb
->data
+ sizeof(*desc
);
98 u16 fc
= *(u16
*)(framestart
+ extra
);
99 int hdrlen
= ieee80211_hdrlen(cpu_to_le16(fc
));
100 memmove(framestart
, framestart
+ extra
, hdrlen
);
103 /* configure packet life time */
104 desc
->start_time
= cpu_to_le32(jiffies_to_usecs(jiffies
) -
106 desc
->life_time
= cpu_to_le16(TX_HW_MGMT_PKT_LIFETIME_TU
);
108 /* configure the tx attributes */
109 tx_attr
= wl
->session_counter
<< TX_HW_ATTR_OFST_SESSION_COUNTER
;
110 /* FIXME: do we know the packet priority? can we identify mgmt
111 packets, and use max prio for them at least? */
113 desc
->aid
= TX_HW_DEFAULT_AID
;
116 /* align the length (and store in terms of words) */
117 pad
= WL1271_TX_ALIGN(skb
->len
);
118 desc
->length
= cpu_to_le16(pad
>> 2);
120 /* calculate number of padding bytes */
121 pad
= pad
- skb
->len
;
122 tx_attr
|= pad
<< TX_HW_ATTR_OFST_LAST_WORD_PAD
;
124 desc
->tx_attr
= cpu_to_le16(tx_attr
);
126 wl1271_debug(DEBUG_TX
, "tx_fill_hdr: pad: %d", pad
);
130 static int wl1271_tx_send_packet(struct wl1271
*wl
, struct sk_buff
*skb
,
131 struct ieee80211_tx_info
*control
)
134 struct wl1271_tx_hw_descr
*desc
;
137 /* FIXME: This is a workaround for getting non-aligned packets.
138 This happens at least with EAPOL packets from the user space.
139 Our DMA requires packets to be aligned on a 4-byte boundary.
141 if (unlikely((long)skb
->data
& 0x03)) {
142 int offset
= (4 - (long)skb
->data
) & 0x03;
143 wl1271_debug(DEBUG_TX
, "skb offset %d", offset
);
145 /* check whether the current skb can be used */
146 if (!skb_cloned(skb
) && (skb_tailroom(skb
) >= offset
)) {
147 unsigned char *src
= skb
->data
;
149 /* align the buffer on a 4-byte boundary */
150 skb_reserve(skb
, offset
);
151 memmove(skb
->data
, src
, skb
->len
);
153 wl1271_info("No handler, fixme!");
158 len
= WL1271_TX_ALIGN(skb
->len
);
160 /* perform a fixed address block write with the packet */
161 wl1271_spi_write(wl
, WL1271_SLV_MEM_DATA
, skb
->data
, len
, true);
163 /* write packet new counter into the write access register */
164 wl
->tx_packets_count
++;
165 wl1271_spi_write32(wl
, WL1271_HOST_WR_ACCESS
, wl
->tx_packets_count
);
167 desc
= (struct wl1271_tx_hw_descr
*) skb
->data
;
168 wl1271_debug(DEBUG_TX
, "tx id %u skb 0x%p payload %u (%u words)",
169 desc
->id
, skb
, len
, desc
->length
);
174 /* caller must hold wl->mutex */
175 static int wl1271_tx_frame(struct wl1271
*wl
, struct sk_buff
*skb
)
177 struct ieee80211_tx_info
*info
;
185 info
= IEEE80211_SKB_CB(skb
);
187 if (info
->control
.hw_key
&&
188 info
->control
.hw_key
->alg
== ALG_TKIP
)
189 extra
= WL1271_TKIP_IV_SPACE
;
191 if (info
->control
.hw_key
) {
192 idx
= info
->control
.hw_key
->hw_key_idx
;
194 /* FIXME: do we have to do this if we're not using WEP? */
195 if (unlikely(wl
->default_key
!= idx
)) {
196 ret
= wl1271_cmd_set_default_wep_key(wl
, idx
);
202 ret
= wl1271_tx_allocate(wl
, skb
, extra
);
206 ret
= wl1271_tx_fill_hdr(wl
, skb
, extra
, info
);
210 ret
= wl1271_tx_send_packet(wl
, skb
, info
);
217 void wl1271_tx_work(struct work_struct
*work
)
219 struct wl1271
*wl
= container_of(work
, struct wl1271
, tx_work
);
221 bool woken_up
= false;
224 mutex_lock(&wl
->mutex
);
226 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
229 while ((skb
= skb_dequeue(&wl
->tx_queue
))) {
231 ret
= wl1271_ps_elp_wakeup(wl
, false);
237 ret
= wl1271_tx_frame(wl
, skb
);
239 /* firmware buffer is full, stop queues */
240 wl1271_debug(DEBUG_TX
, "tx_work: fw buffer full, "
242 ieee80211_stop_queues(wl
->hw
);
243 wl
->tx_queue_stopped
= true;
244 skb_queue_head(&wl
->tx_queue
, skb
);
246 } else if (ret
< 0) {
249 } else if (wl
->tx_queue_stopped
) {
250 /* firmware buffer has space, restart queues */
251 wl1271_debug(DEBUG_TX
,
252 "complete_packet: waking queues");
253 ieee80211_wake_queues(wl
->hw
);
254 wl
->tx_queue_stopped
= false;
260 wl1271_ps_elp_sleep(wl
);
262 mutex_unlock(&wl
->mutex
);
265 static void wl1271_tx_complete_packet(struct wl1271
*wl
,
266 struct wl1271_tx_hw_res_descr
*result
)
268 struct ieee80211_tx_info
*info
;
273 /* check for id legality */
274 if (id
>= ACX_TX_DESCRIPTORS
|| wl
->tx_frames
[id
] == NULL
) {
275 wl1271_warning("TX result illegal id: %d", id
);
279 skb
= wl
->tx_frames
[id
];
280 info
= IEEE80211_SKB_CB(skb
);
282 /* update packet status */
283 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
)) {
284 if (result
->status
== TX_SUCCESS
)
285 info
->flags
|= IEEE80211_TX_STAT_ACK
;
286 if (result
->status
& TX_RETRY_EXCEEDED
) {
288 /* info->status.excessive_retries = 1; */
289 wl
->stats
.excessive_retries
++;
294 /* info->status.retry_count = result->ack_failures; */
295 wl
->stats
.retry_count
+= result
->ack_failures
;
297 /* update security sequence number */
298 seq
= wl
->tx_security_seq_16
+
299 (result
->lsb_security_sequence_number
-
300 wl
->tx_security_last_seq
);
301 wl
->tx_security_last_seq
= result
->lsb_security_sequence_number
;
303 if (seq
< wl
->tx_security_seq_16
)
304 wl
->tx_security_seq_32
++;
305 wl
->tx_security_seq_16
= seq
;
307 /* remove private header from packet */
308 skb_pull(skb
, sizeof(struct wl1271_tx_hw_descr
));
310 /* remove TKIP header space if present */
311 if (info
->control
.hw_key
&&
312 info
->control
.hw_key
->alg
== ALG_TKIP
) {
313 int hdrlen
= ieee80211_get_hdrlen_from_skb(skb
);
314 memmove(skb
->data
+ WL1271_TKIP_IV_SPACE
, skb
->data
, hdrlen
);
315 skb_pull(skb
, WL1271_TKIP_IV_SPACE
);
318 wl1271_debug(DEBUG_TX
, "tx status id %u skb 0x%p failures %u rate 0x%x"
320 result
->id
, skb
, result
->ack_failures
,
321 result
->rate_class_index
, result
->status
);
323 /* return the packet to the stack */
324 ieee80211_tx_status(wl
->hw
, skb
);
325 wl
->tx_frames
[result
->id
] = NULL
;
328 /* Called upon reception of a TX complete interrupt */
329 void wl1271_tx_complete(struct wl1271
*wl
, u32 count
)
331 struct wl1271_acx_mem_map
*memmap
=
332 (struct wl1271_acx_mem_map
*)wl
->target_mem_map
;
335 wl1271_debug(DEBUG_TX
, "tx_complete received, packets: %d", count
);
337 /* read the tx results from the chipset */
338 wl1271_spi_read(wl
, le32_to_cpu(memmap
->tx_result
),
339 wl
->tx_res_if
, sizeof(*wl
->tx_res_if
), false);
341 /* verify that the result buffer is not getting overrun */
342 if (count
> TX_HW_RESULT_QUEUE_LEN
) {
343 wl1271_warning("TX result overflow from chipset: %d", count
);
344 count
= TX_HW_RESULT_QUEUE_LEN
;
347 /* process the results */
348 for (i
= 0; i
< count
; i
++) {
349 struct wl1271_tx_hw_res_descr
*result
;
350 u8 offset
= wl
->tx_results_count
& TX_HW_RESULT_QUEUE_LEN_MASK
;
352 /* process the packet */
353 result
= &(wl
->tx_res_if
->tx_results_queue
[offset
]);
354 wl1271_tx_complete_packet(wl
, result
);
356 wl
->tx_results_count
++;
359 /* write host counter to chipset (to ack) */
360 wl1271_spi_write32(wl
, le32_to_cpu(memmap
->tx_result
) +
361 offsetof(struct wl1271_tx_hw_res_if
,
362 tx_result_host_counter
),
363 le32_to_cpu(wl
->tx_res_if
->tx_result_fw_counter
));
366 /* caller must hold wl->mutex */
367 void wl1271_tx_flush(struct wl1271
*wl
)
371 struct ieee80211_tx_info
*info
;
374 /* control->flags = 0; FIXME */
376 while ((skb
= skb_dequeue(&wl
->tx_queue
))) {
377 info
= IEEE80211_SKB_CB(skb
);
379 wl1271_debug(DEBUG_TX
, "flushing skb 0x%p", skb
);
381 if (!(info
->flags
& IEEE80211_TX_CTL_REQ_TX_STATUS
))
384 ieee80211_tx_status(wl
->hw
, skb
);
387 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
388 if (wl
->tx_frames
[i
] != NULL
) {
389 skb
= wl
->tx_frames
[i
];
390 info
= IEEE80211_SKB_CB(skb
);
392 if (!(info
->flags
& IEEE80211_TX_CTL_REQ_TX_STATUS
))
395 ieee80211_tx_status(wl
->hw
, skb
);
396 wl
->tx_frames
[i
] = NULL
;