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