1 | /* |
2 | * Copyright (c) 2013 Qualcomm Atheros, Inc. |
3 | * |
4 | * Permission to use, copy, modify, and/or distribute this software for any |
5 | * purpose with or without fee is hereby granted, provided that the above |
6 | * copyright notice and this permission notice appear in all copies. |
7 | * |
8 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
9 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
10 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
11 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
12 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
13 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
14 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
15 | */ |
16 | |
17 | #include "ath9k.h" |
18 | |
19 | static void ath9k_tx99_stop(struct ath_softc *sc) |
20 | { |
21 | struct ath_hw *ah = sc->sc_ah; |
22 | struct ath_common *common = ath9k_hw_common(ah); |
23 | |
24 | ath_drain_all_txq(sc); |
25 | ath_startrecv(sc); |
26 | |
27 | ath9k_hw_set_interrupts(ah); |
28 | ath9k_hw_enable_interrupts(ah); |
29 | |
30 | ieee80211_wake_queues(hw: sc->hw); |
31 | |
32 | kfree_skb(skb: sc->tx99_skb); |
33 | sc->tx99_skb = NULL; |
34 | sc->tx99_state = false; |
35 | |
36 | ath9k_hw_tx99_stop(ah: sc->sc_ah); |
37 | ath_dbg(common, XMIT, "TX99 stopped\n" ); |
38 | } |
39 | |
40 | static struct sk_buff *ath9k_build_tx99_skb(struct ath_softc *sc) |
41 | { |
42 | static u8 PN9Data[] = {0xff, 0x87, 0xb8, 0x59, 0xb7, 0xa1, 0xcc, 0x24, |
43 | 0x57, 0x5e, 0x4b, 0x9c, 0x0e, 0xe9, 0xea, 0x50, |
44 | 0x2a, 0xbe, 0xb4, 0x1b, 0xb6, 0xb0, 0x5d, 0xf1, |
45 | 0xe6, 0x9a, 0xe3, 0x45, 0xfd, 0x2c, 0x53, 0x18, |
46 | 0x0c, 0xca, 0xc9, 0xfb, 0x49, 0x37, 0xe5, 0xa8, |
47 | 0x51, 0x3b, 0x2f, 0x61, 0xaa, 0x72, 0x18, 0x84, |
48 | 0x02, 0x23, 0x23, 0xab, 0x63, 0x89, 0x51, 0xb3, |
49 | 0xe7, 0x8b, 0x72, 0x90, 0x4c, 0xe8, 0xfb, 0xc0}; |
50 | u32 len = 1200; |
51 | struct ieee80211_tx_rate *rate; |
52 | struct ieee80211_hw *hw = sc->hw; |
53 | struct ath_hw *ah = sc->sc_ah; |
54 | struct ieee80211_hdr *hdr; |
55 | struct ieee80211_tx_info *tx_info; |
56 | struct sk_buff *skb; |
57 | struct ath_vif *avp; |
58 | |
59 | skb = alloc_skb(size: len, GFP_KERNEL); |
60 | if (!skb) |
61 | return NULL; |
62 | |
63 | skb_put(skb, len); |
64 | |
65 | memset(skb->data, 0, len); |
66 | |
67 | hdr = (struct ieee80211_hdr *)skb->data; |
68 | hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA); |
69 | hdr->duration_id = 0; |
70 | |
71 | memcpy(hdr->addr1, hw->wiphy->perm_addr, ETH_ALEN); |
72 | memcpy(hdr->addr2, hw->wiphy->perm_addr, ETH_ALEN); |
73 | memcpy(hdr->addr3, hw->wiphy->perm_addr, ETH_ALEN); |
74 | |
75 | if (sc->tx99_vif) { |
76 | avp = (struct ath_vif *) sc->tx99_vif->drv_priv; |
77 | hdr->seq_ctrl |= cpu_to_le16(avp->seq_no); |
78 | } |
79 | |
80 | tx_info = IEEE80211_SKB_CB(skb); |
81 | memset(tx_info, 0, sizeof(*tx_info)); |
82 | rate = &tx_info->control.rates[0]; |
83 | tx_info->band = sc->cur_chan->chandef.chan->band; |
84 | tx_info->flags = IEEE80211_TX_CTL_NO_ACK; |
85 | tx_info->control.vif = sc->tx99_vif; |
86 | rate->count = 1; |
87 | if (ah->curchan && IS_CHAN_HT(ah->curchan)) { |
88 | rate->flags |= IEEE80211_TX_RC_MCS; |
89 | if (IS_CHAN_HT40(ah->curchan)) |
90 | rate->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH; |
91 | } |
92 | |
93 | memcpy(skb->data + sizeof(*hdr), PN9Data, sizeof(PN9Data)); |
94 | |
95 | return skb; |
96 | } |
97 | |
98 | static void ath9k_tx99_deinit(struct ath_softc *sc) |
99 | { |
100 | ath_reset(sc, NULL); |
101 | |
102 | ath9k_ps_wakeup(sc); |
103 | ath9k_tx99_stop(sc); |
104 | ath9k_ps_restore(sc); |
105 | } |
106 | |
107 | static int ath9k_tx99_init(struct ath_softc *sc) |
108 | { |
109 | struct ieee80211_hw *hw = sc->hw; |
110 | struct ath_hw *ah = sc->sc_ah; |
111 | struct ath_common *common = ath9k_hw_common(ah); |
112 | struct ath_tx_control txctl; |
113 | int r; |
114 | |
115 | if (test_bit(ATH_OP_INVALID, &common->op_flags)) { |
116 | ath_err(common, |
117 | "driver is in invalid state unable to use TX99" ); |
118 | return -EINVAL; |
119 | } |
120 | |
121 | sc->tx99_skb = ath9k_build_tx99_skb(sc); |
122 | if (!sc->tx99_skb) |
123 | return -ENOMEM; |
124 | |
125 | memset(&txctl, 0, sizeof(txctl)); |
126 | txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO]; |
127 | |
128 | ath_reset(sc, NULL); |
129 | |
130 | ath9k_ps_wakeup(sc); |
131 | |
132 | ath9k_hw_disable_interrupts(ah); |
133 | ath_drain_all_txq(sc); |
134 | ath_stoprecv(sc); |
135 | |
136 | sc->tx99_state = true; |
137 | |
138 | ieee80211_stop_queues(hw); |
139 | |
140 | if (sc->tx99_power == MAX_RATE_POWER + 1) |
141 | sc->tx99_power = MAX_RATE_POWER; |
142 | |
143 | ath9k_hw_tx99_set_txpower(ah, power: sc->tx99_power); |
144 | r = ath9k_tx99_send(sc, skb: sc->tx99_skb, txctl: &txctl); |
145 | if (r) { |
146 | ath_dbg(common, XMIT, "Failed to xmit TX99 skb\n" ); |
147 | return r; |
148 | } |
149 | |
150 | ath_dbg(common, XMIT, "TX99 xmit started using %d ( %ddBm)\n" , |
151 | sc->tx99_power, |
152 | sc->tx99_power / 2); |
153 | |
154 | /* We leave the hardware awake as it will be chugging on */ |
155 | |
156 | return 0; |
157 | } |
158 | |
159 | static ssize_t read_file_tx99(struct file *file, char __user *user_buf, |
160 | size_t count, loff_t *ppos) |
161 | { |
162 | struct ath_softc *sc = file->private_data; |
163 | char buf[3]; |
164 | unsigned int len; |
165 | |
166 | len = sprintf(buf, fmt: "%d\n" , sc->tx99_state); |
167 | return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len); |
168 | } |
169 | |
170 | static ssize_t write_file_tx99(struct file *file, const char __user *user_buf, |
171 | size_t count, loff_t *ppos) |
172 | { |
173 | struct ath_softc *sc = file->private_data; |
174 | struct ath_common *common = ath9k_hw_common(ah: sc->sc_ah); |
175 | bool start; |
176 | ssize_t ret; |
177 | int r; |
178 | |
179 | if (count < 1) |
180 | return -EINVAL; |
181 | |
182 | if (sc->cur_chan->nvifs > 1) |
183 | return -EOPNOTSUPP; |
184 | |
185 | ret = kstrtobool_from_user(s: user_buf, count, res: &start); |
186 | if (ret) |
187 | return ret; |
188 | |
189 | mutex_lock(&sc->mutex); |
190 | |
191 | if (start == sc->tx99_state) { |
192 | if (!start) |
193 | goto out; |
194 | ath_dbg(common, XMIT, "Resetting TX99\n" ); |
195 | ath9k_tx99_deinit(sc); |
196 | } |
197 | |
198 | if (!start) { |
199 | ath9k_tx99_deinit(sc); |
200 | goto out; |
201 | } |
202 | |
203 | r = ath9k_tx99_init(sc); |
204 | if (r) { |
205 | mutex_unlock(lock: &sc->mutex); |
206 | return r; |
207 | } |
208 | out: |
209 | mutex_unlock(lock: &sc->mutex); |
210 | return count; |
211 | } |
212 | |
213 | static const struct file_operations fops_tx99 = { |
214 | .read = read_file_tx99, |
215 | .write = write_file_tx99, |
216 | .open = simple_open, |
217 | .owner = THIS_MODULE, |
218 | .llseek = default_llseek, |
219 | }; |
220 | |
221 | static ssize_t read_file_tx99_power(struct file *file, |
222 | char __user *user_buf, |
223 | size_t count, loff_t *ppos) |
224 | { |
225 | struct ath_softc *sc = file->private_data; |
226 | char buf[32]; |
227 | unsigned int len; |
228 | |
229 | len = sprintf(buf, fmt: "%d (%d dBm)\n" , |
230 | sc->tx99_power, |
231 | sc->tx99_power / 2); |
232 | |
233 | return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len); |
234 | } |
235 | |
236 | static ssize_t write_file_tx99_power(struct file *file, |
237 | const char __user *user_buf, |
238 | size_t count, loff_t *ppos) |
239 | { |
240 | struct ath_softc *sc = file->private_data; |
241 | int r; |
242 | u8 tx_power; |
243 | |
244 | r = kstrtou8_from_user(s: user_buf, count, base: 0, res: &tx_power); |
245 | if (r) |
246 | return r; |
247 | |
248 | if (tx_power > MAX_RATE_POWER) |
249 | return -EINVAL; |
250 | |
251 | sc->tx99_power = tx_power; |
252 | |
253 | ath9k_ps_wakeup(sc); |
254 | ath9k_hw_tx99_set_txpower(ah: sc->sc_ah, power: sc->tx99_power); |
255 | ath9k_ps_restore(sc); |
256 | |
257 | return count; |
258 | } |
259 | |
260 | static const struct file_operations fops_tx99_power = { |
261 | .read = read_file_tx99_power, |
262 | .write = write_file_tx99_power, |
263 | .open = simple_open, |
264 | .owner = THIS_MODULE, |
265 | .llseek = default_llseek, |
266 | }; |
267 | |
268 | void ath9k_tx99_init_debug(struct ath_softc *sc) |
269 | { |
270 | if (!AR_SREV_9280_20_OR_LATER(sc->sc_ah)) |
271 | return; |
272 | |
273 | debugfs_create_file(name: "tx99" , mode: 0600, |
274 | parent: sc->debug.debugfs_phy, data: sc, |
275 | fops: &fops_tx99); |
276 | debugfs_create_file(name: "tx99_power" , mode: 0600, |
277 | parent: sc->debug.debugfs_phy, data: sc, |
278 | fops: &fops_tx99_power); |
279 | } |
280 | |