2 * Copyright (C) 2008, cozybit Inc.
3 * Copyright (C) 2003-2006, Marvell International Ltd.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or (at
8 * your option) any later version.
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/hardirq.h>
13 #include <linux/slab.h>
15 #include <linux/etherdevice.h>
16 #include "libertas_tf.h"
18 #define DRIVER_RELEASE_VERSION "004.p0"
19 /* thinfirm version: 5.132.X.pX */
20 #define LBTF_FW_VER_MIN 0x05840300
21 #define LBTF_FW_VER_MAX 0x0584ffff
22 #define QOS_CONTROL_LEN 2
24 /* Module parameters */
25 unsigned int lbtf_debug
;
26 EXPORT_SYMBOL_GPL(lbtf_debug
);
27 module_param_named(libertas_tf_debug
, lbtf_debug
, int, 0644);
29 static const char lbtf_driver_version
[] = "THINFIRM-USB8388-" DRIVER_RELEASE_VERSION
35 struct workqueue_struct
*lbtf_wq
;
37 static const struct ieee80211_channel lbtf_channels
[] = {
38 { .center_freq
= 2412, .hw_value
= 1 },
39 { .center_freq
= 2417, .hw_value
= 2 },
40 { .center_freq
= 2422, .hw_value
= 3 },
41 { .center_freq
= 2427, .hw_value
= 4 },
42 { .center_freq
= 2432, .hw_value
= 5 },
43 { .center_freq
= 2437, .hw_value
= 6 },
44 { .center_freq
= 2442, .hw_value
= 7 },
45 { .center_freq
= 2447, .hw_value
= 8 },
46 { .center_freq
= 2452, .hw_value
= 9 },
47 { .center_freq
= 2457, .hw_value
= 10 },
48 { .center_freq
= 2462, .hw_value
= 11 },
49 { .center_freq
= 2467, .hw_value
= 12 },
50 { .center_freq
= 2472, .hw_value
= 13 },
51 { .center_freq
= 2484, .hw_value
= 14 },
54 /* This table contains the hardware specific values for the modulation rates. */
55 static const struct ieee80211_rate lbtf_rates
[] = {
60 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
63 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
66 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
93 static void lbtf_cmd_work(struct work_struct
*work
)
95 struct lbtf_private
*priv
= container_of(work
, struct lbtf_private
,
98 lbtf_deb_enter(LBTF_DEB_CMD
);
100 spin_lock_irq(&priv
->driver_lock
);
101 /* command response? */
102 if (priv
->cmd_response_rxed
) {
103 priv
->cmd_response_rxed
= 0;
104 spin_unlock_irq(&priv
->driver_lock
);
105 lbtf_process_rx_command(priv
);
106 spin_lock_irq(&priv
->driver_lock
);
109 if (priv
->cmd_timed_out
&& priv
->cur_cmd
) {
110 struct cmd_ctrl_node
*cmdnode
= priv
->cur_cmd
;
112 if (++priv
->nr_retries
> 10) {
113 lbtf_complete_command(priv
, cmdnode
,
115 priv
->nr_retries
= 0;
117 priv
->cur_cmd
= NULL
;
119 /* Stick it back at the _top_ of the pending
120 * queue for immediate resubmission */
121 list_add(&cmdnode
->list
, &priv
->cmdpendingq
);
124 priv
->cmd_timed_out
= 0;
125 spin_unlock_irq(&priv
->driver_lock
);
127 if (!priv
->fw_ready
) {
128 lbtf_deb_leave_args(LBTF_DEB_CMD
, "fw not ready");
132 /* Execute the next command */
134 lbtf_execute_next_command(priv
);
136 lbtf_deb_leave(LBTF_DEB_CMD
);
140 * lbtf_setup_firmware: initialize firmware.
142 * @priv A pointer to struct lbtf_private structure
144 * Returns: 0 on success.
146 static int lbtf_setup_firmware(struct lbtf_private
*priv
)
150 lbtf_deb_enter(LBTF_DEB_FW
);
152 * Read priv address from HW
154 memset(priv
->current_addr
, 0xff, ETH_ALEN
);
155 ret
= lbtf_update_hw_spec(priv
);
161 lbtf_set_mac_control(priv
);
162 lbtf_set_radio_control(priv
);
166 lbtf_deb_leave_args(LBTF_DEB_FW
, "ret: %d", ret
);
171 * This function handles the timeout of command sending.
172 * It will re-send the same command again.
174 static void command_timer_fn(unsigned long data
)
176 struct lbtf_private
*priv
= (struct lbtf_private
*)data
;
178 lbtf_deb_enter(LBTF_DEB_CMD
);
180 spin_lock_irqsave(&priv
->driver_lock
, flags
);
182 if (!priv
->cur_cmd
) {
183 printk(KERN_DEBUG
"libertastf: command timer expired; "
184 "no pending command\n");
188 printk(KERN_DEBUG
"libertas: command %x timed out\n",
189 le16_to_cpu(priv
->cur_cmd
->cmdbuf
->command
));
191 priv
->cmd_timed_out
= 1;
192 queue_work(lbtf_wq
, &priv
->cmd_work
);
194 spin_unlock_irqrestore(&priv
->driver_lock
, flags
);
195 lbtf_deb_leave(LBTF_DEB_CMD
);
198 static int lbtf_init_adapter(struct lbtf_private
*priv
)
200 lbtf_deb_enter(LBTF_DEB_MAIN
);
201 memset(priv
->current_addr
, 0xff, ETH_ALEN
);
202 mutex_init(&priv
->lock
);
205 setup_timer(&priv
->command_timer
, command_timer_fn
,
206 (unsigned long)priv
);
208 INIT_LIST_HEAD(&priv
->cmdfreeq
);
209 INIT_LIST_HEAD(&priv
->cmdpendingq
);
211 spin_lock_init(&priv
->driver_lock
);
213 /* Allocate the command buffers */
214 if (lbtf_allocate_cmd_buffer(priv
))
217 lbtf_deb_leave(LBTF_DEB_MAIN
);
221 static void lbtf_free_adapter(struct lbtf_private
*priv
)
223 lbtf_deb_enter(LBTF_DEB_MAIN
);
224 lbtf_free_cmd_buffer(priv
);
225 del_timer(&priv
->command_timer
);
226 lbtf_deb_leave(LBTF_DEB_MAIN
);
229 static void lbtf_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
231 struct lbtf_private
*priv
= hw
->priv
;
233 priv
->skb_to_tx
= skb
;
234 queue_work(lbtf_wq
, &priv
->tx_work
);
236 * queue will be restarted when we receive transmission feedback if
237 * there are no buffered multicast frames to send
239 ieee80211_stop_queues(priv
->hw
);
242 static void lbtf_tx_work(struct work_struct
*work
)
244 struct lbtf_private
*priv
= container_of(work
, struct lbtf_private
,
247 struct ieee80211_tx_info
*info
;
249 struct sk_buff
*skb
= NULL
;
252 lbtf_deb_enter(LBTF_DEB_MACOPS
| LBTF_DEB_TX
);
254 if ((priv
->vif
->type
== NL80211_IFTYPE_AP
) &&
255 (!skb_queue_empty(&priv
->bc_ps_buf
)))
256 skb
= skb_dequeue(&priv
->bc_ps_buf
);
257 else if (priv
->skb_to_tx
) {
258 skb
= priv
->skb_to_tx
;
259 priv
->skb_to_tx
= NULL
;
261 lbtf_deb_leave(LBTF_DEB_MACOPS
| LBTF_DEB_TX
);
266 info
= IEEE80211_SKB_CB(skb
);
267 txpd
= (struct txpd
*) skb_push(skb
, sizeof(struct txpd
));
269 if (priv
->surpriseremoved
) {
270 dev_kfree_skb_any(skb
);
271 lbtf_deb_leave(LBTF_DEB_MACOPS
| LBTF_DEB_TX
);
275 memset(txpd
, 0, sizeof(struct txpd
));
276 /* Activate per-packet rate selection */
277 txpd
->tx_control
|= cpu_to_le32(MRVL_PER_PACKET_RATE
|
278 ieee80211_get_tx_rate(priv
->hw
, info
)->hw_value
);
280 /* copy destination address from 802.11 header */
281 memcpy(txpd
->tx_dest_addr_high
, skb
->data
+ sizeof(struct txpd
) + 4,
283 txpd
->tx_packet_length
= cpu_to_le16(len
);
284 txpd
->tx_packet_location
= cpu_to_le32(sizeof(struct txpd
));
285 lbtf_deb_hex(LBTF_DEB_TX
, "TX Data", skb
->data
, min_t(unsigned int, skb
->len
, 100));
286 BUG_ON(priv
->tx_skb
);
287 spin_lock_irq(&priv
->driver_lock
);
289 err
= priv
->hw_host_to_card(priv
, MVMS_DAT
, skb
->data
, skb
->len
);
290 spin_unlock_irq(&priv
->driver_lock
);
292 dev_kfree_skb_any(skb
);
294 pr_err("TX error: %d", err
);
296 lbtf_deb_leave(LBTF_DEB_MACOPS
| LBTF_DEB_TX
);
299 static int lbtf_op_start(struct ieee80211_hw
*hw
)
301 struct lbtf_private
*priv
= hw
->priv
;
302 void *card
= priv
->card
;
305 lbtf_deb_enter(LBTF_DEB_MACOPS
);
308 /* Upload firmware */
309 if (priv
->hw_prog_firmware(card
))
310 goto err_prog_firmware
;
312 /* poke the firmware */
313 priv
->capability
= WLAN_CAPABILITY_SHORT_PREAMBLE
;
314 priv
->radioon
= RADIO_ON
;
315 priv
->mac_control
= CMD_ACT_MAC_RX_ON
| CMD_ACT_MAC_TX_ON
;
316 ret
= lbtf_setup_firmware(priv
);
318 goto err_prog_firmware
;
320 if ((priv
->fwrelease
< LBTF_FW_VER_MIN
) ||
321 (priv
->fwrelease
> LBTF_FW_VER_MAX
)) {
323 goto err_prog_firmware
;
326 printk(KERN_INFO
"libertastf: Marvell WLAN 802.11 thinfirm adapter\n");
327 lbtf_deb_leave(LBTF_DEB_MACOPS
);
331 priv
->hw_reset_device(card
);
332 lbtf_deb_leave_args(LBTF_DEB_MACOPS
, "error programing fw; ret=%d", ret
);
336 static void lbtf_op_stop(struct ieee80211_hw
*hw
)
338 struct lbtf_private
*priv
= hw
->priv
;
342 struct cmd_ctrl_node
*cmdnode
;
344 lbtf_deb_enter(LBTF_DEB_MACOPS
);
346 /* Flush pending command nodes */
347 spin_lock_irqsave(&priv
->driver_lock
, flags
);
348 list_for_each_entry(cmdnode
, &priv
->cmdpendingq
, list
) {
349 cmdnode
->result
= -ENOENT
;
350 cmdnode
->cmdwaitqwoken
= 1;
351 wake_up_interruptible(&cmdnode
->cmdwait_q
);
354 spin_unlock_irqrestore(&priv
->driver_lock
, flags
);
355 cancel_work_sync(&priv
->cmd_work
);
356 cancel_work_sync(&priv
->tx_work
);
357 while ((skb
= skb_dequeue(&priv
->bc_ps_buf
)))
358 dev_kfree_skb_any(skb
);
359 priv
->radioon
= RADIO_OFF
;
360 lbtf_set_radio_control(priv
);
362 lbtf_deb_leave(LBTF_DEB_MACOPS
);
365 static int lbtf_op_add_interface(struct ieee80211_hw
*hw
,
366 struct ieee80211_vif
*vif
)
368 struct lbtf_private
*priv
= hw
->priv
;
369 lbtf_deb_enter(LBTF_DEB_MACOPS
);
370 if (priv
->vif
!= NULL
)
375 case NL80211_IFTYPE_MESH_POINT
:
376 case NL80211_IFTYPE_AP
:
377 lbtf_set_mode(priv
, LBTF_AP_MODE
);
379 case NL80211_IFTYPE_STATION
:
380 lbtf_set_mode(priv
, LBTF_STA_MODE
);
386 lbtf_set_mac_address(priv
, (u8
*) vif
->addr
);
387 lbtf_deb_leave(LBTF_DEB_MACOPS
);
391 static void lbtf_op_remove_interface(struct ieee80211_hw
*hw
,
392 struct ieee80211_vif
*vif
)
394 struct lbtf_private
*priv
= hw
->priv
;
395 lbtf_deb_enter(LBTF_DEB_MACOPS
);
397 if (priv
->vif
->type
== NL80211_IFTYPE_AP
||
398 priv
->vif
->type
== NL80211_IFTYPE_MESH_POINT
)
399 lbtf_beacon_ctrl(priv
, 0, 0);
400 lbtf_set_mode(priv
, LBTF_PASSIVE_MODE
);
401 lbtf_set_bssid(priv
, 0, NULL
);
403 lbtf_deb_leave(LBTF_DEB_MACOPS
);
406 static int lbtf_op_config(struct ieee80211_hw
*hw
, u32 changed
)
408 struct lbtf_private
*priv
= hw
->priv
;
409 struct ieee80211_conf
*conf
= &hw
->conf
;
410 lbtf_deb_enter(LBTF_DEB_MACOPS
);
412 if (conf
->channel
->center_freq
!= priv
->cur_freq
) {
413 priv
->cur_freq
= conf
->channel
->center_freq
;
414 lbtf_set_channel(priv
, conf
->channel
->hw_value
);
416 lbtf_deb_leave(LBTF_DEB_MACOPS
);
420 static u64
lbtf_op_prepare_multicast(struct ieee80211_hw
*hw
,
421 struct netdev_hw_addr_list
*mc_list
)
423 struct lbtf_private
*priv
= hw
->priv
;
425 struct netdev_hw_addr
*ha
;
426 int mc_count
= netdev_hw_addr_list_count(mc_list
);
428 if (!mc_count
|| mc_count
> MRVDRV_MAX_MULTICAST_LIST_SIZE
)
431 priv
->nr_of_multicastmacaddr
= mc_count
;
433 netdev_hw_addr_list_for_each(ha
, mc_list
)
434 memcpy(&priv
->multicastlist
[i
++], ha
->addr
, ETH_ALEN
);
439 #define SUPPORTED_FIF_FLAGS (FIF_PROMISC_IN_BSS | FIF_ALLMULTI)
440 static void lbtf_op_configure_filter(struct ieee80211_hw
*hw
,
441 unsigned int changed_flags
,
442 unsigned int *new_flags
,
445 struct lbtf_private
*priv
= hw
->priv
;
446 int old_mac_control
= priv
->mac_control
;
448 lbtf_deb_enter(LBTF_DEB_MACOPS
);
450 changed_flags
&= SUPPORTED_FIF_FLAGS
;
451 *new_flags
&= SUPPORTED_FIF_FLAGS
;
453 if (!changed_flags
) {
454 lbtf_deb_leave(LBTF_DEB_MACOPS
);
458 if (*new_flags
& (FIF_PROMISC_IN_BSS
))
459 priv
->mac_control
|= CMD_ACT_MAC_PROMISCUOUS_ENABLE
;
461 priv
->mac_control
&= ~CMD_ACT_MAC_PROMISCUOUS_ENABLE
;
462 if (*new_flags
& (FIF_ALLMULTI
) ||
463 multicast
> MRVDRV_MAX_MULTICAST_LIST_SIZE
) {
464 priv
->mac_control
|= CMD_ACT_MAC_ALL_MULTICAST_ENABLE
;
465 priv
->mac_control
&= ~CMD_ACT_MAC_MULTICAST_ENABLE
;
466 } else if (multicast
) {
467 priv
->mac_control
|= CMD_ACT_MAC_MULTICAST_ENABLE
;
468 priv
->mac_control
&= ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE
;
469 lbtf_cmd_set_mac_multicast_addr(priv
);
471 priv
->mac_control
&= ~(CMD_ACT_MAC_MULTICAST_ENABLE
|
472 CMD_ACT_MAC_ALL_MULTICAST_ENABLE
);
473 if (priv
->nr_of_multicastmacaddr
) {
474 priv
->nr_of_multicastmacaddr
= 0;
475 lbtf_cmd_set_mac_multicast_addr(priv
);
480 if (priv
->mac_control
!= old_mac_control
)
481 lbtf_set_mac_control(priv
);
483 lbtf_deb_leave(LBTF_DEB_MACOPS
);
486 static void lbtf_op_bss_info_changed(struct ieee80211_hw
*hw
,
487 struct ieee80211_vif
*vif
,
488 struct ieee80211_bss_conf
*bss_conf
,
491 struct lbtf_private
*priv
= hw
->priv
;
492 struct sk_buff
*beacon
;
493 lbtf_deb_enter(LBTF_DEB_MACOPS
);
495 if (changes
& (BSS_CHANGED_BEACON
| BSS_CHANGED_BEACON_INT
)) {
496 switch (priv
->vif
->type
) {
497 case NL80211_IFTYPE_AP
:
498 case NL80211_IFTYPE_MESH_POINT
:
499 beacon
= ieee80211_beacon_get(hw
, vif
);
501 lbtf_beacon_set(priv
, beacon
);
503 lbtf_beacon_ctrl(priv
, 1,
504 bss_conf
->beacon_int
);
512 if (changes
& BSS_CHANGED_BSSID
) {
513 bool activate
= !is_zero_ether_addr(bss_conf
->bssid
);
514 lbtf_set_bssid(priv
, activate
, bss_conf
->bssid
);
517 if (changes
& BSS_CHANGED_ERP_PREAMBLE
) {
518 if (bss_conf
->use_short_preamble
)
519 priv
->preamble
= CMD_TYPE_SHORT_PREAMBLE
;
521 priv
->preamble
= CMD_TYPE_LONG_PREAMBLE
;
522 lbtf_set_radio_control(priv
);
525 lbtf_deb_leave(LBTF_DEB_MACOPS
);
528 static int lbtf_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
529 struct survey_info
*survey
)
531 struct lbtf_private
*priv
= hw
->priv
;
532 struct ieee80211_conf
*conf
= &hw
->conf
;
537 survey
->channel
= conf
->channel
;
538 survey
->filled
= SURVEY_INFO_NOISE_DBM
;
539 survey
->noise
= priv
->noise
;
544 static const struct ieee80211_ops lbtf_ops
= {
546 .start
= lbtf_op_start
,
547 .stop
= lbtf_op_stop
,
548 .add_interface
= lbtf_op_add_interface
,
549 .remove_interface
= lbtf_op_remove_interface
,
550 .config
= lbtf_op_config
,
551 .prepare_multicast
= lbtf_op_prepare_multicast
,
552 .configure_filter
= lbtf_op_configure_filter
,
553 .bss_info_changed
= lbtf_op_bss_info_changed
,
554 .get_survey
= lbtf_op_get_survey
,
557 int lbtf_rx(struct lbtf_private
*priv
, struct sk_buff
*skb
)
559 struct ieee80211_rx_status stats
;
563 struct ieee80211_hdr
*hdr
;
565 lbtf_deb_enter(LBTF_DEB_RX
);
567 prxpd
= (struct rxpd
*) skb
->data
;
569 memset(&stats
, 0, sizeof(stats
));
570 if (!(prxpd
->status
& cpu_to_le16(MRVDRV_RXPD_STATUS_OK
)))
571 stats
.flag
|= RX_FLAG_FAILED_FCS_CRC
;
572 stats
.freq
= priv
->cur_freq
;
573 stats
.band
= IEEE80211_BAND_2GHZ
;
574 stats
.signal
= prxpd
->snr
;
575 priv
->noise
= prxpd
->nf
;
576 /* Marvell rate index has a hole at value 4 */
577 if (prxpd
->rx_rate
> 4)
579 stats
.rate_idx
= prxpd
->rx_rate
;
580 skb_pull(skb
, sizeof(struct rxpd
));
582 hdr
= (struct ieee80211_hdr
*)skb
->data
;
583 flags
= le32_to_cpu(*(__le32
*)(skb
->data
+ 4));
585 need_padding
= ieee80211_is_data_qos(hdr
->frame_control
);
586 need_padding
^= ieee80211_has_a4(hdr
->frame_control
);
587 need_padding
^= ieee80211_is_data_qos(hdr
->frame_control
) &&
588 (*ieee80211_get_qos_ctl(hdr
) &
589 IEEE80211_QOS_CTL_A_MSDU_PRESENT
);
592 memmove(skb
->data
+ 2, skb
->data
, skb
->len
);
596 memcpy(IEEE80211_SKB_RXCB(skb
), &stats
, sizeof(stats
));
598 lbtf_deb_rx("rx data: skb->len-sizeof(RxPd) = %d-%zd = %zd\n",
599 skb
->len
, sizeof(struct rxpd
), skb
->len
- sizeof(struct rxpd
));
600 lbtf_deb_hex(LBTF_DEB_RX
, "RX Data", skb
->data
,
601 min_t(unsigned int, skb
->len
, 100));
603 ieee80211_rx_irqsafe(priv
->hw
, skb
);
605 lbtf_deb_leave(LBTF_DEB_RX
);
608 EXPORT_SYMBOL_GPL(lbtf_rx
);
611 * lbtf_add_card: Add and initialize the card, no fw upload yet.
613 * @card A pointer to card
615 * Returns: pointer to struct lbtf_priv.
617 struct lbtf_private
*lbtf_add_card(void *card
, struct device
*dmdev
)
619 struct ieee80211_hw
*hw
;
620 struct lbtf_private
*priv
= NULL
;
622 lbtf_deb_enter(LBTF_DEB_MAIN
);
624 hw
= ieee80211_alloc_hw(sizeof(struct lbtf_private
), &lbtf_ops
);
629 if (lbtf_init_adapter(priv
))
630 goto err_init_adapter
;
637 hw
->flags
= IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING
;
638 hw
->extra_tx_headroom
= sizeof(struct txpd
);
639 memcpy(priv
->channels
, lbtf_channels
, sizeof(lbtf_channels
));
640 memcpy(priv
->rates
, lbtf_rates
, sizeof(lbtf_rates
));
641 priv
->band
.n_bitrates
= ARRAY_SIZE(lbtf_rates
);
642 priv
->band
.bitrates
= priv
->rates
;
643 priv
->band
.n_channels
= ARRAY_SIZE(lbtf_channels
);
644 priv
->band
.channels
= priv
->channels
;
645 hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &priv
->band
;
646 hw
->wiphy
->interface_modes
=
647 BIT(NL80211_IFTYPE_STATION
) |
648 BIT(NL80211_IFTYPE_ADHOC
);
649 skb_queue_head_init(&priv
->bc_ps_buf
);
651 SET_IEEE80211_DEV(hw
, dmdev
);
653 INIT_WORK(&priv
->cmd_work
, lbtf_cmd_work
);
654 INIT_WORK(&priv
->tx_work
, lbtf_tx_work
);
655 if (ieee80211_register_hw(hw
))
656 goto err_init_adapter
;
661 lbtf_free_adapter(priv
);
662 ieee80211_free_hw(hw
);
666 lbtf_deb_leave_args(LBTF_DEB_MAIN
, "priv %p", priv
);
669 EXPORT_SYMBOL_GPL(lbtf_add_card
);
672 int lbtf_remove_card(struct lbtf_private
*priv
)
674 struct ieee80211_hw
*hw
= priv
->hw
;
676 lbtf_deb_enter(LBTF_DEB_MAIN
);
678 priv
->surpriseremoved
= 1;
679 del_timer(&priv
->command_timer
);
680 lbtf_free_adapter(priv
);
682 ieee80211_unregister_hw(hw
);
683 ieee80211_free_hw(hw
);
685 lbtf_deb_leave(LBTF_DEB_MAIN
);
688 EXPORT_SYMBOL_GPL(lbtf_remove_card
);
690 void lbtf_send_tx_feedback(struct lbtf_private
*priv
, u8 retrycnt
, u8 fail
)
692 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(priv
->tx_skb
);
694 ieee80211_tx_info_clear_status(info
);
696 * Commented out, otherwise we never go beyond 1Mbit/s using mac80211
697 * default pid rc algorithm.
699 * info->status.retry_count = MRVL_DEFAULT_RETRIES - retrycnt;
701 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
) && !fail
)
702 info
->flags
|= IEEE80211_TX_STAT_ACK
;
703 skb_pull(priv
->tx_skb
, sizeof(struct txpd
));
704 ieee80211_tx_status_irqsafe(priv
->hw
, priv
->tx_skb
);
706 if (!priv
->skb_to_tx
&& skb_queue_empty(&priv
->bc_ps_buf
))
707 ieee80211_wake_queues(priv
->hw
);
709 queue_work(lbtf_wq
, &priv
->tx_work
);
711 EXPORT_SYMBOL_GPL(lbtf_send_tx_feedback
);
713 void lbtf_bcn_sent(struct lbtf_private
*priv
)
715 struct sk_buff
*skb
= NULL
;
717 if (priv
->vif
->type
!= NL80211_IFTYPE_AP
)
720 if (skb_queue_empty(&priv
->bc_ps_buf
)) {
723 while ((skb
= ieee80211_get_buffered_bc(priv
->hw
, priv
->vif
))) {
724 skb_queue_tail(&priv
->bc_ps_buf
, skb
);
728 ieee80211_stop_queues(priv
->hw
);
729 queue_work(lbtf_wq
, &priv
->tx_work
);
733 skb
= ieee80211_beacon_get(priv
->hw
, priv
->vif
);
736 lbtf_beacon_set(priv
, skb
);
740 EXPORT_SYMBOL_GPL(lbtf_bcn_sent
);
742 static int __init
lbtf_init_module(void)
744 lbtf_deb_enter(LBTF_DEB_MAIN
);
745 lbtf_wq
= create_workqueue("libertastf");
746 if (lbtf_wq
== NULL
) {
747 printk(KERN_ERR
"libertastf: couldn't create workqueue\n");
750 lbtf_deb_leave(LBTF_DEB_MAIN
);
754 static void __exit
lbtf_exit_module(void)
756 lbtf_deb_enter(LBTF_DEB_MAIN
);
757 destroy_workqueue(lbtf_wq
);
758 lbtf_deb_leave(LBTF_DEB_MAIN
);
761 module_init(lbtf_init_module
);
762 module_exit(lbtf_exit_module
);
764 MODULE_DESCRIPTION("Libertas WLAN Thinfirm Driver Library");
765 MODULE_AUTHOR("Cozybit Inc.");
766 MODULE_LICENSE("GPL");