Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 1 | /* |
Gertjan van Wingerde | 9c9a0d1 | 2009-11-08 16:39:55 +0100 | [diff] [blame] | 2 | Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com> |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 3 | <http://rt2x00.serialmonkey.com> |
| 4 | |
| 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 |
| 8 | (at your option) any later version. |
| 9 | |
| 10 | This program is distributed in the hope that it will be useful, |
| 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | GNU General Public License for more details. |
| 14 | |
| 15 | You should have received a copy of the GNU General Public License |
| 16 | along with this program; if not, write to the |
| 17 | Free Software Foundation, Inc., |
| 18 | 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 19 | */ |
| 20 | |
| 21 | /* |
| 22 | Module: rt2x00mac |
| 23 | Abstract: rt2x00 generic mac80211 routines. |
| 24 | */ |
| 25 | |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 26 | #include <linux/kernel.h> |
| 27 | #include <linux/module.h> |
| 28 | |
| 29 | #include "rt2x00.h" |
| 30 | #include "rt2x00lib.h" |
| 31 | |
| 32 | static int rt2x00mac_tx_rts_cts(struct rt2x00_dev *rt2x00dev, |
Ivo van Doorn | 181d690 | 2008-02-05 16:42:23 -0500 | [diff] [blame] | 33 | struct data_queue *queue, |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 34 | struct sk_buff *frag_skb) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 35 | { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 36 | struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(frag_skb); |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 37 | struct ieee80211_tx_info *rts_info; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 38 | struct sk_buff *skb; |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 39 | unsigned int data_length; |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 40 | int retval = 0; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 41 | |
Johannes Berg | e6a9854 | 2008-10-21 12:40:02 +0200 | [diff] [blame] | 42 | if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 43 | data_length = sizeof(struct ieee80211_cts); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 44 | else |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 45 | data_length = sizeof(struct ieee80211_rts); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 46 | |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 47 | skb = dev_alloc_skb(data_length + rt2x00dev->hw->extra_tx_headroom); |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 48 | if (unlikely(!skb)) { |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 49 | WARNING(rt2x00dev, "Failed to create RTS/CTS frame.\n"); |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 50 | return -ENOMEM; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 51 | } |
| 52 | |
| 53 | skb_reserve(skb, rt2x00dev->hw->extra_tx_headroom); |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 54 | skb_put(skb, data_length); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 55 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 56 | /* |
| 57 | * Copy TX information over from original frame to |
| 58 | * RTS/CTS frame. Note that we set the no encryption flag |
| 59 | * since we don't want this frame to be encrypted. |
| 60 | * RTS frames should be acked, while CTS-to-self frames |
| 61 | * should not. The ready for TX flag is cleared to prevent |
| 62 | * it being automatically send when the descriptor is |
| 63 | * written to the hardware. |
| 64 | */ |
| 65 | memcpy(skb->cb, frag_skb->cb, sizeof(skb->cb)); |
| 66 | rts_info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e6a9854 | 2008-10-21 12:40:02 +0200 | [diff] [blame] | 67 | rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_RTS_CTS; |
| 68 | rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_CTS_PROTECT; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 69 | |
Johannes Berg | e6a9854 | 2008-10-21 12:40:02 +0200 | [diff] [blame] | 70 | if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 71 | rts_info->flags |= IEEE80211_TX_CTL_NO_ACK; |
| 72 | else |
| 73 | rts_info->flags &= ~IEEE80211_TX_CTL_NO_ACK; |
| 74 | |
Johannes Berg | 18ad01c | 2009-06-16 20:46:45 +0200 | [diff] [blame] | 75 | /* Disable hardware encryption */ |
| 76 | rts_info->control.hw_key = NULL; |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 77 | |
| 78 | /* |
| 79 | * RTS/CTS frame should use the length of the frame plus any |
| 80 | * encryption overhead that will be added by the hardware. |
| 81 | */ |
Ivo van Doorn | 7b40982 | 2008-12-20 10:58:33 +0100 | [diff] [blame] | 82 | data_length += rt2x00crypto_tx_overhead(rt2x00dev, skb); |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 83 | |
Johannes Berg | e6a9854 | 2008-10-21 12:40:02 +0200 | [diff] [blame] | 84 | if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 85 | ieee80211_ctstoself_get(rt2x00dev->hw, tx_info->control.vif, |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 86 | frag_skb->data, data_length, tx_info, |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 87 | (struct ieee80211_cts *)(skb->data)); |
| 88 | else |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 89 | ieee80211_rts_get(rt2x00dev->hw, tx_info->control.vif, |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 90 | frag_skb->data, data_length, tx_info, |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 91 | (struct ieee80211_rts *)(skb->data)); |
| 92 | |
Johannes Berg | 7351c6b | 2009-11-19 01:08:30 +0100 | [diff] [blame] | 93 | retval = rt2x00queue_write_tx_frame(queue, skb, true); |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 94 | if (retval) { |
Ivo van Doorn | e7087a8 | 2008-07-20 18:03:58 +0200 | [diff] [blame] | 95 | dev_kfree_skb_any(skb); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 96 | WARNING(rt2x00dev, "Failed to send RTS/CTS frame.\n"); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 97 | } |
| 98 | |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 99 | return retval; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 100 | } |
| 101 | |
Johannes Berg | 7bb4568 | 2011-02-24 14:42:06 +0100 | [diff] [blame] | 102 | void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 103 | { |
| 104 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 105 | struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 106 | enum data_queue_qid qid = skb_get_queue_mapping(skb); |
Ivo van Doorn | 0b7fde5 | 2010-12-13 12:35:17 +0100 | [diff] [blame] | 107 | struct data_queue *queue = NULL; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 108 | |
| 109 | /* |
Ivo van Doorn | 066cb63 | 2007-09-25 20:55:39 +0200 | [diff] [blame] | 110 | * Mac80211 might be calling this function while we are trying |
| 111 | * to remove the device or perhaps suspending it. |
| 112 | * Note that we can only stop the TX queues inside the TX path |
| 113 | * due to possible race conditions in mac80211. |
| 114 | */ |
Ivo van Doorn | 0262ab0 | 2008-08-29 21:04:26 +0200 | [diff] [blame] | 115 | if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) |
Stanislaw Gruszka | 00898a4 | 2011-08-02 13:29:02 +0200 | [diff] [blame] | 116 | goto exit_free_skb; |
Ivo van Doorn | 066cb63 | 2007-09-25 20:55:39 +0200 | [diff] [blame] | 117 | |
| 118 | /* |
Gertjan van Wingerde | 61c6e48 | 2011-03-03 19:46:29 +0100 | [diff] [blame] | 119 | * Use the ATIM queue if appropriate and present. |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 120 | */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 121 | if (tx_info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM && |
Ivo van Doorn | 7dab73b | 2011-04-18 15:27:06 +0200 | [diff] [blame] | 122 | test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags)) |
Gertjan van Wingerde | 61c6e48 | 2011-03-03 19:46:29 +0100 | [diff] [blame] | 123 | qid = QID_ATIM; |
| 124 | |
| 125 | queue = rt2x00queue_get_tx_queue(rt2x00dev, qid); |
Ivo van Doorn | 181d690 | 2008-02-05 16:42:23 -0500 | [diff] [blame] | 126 | if (unlikely(!queue)) { |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 127 | ERROR(rt2x00dev, |
| 128 | "Attempt to send packet over invalid queue %d.\n" |
Ivo van Doorn | e58c6ac | 2008-04-21 19:00:47 +0200 | [diff] [blame] | 129 | "Please file bug report to %s.\n", qid, DRV_PROJECT); |
Stanislaw Gruszka | 00898a4 | 2011-08-02 13:29:02 +0200 | [diff] [blame] | 130 | goto exit_free_skb; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | /* |
Ivo van Doorn | 772a249 | 2008-06-03 20:29:57 +0200 | [diff] [blame] | 134 | * If CTS/RTS is required. create and queue that frame first. |
| 135 | * Make sure we have at least enough entries available to send |
| 136 | * this CTS/RTS frame as well as the data frame. |
Ivo van Doorn | 2d9ccf8 | 2008-04-21 18:59:48 +0200 | [diff] [blame] | 137 | * Note that when the driver has set the set_rts_threshold() |
| 138 | * callback function it doesn't need software generation of |
Ivo van Doorn | 772a249 | 2008-06-03 20:29:57 +0200 | [diff] [blame] | 139 | * either RTS or CTS-to-self frame and handles everything |
Ivo van Doorn | 2d9ccf8 | 2008-04-21 18:59:48 +0200 | [diff] [blame] | 140 | * inside the hardware. |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 141 | */ |
Helmut Schaa | 430df79 | 2011-02-20 13:55:46 +0100 | [diff] [blame] | 142 | if (!rt2x00dev->ops->hw->set_rts_threshold && |
| 143 | (tx_info->control.rates[0].flags & (IEEE80211_TX_RC_USE_RTS_CTS | |
| 144 | IEEE80211_TX_RC_USE_CTS_PROTECT))) { |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 145 | if (rt2x00queue_available(queue) <= 1) |
| 146 | goto exit_fail; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 147 | |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 148 | if (rt2x00mac_tx_rts_cts(rt2x00dev, queue, skb)) |
| 149 | goto exit_fail; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 150 | } |
| 151 | |
Helmut Schaa | 208f19d | 2011-03-03 19:41:03 +0100 | [diff] [blame] | 152 | if (unlikely(rt2x00queue_write_tx_frame(queue, skb, false))) |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 153 | goto exit_fail; |
Ivo van Doorn | 1230cb8 | 2008-01-06 23:38:34 +0100 | [diff] [blame] | 154 | |
Stanislaw Gruszka | 3780d03 | 2012-03-09 12:39:54 +0100 | [diff] [blame] | 155 | /* |
| 156 | * Pausing queue has to be serialized with rt2x00lib_txdone(). Note |
| 157 | * we should not use spin_lock_bh variant as bottom halve was already |
| 158 | * disabled before ieee80211_xmit() call. |
| 159 | */ |
| 160 | spin_lock(&queue->tx_lock); |
Ivo van Doorn | b869767 | 2008-06-06 22:53:14 +0200 | [diff] [blame] | 161 | if (rt2x00queue_threshold(queue)) |
Ivo van Doorn | 0b7fde5 | 2010-12-13 12:35:17 +0100 | [diff] [blame] | 162 | rt2x00queue_pause_queue(queue); |
Stanislaw Gruszka | 3780d03 | 2012-03-09 12:39:54 +0100 | [diff] [blame] | 163 | spin_unlock(&queue->tx_lock); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 164 | |
Johannes Berg | 7bb4568 | 2011-02-24 14:42:06 +0100 | [diff] [blame] | 165 | return; |
Daniel Wagner | b9740c2 | 2008-07-23 19:17:01 +0200 | [diff] [blame] | 166 | |
| 167 | exit_fail: |
Stanislaw Gruszka | 3780d03 | 2012-03-09 12:39:54 +0100 | [diff] [blame] | 168 | spin_lock(&queue->tx_lock); |
Helmut Schaa | 62fe778 | 2011-04-18 15:26:37 +0200 | [diff] [blame] | 169 | rt2x00queue_pause_queue(queue); |
Stanislaw Gruszka | 3780d03 | 2012-03-09 12:39:54 +0100 | [diff] [blame] | 170 | spin_unlock(&queue->tx_lock); |
Stanislaw Gruszka | 00898a4 | 2011-08-02 13:29:02 +0200 | [diff] [blame] | 171 | exit_free_skb: |
Helmut Schaa | e4522ab | 2011-12-14 16:28:41 +0100 | [diff] [blame] | 172 | ieee80211_free_txskb(hw, skb); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 173 | } |
| 174 | EXPORT_SYMBOL_GPL(rt2x00mac_tx); |
| 175 | |
| 176 | int rt2x00mac_start(struct ieee80211_hw *hw) |
| 177 | { |
| 178 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 179 | |
Ivo van Doorn | 0262ab0 | 2008-08-29 21:04:26 +0200 | [diff] [blame] | 180 | if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 181 | return 0; |
| 182 | |
Ivo van Doorn | e37ea21 | 2008-01-06 23:40:07 +0100 | [diff] [blame] | 183 | return rt2x00lib_start(rt2x00dev); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 184 | } |
| 185 | EXPORT_SYMBOL_GPL(rt2x00mac_start); |
| 186 | |
| 187 | void rt2x00mac_stop(struct ieee80211_hw *hw) |
| 188 | { |
| 189 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 190 | |
Ivo van Doorn | 0262ab0 | 2008-08-29 21:04:26 +0200 | [diff] [blame] | 191 | if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) |
Ivo van Doorn | 066cb63 | 2007-09-25 20:55:39 +0200 | [diff] [blame] | 192 | return; |
| 193 | |
Ivo van Doorn | e37ea21 | 2008-01-06 23:40:07 +0100 | [diff] [blame] | 194 | rt2x00lib_stop(rt2x00dev); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 195 | } |
| 196 | EXPORT_SYMBOL_GPL(rt2x00mac_stop); |
| 197 | |
| 198 | int rt2x00mac_add_interface(struct ieee80211_hw *hw, |
Johannes Berg | 1ed32e4 | 2009-12-23 13:15:45 +0100 | [diff] [blame] | 199 | struct ieee80211_vif *vif) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 200 | { |
| 201 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Johannes Berg | 1ed32e4 | 2009-12-23 13:15:45 +0100 | [diff] [blame] | 202 | struct rt2x00_intf *intf = vif_to_intf(vif); |
Gertjan van Wingerde | a244083 | 2011-03-03 19:46:55 +0100 | [diff] [blame] | 203 | struct data_queue *queue = rt2x00dev->bcn; |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 204 | struct queue_entry *entry = NULL; |
| 205 | unsigned int i; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 206 | |
| 207 | /* |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 208 | * Don't allow interfaces to be added |
| 209 | * the device has disappeared. |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 210 | */ |
Ivo van Doorn | 0262ab0 | 2008-08-29 21:04:26 +0200 | [diff] [blame] | 211 | if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) || |
| 212 | !test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags)) |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 213 | return -ENODEV; |
| 214 | |
Johannes Berg | 1ed32e4 | 2009-12-23 13:15:45 +0100 | [diff] [blame] | 215 | switch (vif->type) { |
Johannes Berg | 05c914f | 2008-09-11 00:01:58 +0200 | [diff] [blame] | 216 | case NL80211_IFTYPE_AP: |
Ivo van Doorn | 0fc9803 | 2008-08-06 16:18:31 +0200 | [diff] [blame] | 217 | /* |
| 218 | * We don't support mixed combinations of |
| 219 | * sta and ap interfaces. |
| 220 | */ |
| 221 | if (rt2x00dev->intf_sta_count) |
| 222 | return -ENOBUFS; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 223 | |
Ivo van Doorn | 0fc9803 | 2008-08-06 16:18:31 +0200 | [diff] [blame] | 224 | /* |
| 225 | * Check if we exceeded the maximum amount |
| 226 | * of supported interfaces. |
| 227 | */ |
| 228 | if (rt2x00dev->intf_ap_count >= rt2x00dev->ops->max_ap_intf) |
| 229 | return -ENOBUFS; |
| 230 | |
| 231 | break; |
Johannes Berg | 05c914f | 2008-09-11 00:01:58 +0200 | [diff] [blame] | 232 | case NL80211_IFTYPE_STATION: |
| 233 | case NL80211_IFTYPE_ADHOC: |
Andrey Yurovsky | a07dbea | 2008-12-20 10:55:34 +0100 | [diff] [blame] | 234 | case NL80211_IFTYPE_MESH_POINT: |
Ivo van Doorn | ce292a6 | 2008-12-20 10:57:02 +0100 | [diff] [blame] | 235 | case NL80211_IFTYPE_WDS: |
Ivo van Doorn | 0fc9803 | 2008-08-06 16:18:31 +0200 | [diff] [blame] | 236 | /* |
| 237 | * We don't support mixed combinations of |
| 238 | * sta and ap interfaces. |
| 239 | */ |
| 240 | if (rt2x00dev->intf_ap_count) |
| 241 | return -ENOBUFS; |
| 242 | |
| 243 | /* |
| 244 | * Check if we exceeded the maximum amount |
| 245 | * of supported interfaces. |
| 246 | */ |
| 247 | if (rt2x00dev->intf_sta_count >= rt2x00dev->ops->max_sta_intf) |
| 248 | return -ENOBUFS; |
| 249 | |
| 250 | break; |
| 251 | default: |
| 252 | return -EINVAL; |
| 253 | } |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 254 | |
| 255 | /* |
| 256 | * Loop through all beacon queues to find a free |
| 257 | * entry. Since there are as much beacon entries |
| 258 | * as the maximum interfaces, this search shouldn't |
| 259 | * fail. |
| 260 | */ |
| 261 | for (i = 0; i < queue->limit; i++) { |
| 262 | entry = &queue->entries[i]; |
Ivo van Doorn | 0262ab0 | 2008-08-29 21:04:26 +0200 | [diff] [blame] | 263 | if (!test_and_set_bit(ENTRY_BCN_ASSIGNED, &entry->flags)) |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 264 | break; |
| 265 | } |
| 266 | |
| 267 | if (unlikely(i == queue->limit)) |
| 268 | return -ENOBUFS; |
| 269 | |
| 270 | /* |
| 271 | * We are now absolutely sure the interface can be created, |
| 272 | * increase interface count and start initialization. |
| 273 | */ |
| 274 | |
Johannes Berg | 1ed32e4 | 2009-12-23 13:15:45 +0100 | [diff] [blame] | 275 | if (vif->type == NL80211_IFTYPE_AP) |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 276 | rt2x00dev->intf_ap_count++; |
| 277 | else |
| 278 | rt2x00dev->intf_sta_count++; |
| 279 | |
Ivo van Doorn | d4764b2 | 2008-07-28 10:21:16 +0200 | [diff] [blame] | 280 | spin_lock_init(&intf->seqlock); |
Igor Perminov | 17512dc | 2009-08-08 23:55:18 +0200 | [diff] [blame] | 281 | mutex_init(&intf->beacon_skb_mutex); |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 282 | intf->beacon = entry; |
| 283 | |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 284 | /* |
Uwe Kleine-König | b595076 | 2010-11-01 15:38:34 -0400 | [diff] [blame] | 285 | * The MAC address must be configured after the device |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 286 | * has been initialized. Otherwise the device can reset |
| 287 | * the MAC registers. |
Ivo van Doorn | 06b3cda | 2010-07-24 19:32:25 +0200 | [diff] [blame] | 288 | * The BSSID address must only be configured in AP mode, |
| 289 | * however we should not send an empty BSSID address for |
| 290 | * STA interfaces at this time, since this can cause |
| 291 | * invalid behavior in the device. |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 292 | */ |
Helmut Schaa | fa8b4b2 | 2010-11-04 20:42:36 +0100 | [diff] [blame] | 293 | rt2x00lib_config_intf(rt2x00dev, intf, vif->type, |
Gertjan van Wingerde | a39fd6b | 2010-12-27 15:05:35 +0100 | [diff] [blame] | 294 | vif->addr, NULL); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 295 | |
Ivo van Doorn | e0b005f | 2008-03-31 15:24:53 +0200 | [diff] [blame] | 296 | /* |
| 297 | * Some filters depend on the current working mode. We can force |
| 298 | * an update during the next configure_filter() run by mac80211 by |
| 299 | * resetting the current packet_filter state. |
| 300 | */ |
| 301 | rt2x00dev->packet_filter = 0; |
| 302 | |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 303 | return 0; |
| 304 | } |
| 305 | EXPORT_SYMBOL_GPL(rt2x00mac_add_interface); |
| 306 | |
| 307 | void rt2x00mac_remove_interface(struct ieee80211_hw *hw, |
Johannes Berg | 1ed32e4 | 2009-12-23 13:15:45 +0100 | [diff] [blame] | 308 | struct ieee80211_vif *vif) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 309 | { |
| 310 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Johannes Berg | 1ed32e4 | 2009-12-23 13:15:45 +0100 | [diff] [blame] | 311 | struct rt2x00_intf *intf = vif_to_intf(vif); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 312 | |
| 313 | /* |
Ivo van Doorn | 066cb63 | 2007-09-25 20:55:39 +0200 | [diff] [blame] | 314 | * Don't allow interfaces to be remove while |
| 315 | * either the device has disappeared or when |
| 316 | * no interface is present. |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 317 | */ |
Ivo van Doorn | 0262ab0 | 2008-08-29 21:04:26 +0200 | [diff] [blame] | 318 | if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) || |
Johannes Berg | 1ed32e4 | 2009-12-23 13:15:45 +0100 | [diff] [blame] | 319 | (vif->type == NL80211_IFTYPE_AP && !rt2x00dev->intf_ap_count) || |
| 320 | (vif->type != NL80211_IFTYPE_AP && !rt2x00dev->intf_sta_count)) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 321 | return; |
| 322 | |
Johannes Berg | 1ed32e4 | 2009-12-23 13:15:45 +0100 | [diff] [blame] | 323 | if (vif->type == NL80211_IFTYPE_AP) |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 324 | rt2x00dev->intf_ap_count--; |
| 325 | else |
| 326 | rt2x00dev->intf_sta_count--; |
| 327 | |
| 328 | /* |
| 329 | * Release beacon entry so it is available for |
| 330 | * new interfaces again. |
| 331 | */ |
Ivo van Doorn | 0262ab0 | 2008-08-29 21:04:26 +0200 | [diff] [blame] | 332 | clear_bit(ENTRY_BCN_ASSIGNED, &intf->beacon->flags); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 333 | |
| 334 | /* |
| 335 | * Make sure the bssid and mac address registers |
| 336 | * are cleared to prevent false ACKing of frames. |
| 337 | */ |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 338 | rt2x00lib_config_intf(rt2x00dev, intf, |
Johannes Berg | 05c914f | 2008-09-11 00:01:58 +0200 | [diff] [blame] | 339 | NL80211_IFTYPE_UNSPECIFIED, NULL, NULL); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 340 | } |
| 341 | EXPORT_SYMBOL_GPL(rt2x00mac_remove_interface); |
| 342 | |
Johannes Berg | e897558 | 2008-10-09 12:18:51 +0200 | [diff] [blame] | 343 | int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 344 | { |
| 345 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Johannes Berg | e897558 | 2008-10-09 12:18:51 +0200 | [diff] [blame] | 346 | struct ieee80211_conf *conf = &hw->conf; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 347 | |
| 348 | /* |
Luis Correia | 4951348 | 2009-07-17 21:39:19 +0200 | [diff] [blame] | 349 | * mac80211 might be calling this function while we are trying |
Ivo van Doorn | 066cb63 | 2007-09-25 20:55:39 +0200 | [diff] [blame] | 350 | * to remove the device or perhaps suspending it. |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 351 | */ |
Ivo van Doorn | 0262ab0 | 2008-08-29 21:04:26 +0200 | [diff] [blame] | 352 | if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 353 | return 0; |
| 354 | |
| 355 | /* |
Ivo van Doorn | bdfa500 | 2009-08-08 23:53:04 +0200 | [diff] [blame] | 356 | * Some configuration parameters (e.g. channel and antenna values) can |
| 357 | * only be set when the radio is enabled, but do require the RX to |
Ivo van Doorn | d8147f9 | 2010-07-11 12:24:47 +0200 | [diff] [blame] | 358 | * be off. During this period we should keep link tuning enabled, |
| 359 | * if for any reason the link tuner must be reset, this will be |
| 360 | * handled by rt2x00lib_config(). |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 361 | */ |
Ivo van Doorn | 0b7fde5 | 2010-12-13 12:35:17 +0100 | [diff] [blame] | 362 | rt2x00queue_stop_queue(rt2x00dev->rx); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 363 | |
Ivo van Doorn | bdfa500 | 2009-08-08 23:53:04 +0200 | [diff] [blame] | 364 | /* |
| 365 | * When we've just turned on the radio, we want to reprogram |
| 366 | * everything to ensure a consistent state |
| 367 | */ |
| 368 | rt2x00lib_config(rt2x00dev, conf, changed); |
Ivo van Doorn | 74c0ee9 | 2008-07-21 11:52:44 +0200 | [diff] [blame] | 369 | |
Ivo van Doorn | bdfa500 | 2009-08-08 23:53:04 +0200 | [diff] [blame] | 370 | /* |
| 371 | * After the radio has been enabled we need to configure |
| 372 | * the antenna to the default settings. rt2x00lib_config_antenna() |
| 373 | * should determine if any action should be taken based on |
| 374 | * checking if diversity has been enabled or no antenna changes |
| 375 | * have been made since the last configuration change. |
| 376 | */ |
| 377 | rt2x00lib_config_antenna(rt2x00dev, rt2x00dev->default_ant); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 378 | |
Ivo van Doorn | bdfa500 | 2009-08-08 23:53:04 +0200 | [diff] [blame] | 379 | /* Turn RX back on */ |
Ivo van Doorn | 0b7fde5 | 2010-12-13 12:35:17 +0100 | [diff] [blame] | 380 | rt2x00queue_start_queue(rt2x00dev->rx); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 381 | |
| 382 | return 0; |
| 383 | } |
| 384 | EXPORT_SYMBOL_GPL(rt2x00mac_config); |
| 385 | |
Ivo van Doorn | 3a643d2 | 2008-03-25 14:13:18 +0100 | [diff] [blame] | 386 | void rt2x00mac_configure_filter(struct ieee80211_hw *hw, |
| 387 | unsigned int changed_flags, |
| 388 | unsigned int *total_flags, |
Johannes Berg | 3ac64be | 2009-08-17 16:16:53 +0200 | [diff] [blame] | 389 | u64 multicast) |
Ivo van Doorn | 3a643d2 | 2008-03-25 14:13:18 +0100 | [diff] [blame] | 390 | { |
| 391 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 392 | |
| 393 | /* |
| 394 | * Mask off any flags we are going to ignore |
| 395 | * from the total_flags field. |
| 396 | */ |
| 397 | *total_flags &= |
| 398 | FIF_ALLMULTI | |
| 399 | FIF_FCSFAIL | |
| 400 | FIF_PLCPFAIL | |
| 401 | FIF_CONTROL | |
Igor Perminov | 1afcfd54 | 2009-08-08 23:55:55 +0200 | [diff] [blame] | 402 | FIF_PSPOLL | |
Ivo van Doorn | 3a643d2 | 2008-03-25 14:13:18 +0100 | [diff] [blame] | 403 | FIF_OTHER_BSS | |
| 404 | FIF_PROMISC_IN_BSS; |
| 405 | |
| 406 | /* |
| 407 | * Apply some rules to the filters: |
| 408 | * - Some filters imply different filters to be set. |
| 409 | * - Some things we can't filter out at all. |
| 410 | * - Multicast filter seems to kill broadcast traffic so never use it. |
| 411 | */ |
| 412 | *total_flags |= FIF_ALLMULTI; |
| 413 | if (*total_flags & FIF_OTHER_BSS || |
| 414 | *total_flags & FIF_PROMISC_IN_BSS) |
| 415 | *total_flags |= FIF_PROMISC_IN_BSS | FIF_OTHER_BSS; |
| 416 | |
| 417 | /* |
Igor Perminov | 1afcfd54 | 2009-08-08 23:55:55 +0200 | [diff] [blame] | 418 | * If the device has a single filter for all control frames, |
| 419 | * FIF_CONTROL and FIF_PSPOLL flags imply each other. |
| 420 | * And if the device has more than one filter for control frames |
| 421 | * of different types, but has no a separate filter for PS Poll frames, |
| 422 | * FIF_CONTROL flag implies FIF_PSPOLL. |
| 423 | */ |
Ivo van Doorn | 7dab73b | 2011-04-18 15:27:06 +0200 | [diff] [blame] | 424 | if (!test_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags)) { |
Igor Perminov | 1afcfd54 | 2009-08-08 23:55:55 +0200 | [diff] [blame] | 425 | if (*total_flags & FIF_CONTROL || *total_flags & FIF_PSPOLL) |
| 426 | *total_flags |= FIF_CONTROL | FIF_PSPOLL; |
| 427 | } |
Ivo van Doorn | 7dab73b | 2011-04-18 15:27:06 +0200 | [diff] [blame] | 428 | if (!test_bit(CAPABILITY_CONTROL_FILTER_PSPOLL, &rt2x00dev->cap_flags)) { |
Igor Perminov | 1afcfd54 | 2009-08-08 23:55:55 +0200 | [diff] [blame] | 429 | if (*total_flags & FIF_CONTROL) |
| 430 | *total_flags |= FIF_PSPOLL; |
| 431 | } |
| 432 | |
| 433 | /* |
Ivo van Doorn | 3a643d2 | 2008-03-25 14:13:18 +0100 | [diff] [blame] | 434 | * Check if there is any work left for us. |
| 435 | */ |
| 436 | if (rt2x00dev->packet_filter == *total_flags) |
| 437 | return; |
| 438 | rt2x00dev->packet_filter = *total_flags; |
| 439 | |
Ivo van Doorn | afa6204 | 2009-08-18 19:54:23 +0200 | [diff] [blame] | 440 | rt2x00dev->ops->lib->config_filter(rt2x00dev, *total_flags); |
Ivo van Doorn | 3a643d2 | 2008-03-25 14:13:18 +0100 | [diff] [blame] | 441 | } |
| 442 | EXPORT_SYMBOL_GPL(rt2x00mac_configure_filter); |
| 443 | |
Helmut Schaa | 4dee32f | 2010-07-11 12:27:26 +0200 | [diff] [blame] | 444 | static void rt2x00mac_set_tim_iter(void *data, u8 *mac, |
| 445 | struct ieee80211_vif *vif) |
| 446 | { |
| 447 | struct rt2x00_intf *intf = vif_to_intf(vif); |
| 448 | |
| 449 | if (vif->type != NL80211_IFTYPE_AP && |
| 450 | vif->type != NL80211_IFTYPE_ADHOC && |
| 451 | vif->type != NL80211_IFTYPE_MESH_POINT && |
| 452 | vif->type != NL80211_IFTYPE_WDS) |
| 453 | return; |
| 454 | |
Helmut Schaa | bfe6a15 | 2010-12-27 15:06:57 +0100 | [diff] [blame] | 455 | set_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags); |
Helmut Schaa | 4dee32f | 2010-07-11 12:27:26 +0200 | [diff] [blame] | 456 | } |
| 457 | |
Ivo van Doorn | ad2f34b | 2009-07-28 18:58:54 +0200 | [diff] [blame] | 458 | int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, |
| 459 | bool set) |
| 460 | { |
| 461 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 462 | |
Helmut Schaa | 4dee32f | 2010-07-11 12:27:26 +0200 | [diff] [blame] | 463 | if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) |
| 464 | return 0; |
| 465 | |
| 466 | ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw, |
| 467 | rt2x00mac_set_tim_iter, |
| 468 | rt2x00dev); |
| 469 | |
| 470 | /* queue work to upodate the beacon template */ |
| 471 | ieee80211_queue_work(rt2x00dev->hw, &rt2x00dev->intf_work); |
Ivo van Doorn | ad2f34b | 2009-07-28 18:58:54 +0200 | [diff] [blame] | 472 | return 0; |
| 473 | } |
| 474 | EXPORT_SYMBOL_GPL(rt2x00mac_set_tim); |
| 475 | |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 476 | #ifdef CONFIG_RT2X00_LIB_CRYPTO |
Ivo van Doorn | 7b40982 | 2008-12-20 10:58:33 +0100 | [diff] [blame] | 477 | static void memcpy_tkip(struct rt2x00lib_crypto *crypto, u8 *key, u8 key_len) |
| 478 | { |
| 479 | if (key_len > NL80211_TKIP_DATA_OFFSET_ENCR_KEY) |
Gertjan van Wingerde | 736e3ac | 2010-12-27 15:05:55 +0100 | [diff] [blame] | 480 | memcpy(crypto->key, |
Ivo van Doorn | 7b40982 | 2008-12-20 10:58:33 +0100 | [diff] [blame] | 481 | &key[NL80211_TKIP_DATA_OFFSET_ENCR_KEY], |
| 482 | sizeof(crypto->key)); |
| 483 | |
| 484 | if (key_len > NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY) |
Gertjan van Wingerde | 736e3ac | 2010-12-27 15:05:55 +0100 | [diff] [blame] | 485 | memcpy(crypto->tx_mic, |
Ivo van Doorn | 7b40982 | 2008-12-20 10:58:33 +0100 | [diff] [blame] | 486 | &key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY], |
| 487 | sizeof(crypto->tx_mic)); |
| 488 | |
| 489 | if (key_len > NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY) |
Gertjan van Wingerde | 736e3ac | 2010-12-27 15:05:55 +0100 | [diff] [blame] | 490 | memcpy(crypto->rx_mic, |
Ivo van Doorn | 7b40982 | 2008-12-20 10:58:33 +0100 | [diff] [blame] | 491 | &key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY], |
| 492 | sizeof(crypto->rx_mic)); |
| 493 | } |
| 494 | |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 495 | int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, |
Johannes Berg | dc822b5 | 2008-12-29 12:55:09 +0100 | [diff] [blame] | 496 | struct ieee80211_vif *vif, struct ieee80211_sta *sta, |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 497 | struct ieee80211_key_conf *key) |
| 498 | { |
| 499 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 500 | int (*set_key) (struct rt2x00_dev *rt2x00dev, |
| 501 | struct rt2x00lib_crypto *crypto, |
| 502 | struct ieee80211_key_conf *key); |
| 503 | struct rt2x00lib_crypto crypto; |
Johannes Berg | dc822b5 | 2008-12-29 12:55:09 +0100 | [diff] [blame] | 504 | static const u8 bcast_addr[ETH_ALEN] = |
| 505 | { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, }; |
Helmut Schaa | f03fcfc | 2011-09-08 14:36:45 +0200 | [diff] [blame] | 506 | struct rt2x00_sta *sta_priv = NULL; |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 507 | |
Ivo van Doorn | 8058409 | 2008-11-02 00:37:25 +0100 | [diff] [blame] | 508 | if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) |
| 509 | return 0; |
Ivo van Doorn | 7dab73b | 2011-04-18 15:27:06 +0200 | [diff] [blame] | 510 | else if (!test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags)) |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 511 | return -EOPNOTSUPP; |
| 512 | else if (key->keylen > 32) |
| 513 | return -ENOSPC; |
| 514 | |
| 515 | memset(&crypto, 0, sizeof(crypto)); |
| 516 | |
Helmut Schaa | 1832552 | 2011-09-08 14:34:22 +0200 | [diff] [blame] | 517 | crypto.bssidx = rt2x00lib_get_bssidx(rt2x00dev, vif); |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 518 | crypto.cipher = rt2x00crypto_key_to_cipher(key); |
| 519 | if (crypto.cipher == CIPHER_NONE) |
| 520 | return -EOPNOTSUPP; |
| 521 | |
| 522 | crypto.cmd = cmd; |
Johannes Berg | dc822b5 | 2008-12-29 12:55:09 +0100 | [diff] [blame] | 523 | |
Helmut Schaa | f03fcfc | 2011-09-08 14:36:45 +0200 | [diff] [blame] | 524 | if (sta) { |
Johannes Berg | dc822b5 | 2008-12-29 12:55:09 +0100 | [diff] [blame] | 525 | crypto.address = sta->addr; |
Helmut Schaa | f03fcfc | 2011-09-08 14:36:45 +0200 | [diff] [blame] | 526 | sta_priv = sta_to_rt2x00_sta(sta); |
| 527 | crypto.wcid = sta_priv->wcid; |
| 528 | } else |
Johannes Berg | dc822b5 | 2008-12-29 12:55:09 +0100 | [diff] [blame] | 529 | crypto.address = bcast_addr; |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 530 | |
Ivo van Doorn | 7b40982 | 2008-12-20 10:58:33 +0100 | [diff] [blame] | 531 | if (crypto.cipher == CIPHER_TKIP) |
| 532 | memcpy_tkip(&crypto, &key->key[0], key->keylen); |
| 533 | else |
Gertjan van Wingerde | 736e3ac | 2010-12-27 15:05:55 +0100 | [diff] [blame] | 534 | memcpy(crypto.key, &key->key[0], key->keylen); |
Ivo van Doorn | 73a5267 | 2008-12-03 17:30:22 +0100 | [diff] [blame] | 535 | /* |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 536 | * Each BSS has a maximum of 4 shared keys. |
| 537 | * Shared key index values: |
| 538 | * 0) BSS0 key0 |
| 539 | * 1) BSS0 key1 |
| 540 | * ... |
| 541 | * 4) BSS1 key0 |
| 542 | * ... |
| 543 | * 8) BSS2 key0 |
| 544 | * ... |
| 545 | * Both pairwise as shared key indeces are determined by |
| 546 | * driver. This is required because the hardware requires |
| 547 | * keys to be assigned in correct order (When key 1 is |
| 548 | * provided but key 0 is not, then the key is not found |
| 549 | * by the hardware during RX). |
| 550 | */ |
Ivo van Doorn | acaf908d | 2008-09-22 19:40:04 +0200 | [diff] [blame] | 551 | if (cmd == SET_KEY) |
| 552 | key->hw_key_idx = 0; |
Ivo van Doorn | 2bb057d | 2008-08-04 16:37:44 +0200 | [diff] [blame] | 553 | |
| 554 | if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) |
| 555 | set_key = rt2x00dev->ops->lib->config_pairwise_key; |
| 556 | else |
| 557 | set_key = rt2x00dev->ops->lib->config_shared_key; |
| 558 | |
| 559 | if (!set_key) |
| 560 | return -EOPNOTSUPP; |
| 561 | |
| 562 | return set_key(rt2x00dev, &crypto, key); |
| 563 | } |
| 564 | EXPORT_SYMBOL_GPL(rt2x00mac_set_key); |
| 565 | #endif /* CONFIG_RT2X00_LIB_CRYPTO */ |
| 566 | |
Helmut Schaa | b4943d8 | 2011-09-08 14:36:04 +0200 | [diff] [blame] | 567 | int rt2x00mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif, |
| 568 | struct ieee80211_sta *sta) |
| 569 | { |
| 570 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 571 | struct rt2x00_sta *sta_priv = sta_to_rt2x00_sta(sta); |
| 572 | |
| 573 | /* |
| 574 | * If there's no space left in the device table store |
| 575 | * -1 as wcid but tell mac80211 everything went ok. |
| 576 | */ |
| 577 | if (rt2x00dev->ops->lib->sta_add(rt2x00dev, vif, sta)) |
| 578 | sta_priv->wcid = -1; |
| 579 | |
| 580 | return 0; |
| 581 | } |
| 582 | EXPORT_SYMBOL_GPL(rt2x00mac_sta_add); |
| 583 | |
| 584 | int rt2x00mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif, |
| 585 | struct ieee80211_sta *sta) |
| 586 | { |
| 587 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 588 | struct rt2x00_sta *sta_priv = sta_to_rt2x00_sta(sta); |
| 589 | |
| 590 | /* |
| 591 | * If we never sent the STA to the device no need to clean it up. |
| 592 | */ |
| 593 | if (sta_priv->wcid < 0) |
| 594 | return 0; |
| 595 | |
| 596 | return rt2x00dev->ops->lib->sta_remove(rt2x00dev, sta_priv->wcid); |
| 597 | } |
| 598 | EXPORT_SYMBOL_GPL(rt2x00mac_sta_remove); |
| 599 | |
Ivo van Doorn | d8147f9 | 2010-07-11 12:24:47 +0200 | [diff] [blame] | 600 | void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw) |
| 601 | { |
| 602 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Ivo van Doorn | 7dab73b | 2011-04-18 15:27:06 +0200 | [diff] [blame] | 603 | set_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags); |
Ivo van Doorn | d8147f9 | 2010-07-11 12:24:47 +0200 | [diff] [blame] | 604 | rt2x00link_stop_tuner(rt2x00dev); |
| 605 | } |
| 606 | EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_start); |
| 607 | |
| 608 | void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw) |
| 609 | { |
| 610 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Ivo van Doorn | 7dab73b | 2011-04-18 15:27:06 +0200 | [diff] [blame] | 611 | clear_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags); |
Ivo van Doorn | d8147f9 | 2010-07-11 12:24:47 +0200 | [diff] [blame] | 612 | rt2x00link_start_tuner(rt2x00dev); |
| 613 | } |
| 614 | EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_complete); |
| 615 | |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 616 | int rt2x00mac_get_stats(struct ieee80211_hw *hw, |
| 617 | struct ieee80211_low_level_stats *stats) |
| 618 | { |
| 619 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 620 | |
| 621 | /* |
| 622 | * The dot11ACKFailureCount, dot11RTSFailureCount and |
| 623 | * dot11RTSSuccessCount are updated in interrupt time. |
| 624 | * dot11FCSErrorCount is updated in the link tuner. |
| 625 | */ |
| 626 | memcpy(stats, &rt2x00dev->low_level_stats, sizeof(*stats)); |
| 627 | |
| 628 | return 0; |
| 629 | } |
| 630 | EXPORT_SYMBOL_GPL(rt2x00mac_get_stats); |
| 631 | |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 632 | void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw, |
| 633 | struct ieee80211_vif *vif, |
| 634 | struct ieee80211_bss_conf *bss_conf, |
| 635 | u32 changes) |
Ivo van Doorn | 5c58ee5 | 2007-10-06 13:34:52 +0200 | [diff] [blame] | 636 | { |
| 637 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 638 | struct rt2x00_intf *intf = vif_to_intf(vif); |
Johannes Berg | 2d0ddec | 2009-04-23 16:13:26 +0200 | [diff] [blame] | 639 | |
| 640 | /* |
Luis Correia | 4951348 | 2009-07-17 21:39:19 +0200 | [diff] [blame] | 641 | * mac80211 might be calling this function while we are trying |
Johannes Berg | 2d0ddec | 2009-04-23 16:13:26 +0200 | [diff] [blame] | 642 | * to remove the device or perhaps suspending it. |
| 643 | */ |
| 644 | if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) |
| 645 | return; |
| 646 | |
Johannes Berg | 2d0ddec | 2009-04-23 16:13:26 +0200 | [diff] [blame] | 647 | /* |
Helmut Schaa | 5af3c1d | 2010-12-27 15:07:35 +0100 | [diff] [blame] | 648 | * Update the BSSID. |
Johannes Berg | 2d0ddec | 2009-04-23 16:13:26 +0200 | [diff] [blame] | 649 | */ |
| 650 | if (changes & BSS_CHANGED_BSSID) |
| 651 | rt2x00lib_config_intf(rt2x00dev, intf, vif->type, NULL, |
Ivo van Doorn | 1ed7a17 | 2010-06-29 21:39:29 +0200 | [diff] [blame] | 652 | bss_conf->bssid); |
Johannes Berg | 2d0ddec | 2009-04-23 16:13:26 +0200 | [diff] [blame] | 653 | |
| 654 | /* |
Helmut Schaa | 1dae8d3 | 2011-01-30 13:16:52 +0100 | [diff] [blame] | 655 | * Update the beacon. This is only required on USB devices. PCI |
| 656 | * devices fetch beacons periodically. |
Johannes Berg | 2d0ddec | 2009-04-23 16:13:26 +0200 | [diff] [blame] | 657 | */ |
Helmut Schaa | 1dae8d3 | 2011-01-30 13:16:52 +0100 | [diff] [blame] | 658 | if (changes & BSS_CHANGED_BEACON && rt2x00_is_usb(rt2x00dev)) |
Helmut Schaa | 69cf36a | 2011-01-30 13:16:03 +0100 | [diff] [blame] | 659 | rt2x00queue_update_beacon(rt2x00dev, vif); |
| 660 | |
| 661 | /* |
| 662 | * Start/stop beaconing. |
| 663 | */ |
| 664 | if (changes & BSS_CHANGED_BEACON_ENABLED) { |
| 665 | if (!bss_conf->enable_beacon && intf->enable_beacon) { |
| 666 | rt2x00queue_clear_beacon(rt2x00dev, vif); |
| 667 | rt2x00dev->intf_beaconing--; |
| 668 | intf->enable_beacon = false; |
| 669 | |
| 670 | if (rt2x00dev->intf_beaconing == 0) { |
| 671 | /* |
| 672 | * Last beaconing interface disabled |
| 673 | * -> stop beacon queue. |
| 674 | */ |
| 675 | mutex_lock(&intf->beacon_skb_mutex); |
| 676 | rt2x00queue_stop_queue(rt2x00dev->bcn); |
| 677 | mutex_unlock(&intf->beacon_skb_mutex); |
| 678 | } |
| 679 | |
| 680 | |
| 681 | } else if (bss_conf->enable_beacon && !intf->enable_beacon) { |
| 682 | rt2x00dev->intf_beaconing++; |
| 683 | intf->enable_beacon = true; |
| 684 | |
| 685 | if (rt2x00dev->intf_beaconing == 1) { |
| 686 | /* |
| 687 | * First beaconing interface enabled |
| 688 | * -> start beacon queue. |
| 689 | */ |
| 690 | mutex_lock(&intf->beacon_skb_mutex); |
| 691 | rt2x00queue_start_queue(rt2x00dev->bcn); |
| 692 | mutex_unlock(&intf->beacon_skb_mutex); |
| 693 | } |
| 694 | } |
| 695 | } |
Ivo van Doorn | 5c58ee5 | 2007-10-06 13:34:52 +0200 | [diff] [blame] | 696 | |
| 697 | /* |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 698 | * When the association status has changed we must reset the link |
| 699 | * tuner counter. This is because some drivers determine if they |
| 700 | * should perform link tuning based on the number of seconds |
| 701 | * while associated or not associated. |
Ivo van Doorn | 5c58ee5 | 2007-10-06 13:34:52 +0200 | [diff] [blame] | 702 | */ |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 703 | if (changes & BSS_CHANGED_ASSOC) { |
| 704 | rt2x00dev->link.count = 0; |
Ivo van Doorn | 5c58ee5 | 2007-10-06 13:34:52 +0200 | [diff] [blame] | 705 | |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 706 | if (bss_conf->assoc) |
| 707 | rt2x00dev->intf_associated++; |
| 708 | else |
| 709 | rt2x00dev->intf_associated--; |
Ivo van Doorn | a2e1d52 | 2008-03-31 15:53:44 +0200 | [diff] [blame] | 710 | |
Ivo van Doorn | d904dc1 | 2009-08-18 20:33:12 +0200 | [diff] [blame] | 711 | rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated); |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 712 | } |
Ivo van Doorn | 5c58ee5 | 2007-10-06 13:34:52 +0200 | [diff] [blame] | 713 | |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 714 | /* |
Ivo van Doorn | 7281037 | 2008-03-09 22:46:18 +0100 | [diff] [blame] | 715 | * When the erp information has changed, we should perform |
| 716 | * additional configuration steps. For all other changes we are done. |
Ivo van Doorn | 6bb40dd | 2008-02-03 15:49:59 +0100 | [diff] [blame] | 717 | */ |
Helmut Schaa | 0204464 | 2010-09-08 20:56:32 +0200 | [diff] [blame] | 718 | if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE | |
| 719 | BSS_CHANGED_ERP_SLOT | BSS_CHANGED_BASIC_RATES | |
Helmut Schaa | 87c1915 | 2010-10-02 11:28:34 +0200 | [diff] [blame] | 720 | BSS_CHANGED_BEACON_INT | BSS_CHANGED_HT)) |
Helmut Schaa | 0204464 | 2010-09-08 20:56:32 +0200 | [diff] [blame] | 721 | rt2x00lib_config_erp(rt2x00dev, intf, bss_conf, changes); |
Ivo van Doorn | 5c58ee5 | 2007-10-06 13:34:52 +0200 | [diff] [blame] | 722 | } |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 723 | EXPORT_SYMBOL_GPL(rt2x00mac_bss_info_changed); |
Ivo van Doorn | 5c58ee5 | 2007-10-06 13:34:52 +0200 | [diff] [blame] | 724 | |
Eliad Peller | 8a3a3c8 | 2011-10-02 10:15:52 +0200 | [diff] [blame] | 725 | int rt2x00mac_conf_tx(struct ieee80211_hw *hw, |
| 726 | struct ieee80211_vif *vif, u16 queue_idx, |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 727 | const struct ieee80211_tx_queue_params *params) |
| 728 | { |
| 729 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Ivo van Doorn | 181d690 | 2008-02-05 16:42:23 -0500 | [diff] [blame] | 730 | struct data_queue *queue; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 731 | |
Helmut Schaa | 11f818e | 2011-03-03 19:38:55 +0100 | [diff] [blame] | 732 | queue = rt2x00queue_get_tx_queue(rt2x00dev, queue_idx); |
Ivo van Doorn | 181d690 | 2008-02-05 16:42:23 -0500 | [diff] [blame] | 733 | if (unlikely(!queue)) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 734 | return -EINVAL; |
| 735 | |
| 736 | /* |
| 737 | * The passed variables are stored as real value ((2^n)-1). |
| 738 | * Ralink registers require to know the bit number 'n'. |
| 739 | */ |
Ivo van Doorn | 3b3618a | 2008-02-03 15:47:30 +0100 | [diff] [blame] | 740 | if (params->cw_min > 0) |
Ivo van Doorn | 181d690 | 2008-02-05 16:42:23 -0500 | [diff] [blame] | 741 | queue->cw_min = fls(params->cw_min); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 742 | else |
Ivo van Doorn | 181d690 | 2008-02-05 16:42:23 -0500 | [diff] [blame] | 743 | queue->cw_min = 5; /* cw_min: 2^5 = 32. */ |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 744 | |
Ivo van Doorn | 3b3618a | 2008-02-03 15:47:30 +0100 | [diff] [blame] | 745 | if (params->cw_max > 0) |
Ivo van Doorn | 181d690 | 2008-02-05 16:42:23 -0500 | [diff] [blame] | 746 | queue->cw_max = fls(params->cw_max); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 747 | else |
Ivo van Doorn | 181d690 | 2008-02-05 16:42:23 -0500 | [diff] [blame] | 748 | queue->cw_max = 10; /* cw_min: 2^10 = 1024. */ |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 749 | |
Johannes Berg | 0b57664 | 2008-07-15 02:08:24 -0700 | [diff] [blame] | 750 | queue->aifs = params->aifs; |
Ivo van Doorn | 2af0a57 | 2008-08-29 21:05:45 +0200 | [diff] [blame] | 751 | queue->txop = params->txop; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 752 | |
| 753 | INFO(rt2x00dev, |
Ivo van Doorn | 2af0a57 | 2008-08-29 21:05:45 +0200 | [diff] [blame] | 754 | "Configured TX queue %d - CWmin: %d, CWmax: %d, Aifs: %d, TXop: %d.\n", |
| 755 | queue_idx, queue->cw_min, queue->cw_max, queue->aifs, queue->txop); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 756 | |
| 757 | return 0; |
| 758 | } |
| 759 | EXPORT_SYMBOL_GPL(rt2x00mac_conf_tx); |
Ivo van Doorn | e47a5cd | 2009-07-01 15:17:35 +0200 | [diff] [blame] | 760 | |
| 761 | void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw) |
| 762 | { |
| 763 | struct rt2x00_dev *rt2x00dev = hw->priv; |
Ivo van Doorn | 73077c8 | 2009-08-17 18:53:24 +0200 | [diff] [blame] | 764 | bool active = !!rt2x00dev->ops->lib->rfkill_poll(rt2x00dev); |
Ivo van Doorn | e47a5cd | 2009-07-01 15:17:35 +0200 | [diff] [blame] | 765 | |
Ivo van Doorn | 73077c8 | 2009-08-17 18:53:24 +0200 | [diff] [blame] | 766 | wiphy_rfkill_set_hw_state(hw->wiphy, !active); |
Ivo van Doorn | e47a5cd | 2009-07-01 15:17:35 +0200 | [diff] [blame] | 767 | } |
| 768 | EXPORT_SYMBOL_GPL(rt2x00mac_rfkill_poll); |
Ivo van Doorn | f44df18 | 2010-11-04 20:40:11 +0100 | [diff] [blame] | 769 | |
| 770 | void rt2x00mac_flush(struct ieee80211_hw *hw, bool drop) |
| 771 | { |
| 772 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 773 | struct data_queue *queue; |
Ivo van Doorn | f44df18 | 2010-11-04 20:40:11 +0100 | [diff] [blame] | 774 | |
Ivo van Doorn | 5be6560 | 2010-12-13 12:35:40 +0100 | [diff] [blame] | 775 | tx_queue_for_each(rt2x00dev, queue) |
| 776 | rt2x00queue_flush_queue(queue, drop); |
Ivo van Doorn | f44df18 | 2010-11-04 20:40:11 +0100 | [diff] [blame] | 777 | } |
| 778 | EXPORT_SYMBOL_GPL(rt2x00mac_flush); |
Ivo van Doorn | e7dee44 | 2011-04-18 15:34:41 +0200 | [diff] [blame] | 779 | |
Ivo van Doorn | 0ed7b3c | 2011-04-18 15:35:12 +0200 | [diff] [blame] | 780 | int rt2x00mac_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) |
| 781 | { |
| 782 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 783 | struct link_ant *ant = &rt2x00dev->link.ant; |
| 784 | struct antenna_setup *def = &rt2x00dev->default_ant; |
| 785 | struct antenna_setup setup; |
| 786 | |
| 787 | // The antenna value is not supposed to be 0, |
| 788 | // or exceed the maximum number of antenna's. |
| 789 | if (!tx_ant || (tx_ant & ~3) || !rx_ant || (rx_ant & ~3)) |
| 790 | return -EINVAL; |
| 791 | |
| 792 | // When the client tried to configure the antenna to or from |
| 793 | // diversity mode, we must reset the default antenna as well |
| 794 | // as that controls the diversity switch. |
| 795 | if (ant->flags & ANTENNA_TX_DIVERSITY && tx_ant != 3) |
| 796 | ant->flags &= ~ANTENNA_TX_DIVERSITY; |
| 797 | if (ant->flags & ANTENNA_RX_DIVERSITY && rx_ant != 3) |
| 798 | ant->flags &= ~ANTENNA_RX_DIVERSITY; |
| 799 | |
| 800 | // If diversity is being enabled, check if we need hardware |
| 801 | // or software diversity. In the latter case, reset the value, |
| 802 | // and make sure we update the antenna flags to have the |
| 803 | // link tuner pick up the diversity tuning. |
| 804 | if (tx_ant == 3 && def->tx == ANTENNA_SW_DIVERSITY) { |
| 805 | tx_ant = ANTENNA_SW_DIVERSITY; |
| 806 | ant->flags |= ANTENNA_TX_DIVERSITY; |
| 807 | } |
| 808 | |
| 809 | if (rx_ant == 3 && def->rx == ANTENNA_SW_DIVERSITY) { |
| 810 | rx_ant = ANTENNA_SW_DIVERSITY; |
| 811 | ant->flags |= ANTENNA_RX_DIVERSITY; |
| 812 | } |
| 813 | |
| 814 | setup.tx = tx_ant; |
| 815 | setup.rx = rx_ant; |
| 816 | |
| 817 | rt2x00lib_config_antenna(rt2x00dev, setup); |
| 818 | |
| 819 | return 0; |
| 820 | } |
| 821 | EXPORT_SYMBOL_GPL(rt2x00mac_set_antenna); |
| 822 | |
| 823 | int rt2x00mac_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) |
| 824 | { |
| 825 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 826 | struct link_ant *ant = &rt2x00dev->link.ant; |
| 827 | struct antenna_setup *active = &rt2x00dev->link.ant.active; |
| 828 | |
| 829 | // When software diversity is active, we must report this to the |
| 830 | // client and not the current active antenna state. |
| 831 | if (ant->flags & ANTENNA_TX_DIVERSITY) |
| 832 | *tx_ant = ANTENNA_HW_DIVERSITY; |
| 833 | else |
| 834 | *tx_ant = active->tx; |
| 835 | |
| 836 | if (ant->flags & ANTENNA_RX_DIVERSITY) |
| 837 | *rx_ant = ANTENNA_HW_DIVERSITY; |
| 838 | else |
| 839 | *rx_ant = active->rx; |
| 840 | |
| 841 | return 0; |
| 842 | } |
| 843 | EXPORT_SYMBOL_GPL(rt2x00mac_get_antenna); |
| 844 | |
Ivo van Doorn | e7dee44 | 2011-04-18 15:34:41 +0200 | [diff] [blame] | 845 | void rt2x00mac_get_ringparam(struct ieee80211_hw *hw, |
| 846 | u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max) |
| 847 | { |
| 848 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 849 | struct data_queue *queue; |
| 850 | |
| 851 | tx_queue_for_each(rt2x00dev, queue) { |
| 852 | *tx += queue->length; |
| 853 | *tx_max += queue->limit; |
| 854 | } |
| 855 | |
| 856 | *rx = rt2x00dev->rx->length; |
| 857 | *rx_max = rt2x00dev->rx->limit; |
| 858 | } |
| 859 | EXPORT_SYMBOL_GPL(rt2x00mac_get_ringparam); |
Gertjan van Wingerde | 5f0dd29 | 2011-07-06 23:00:21 +0200 | [diff] [blame] | 860 | |
| 861 | bool rt2x00mac_tx_frames_pending(struct ieee80211_hw *hw) |
| 862 | { |
| 863 | struct rt2x00_dev *rt2x00dev = hw->priv; |
| 864 | struct data_queue *queue; |
| 865 | |
| 866 | tx_queue_for_each(rt2x00dev, queue) { |
| 867 | if (!rt2x00queue_empty(queue)) |
| 868 | return true; |
| 869 | } |
| 870 | |
| 871 | return false; |
| 872 | } |
| 873 | EXPORT_SYMBOL_GPL(rt2x00mac_tx_frames_pending); |