?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CRIS: Move common Kconfig variable ETRAX_RTC to arch independet Kconfig.
[wrt350n-kernel.git] / drivers / net / wireless / ath5k / hw.c
blob3a4bf4035a2337eb7bc0d33ea52de1db00c50e8e
1 /*
2 * Copyright (c) 2004-2007 Reyk Floeter <reyk@openbsd.org>
3 * Copyright (c) 2006-2007 Nick Kossifidis <mickflemm@gmail.com>
4 * Copyright (c) 2007 Matthew W. S. Bell <mentor@madwifi.org>
5 * Copyright (c) 2007 Luis Rodriguez <mcgrof@winlab.rutgers.edu>
6 * Copyright (c) 2007 Pavel Roskin <proski@gnu.org>
7 * Copyright (c) 2007 Jiri Slaby <jirislaby@gmail.com>
8 *
9 * Permission to use, copy, modify, and distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 *
21 */
22
23 /*
24 * HW related functions for Atheros Wireless LAN devices.
25 */
26
27 #include <linux/pci.h>
28 #include <linux/delay.h>
29
30 #include "reg.h"
31 #include "base.h"
32 #include "debug.h"
33
34 /*Rate tables*/
35 static const struct ath5k_rate_table ath5k_rt_11a = AR5K_RATES_11A;
36 static const struct ath5k_rate_table ath5k_rt_11b = AR5K_RATES_11B;
37 static const struct ath5k_rate_table ath5k_rt_11g = AR5K_RATES_11G;
38 static const struct ath5k_rate_table ath5k_rt_turbo = AR5K_RATES_TURBO;
39 static const struct ath5k_rate_table ath5k_rt_xr = AR5K_RATES_XR;
40
41 /*Prototypes*/
42 static int ath5k_hw_nic_reset(struct ath5k_hw *, u32);
43 static int ath5k_hw_nic_wakeup(struct ath5k_hw *, int, bool);
44 static int ath5k_hw_setup_4word_tx_desc(struct ath5k_hw *, struct ath5k_desc *,
45 unsigned int, unsigned int, enum ath5k_pkt_type, unsigned int,
46 unsigned int, unsigned int, unsigned int, unsigned int, unsigned int,
47 unsigned int, unsigned int);
48 static bool ath5k_hw_setup_xr_tx_desc(struct ath5k_hw *, struct ath5k_desc *,
49 unsigned int, unsigned int, unsigned int, unsigned int, unsigned int,
50 unsigned int);
51 static int ath5k_hw_proc_4word_tx_status(struct ath5k_hw *, struct ath5k_desc *);
52 static int ath5k_hw_setup_2word_tx_desc(struct ath5k_hw *, struct ath5k_desc *,
53 unsigned int, unsigned int, enum ath5k_pkt_type, unsigned int,
54 unsigned int, unsigned int, unsigned int, unsigned int, unsigned int,
55 unsigned int, unsigned int);
56 static int ath5k_hw_proc_2word_tx_status(struct ath5k_hw *, struct ath5k_desc *);
57 static int ath5k_hw_proc_new_rx_status(struct ath5k_hw *, struct ath5k_desc *);
58 static int ath5k_hw_proc_old_rx_status(struct ath5k_hw *, struct ath5k_desc *);
59 static int ath5k_hw_get_capabilities(struct ath5k_hw *);
60
61 static int ath5k_eeprom_init(struct ath5k_hw *);
62 static int ath5k_eeprom_read_mac(struct ath5k_hw *, u8 *);
63
64 static int ath5k_hw_enable_pspoll(struct ath5k_hw *, u8 *, u16);
65 static int ath5k_hw_disable_pspoll(struct ath5k_hw *);
66
67 /*
68 * Enable to overwrite the country code (use "00" for debug)
69 */
70 #if 0
71 #define COUNTRYCODE "00"
72 #endif
73
74 /*******************\
75 General Functions
76 \*******************/
77
78 /*
79 * Functions used internaly
80 */
81
82 static inline unsigned int ath5k_hw_htoclock(unsigned int usec, bool turbo)
83 {
84 return turbo == true ? (usec * 80) : (usec * 40);
85 }
86
87 static inline unsigned int ath5k_hw_clocktoh(unsigned int clock, bool turbo)
88 {
89 return turbo == true ? (clock / 80) : (clock / 40);
90 }
91
92 /*
93 * Check if a register write has been completed
94 */
95 int ath5k_hw_register_timeout(struct ath5k_hw *ah, u32 reg, u32 flag, u32 val,
96 bool is_set)
97 {
98 int i;
99 u32 data;
100
101 for (i = AR5K_TUNE_REGISTER_TIMEOUT; i > 0; i--) {
102 data = ath5k_hw_reg_read(ah, reg);
103 if ((is_set == true) && (data & flag))
104 break;
105 else if ((data & flag) == val)
106 break;
107 udelay(15);
108 }
109
110 return (i <= 0) ? -EAGAIN : 0;
111 }
112
113
114 /***************************************\
115 Attach/Detach Functions
116 \***************************************/
117
118 /*
119 * Check if the device is supported and initialize the needed structs
120 */
121 struct ath5k_hw *ath5k_hw_attach(struct ath5k_softc *sc, u8 mac_version)
122 {
123 struct ath5k_hw *ah;
124 u8 mac[ETH_ALEN];
125 int ret;
126 u32 srev;
127
128 /*If we passed the test malloc a ath5k_hw struct*/
129 ah = kzalloc(sizeof(struct ath5k_hw), GFP_KERNEL);
130 if (ah == NULL) {
131 ret = -ENOMEM;
132 ATH5K_ERR(sc, "out of memory\n");
133 goto err;
134 }
135
136 ah->ah_sc = sc;
137 ah->ah_iobase = sc->iobase;
138
139 /*
140 * HW information
141 */
142
143 /* Get reg domain from eeprom */
144 ath5k_get_regdomain(ah);
145
146 ah->ah_op_mode = IEEE80211_IF_TYPE_STA;
147 ah->ah_radar.r_enabled = AR5K_TUNE_RADAR_ALERT;
148 ah->ah_turbo = false;
149 ah->ah_txpower.txp_tpc = AR5K_TUNE_TPC_TXPOWER;
150 ah->ah_imr = 0;
151 ah->ah_atim_window = 0;
152 ah->ah_aifs = AR5K_TUNE_AIFS;
153 ah->ah_cw_min = AR5K_TUNE_CWMIN;
154 ah->ah_limit_tx_retries = AR5K_INIT_TX_RETRY;
155 ah->ah_software_retry = false;
156 ah->ah_ant_diversity = AR5K_TUNE_ANT_DIVERSITY;
157
158 /*
159 * Set the mac revision based on the pci id
160 */
161 ah->ah_version = mac_version;
162
163 /*Fill the ath5k_hw struct with the needed functions*/
164 if (ah->ah_version == AR5K_AR5212)
165 ah->ah_magic = AR5K_EEPROM_MAGIC_5212;
166 else if (ah->ah_version == AR5K_AR5211)
167 ah->ah_magic = AR5K_EEPROM_MAGIC_5211;
168
169 if (ah->ah_version == AR5K_AR5212) {
170 ah->ah_setup_tx_desc = ath5k_hw_setup_4word_tx_desc;
171 ah->ah_setup_xtx_desc = ath5k_hw_setup_xr_tx_desc;
172 ah->ah_proc_tx_desc = ath5k_hw_proc_4word_tx_status;
173 } else {
174 ah->ah_setup_tx_desc = ath5k_hw_setup_2word_tx_desc;
175 ah->ah_setup_xtx_desc = ath5k_hw_setup_xr_tx_desc;
176 ah->ah_proc_tx_desc = ath5k_hw_proc_2word_tx_status;
177 }
178
179 if (ah->ah_version == AR5K_AR5212)
180 ah->ah_proc_rx_desc = ath5k_hw_proc_new_rx_status;
181 else if (ah->ah_version <= AR5K_AR5211)
182 ah->ah_proc_rx_desc = ath5k_hw_proc_old_rx_status;
183
184 /* Bring device out of sleep and reset it's units */
185 ret = ath5k_hw_nic_wakeup(ah, AR5K_INIT_MODE, true);
186 if (ret)
187 goto err_free;
188
189 /* Get MAC, PHY and RADIO revisions */
190 srev = ath5k_hw_reg_read(ah, AR5K_SREV);
191 ah->ah_mac_srev = srev;
192 ah->ah_mac_version = AR5K_REG_MS(srev, AR5K_SREV_VER);
193 ah->ah_mac_revision = AR5K_REG_MS(srev, AR5K_SREV_REV);
194 ah->ah_phy_revision = ath5k_hw_reg_read(ah, AR5K_PHY_CHIP_ID) &
195 0xffffffff;
196 ah->ah_radio_5ghz_revision = ath5k_hw_radio_revision(ah,
197 CHANNEL_5GHZ);
198
199 if (ah->ah_version == AR5K_AR5210)
200 ah->ah_radio_2ghz_revision = 0;
201 else
202 ah->ah_radio_2ghz_revision = ath5k_hw_radio_revision(ah,
203 CHANNEL_2GHZ);
204
205 /* Return on unsuported chips (unsupported eeprom etc) */
206 if(srev >= AR5K_SREV_VER_AR5416){
207 ATH5K_ERR(sc, "Device not yet supported.\n");
208 ret = -ENODEV;
209 goto err_free;
210 }
211
212 /* Identify single chip solutions */
213 if((srev <= AR5K_SREV_VER_AR5414) &&
214 (srev >= AR5K_SREV_VER_AR2424)) {
215 ah->ah_single_chip = true;
216 } else {
217 ah->ah_single_chip = false;
218 }
219
220 /* Single chip radio */
221 if (ah->ah_radio_2ghz_revision == ah->ah_radio_5ghz_revision)
222 ah->ah_radio_2ghz_revision = 0;
223
224 /* Identify the radio chip*/
225 if (ah->ah_version == AR5K_AR5210) {
226 ah->ah_radio = AR5K_RF5110;
227 } else if (ah->ah_radio_5ghz_revision < AR5K_SREV_RAD_5112) {
228 ah->ah_radio = AR5K_RF5111;
229 } else if (ah->ah_radio_5ghz_revision < AR5K_SREV_RAD_SC1) {
230 ah->ah_radio = AR5K_RF5112;
231 } else {
232 ah->ah_radio = AR5K_RF5413;
233 }
234
235 ah->ah_phy = AR5K_PHY(0);
236
237 /*
238 * Get card capabilities, values, ...
239 */
240
241 ret = ath5k_eeprom_init(ah);
242 if (ret) {
243 ATH5K_ERR(sc, "unable to init EEPROM\n");
244 goto err_free;
245 }
246
247 /* Get misc capabilities */
248 ret = ath5k_hw_get_capabilities(ah);
249 if (ret) {
250 ATH5K_ERR(sc, "unable to get device capabilities: 0x%04x\n",
251 sc->pdev->device);
252 goto err_free;
253 }
254
255 /* Get MAC address */
256 ret = ath5k_eeprom_read_mac(ah, mac);
257 if (ret) {
258 ATH5K_ERR(sc, "unable to read address from EEPROM: 0x%04x\n",
259 sc->pdev->device);
260 goto err_free;
261 }
262
263 ath5k_hw_set_lladdr(ah, mac);
264 /* Set BSSID to bcast address: ff:ff:ff:ff:ff:ff for now */
265 memset(ah->ah_bssid, 0xff, ETH_ALEN);
266 ath5k_hw_set_associd(ah, ah->ah_bssid, 0);
267 ath5k_hw_set_opmode(ah);
268
269 ath5k_hw_set_rfgain_opt(ah);
270
271 return ah;
272 err_free:
273 kfree(ah);
274 err:
275 return ERR_PTR(ret);
276 }
277
278 /*
279 * Bring up MAC + PHY Chips
280 */
281 static int ath5k_hw_nic_wakeup(struct ath5k_hw *ah, int flags, bool initial)
282 {
283 u32 turbo, mode, clock;
284 int ret;
285
286 turbo = 0;
287 mode = 0;
288 clock = 0;
289
290 ATH5K_TRACE(ah->ah_sc);
291
292 /* Wakeup the device */
293 ret = ath5k_hw_set_power(ah, AR5K_PM_AWAKE, true, 0);
294 if (ret) {
295 ATH5K_ERR(ah->ah_sc, "failed to wakeup the MAC Chip\n");
296 return ret;
297 }
298
299 if (ah->ah_version != AR5K_AR5210) {
300 /*
301 * Get channel mode flags
302 */
303
304 if (ah->ah_radio >= AR5K_RF5112) {
305 mode = AR5K_PHY_MODE_RAD_RF5112;
306 clock = AR5K_PHY_PLL_RF5112;
307 } else {
308 mode = AR5K_PHY_MODE_RAD_RF5111; /*Zero*/
309 clock = AR5K_PHY_PLL_RF5111; /*Zero*/
310 }
311
312 if (flags & CHANNEL_2GHZ) {
313 mode |= AR5K_PHY_MODE_FREQ_2GHZ;
314 clock |= AR5K_PHY_PLL_44MHZ;
315
316 if (flags & CHANNEL_CCK) {
317 mode |= AR5K_PHY_MODE_MOD_CCK;
318 } else if (flags & CHANNEL_OFDM) {
319 /* XXX Dynamic OFDM/CCK is not supported by the
320 * AR5211 so we set MOD_OFDM for plain g (no
321 * CCK headers) operation. We need to test
322 * this, 5211 might support ofdm-only g after
323 * all, there are also initial register values
324 * in the code for g mode (see initvals.c). */
325 if (ah->ah_version == AR5K_AR5211)
326 mode |= AR5K_PHY_MODE_MOD_OFDM;
327 else
328 mode |= AR5K_PHY_MODE_MOD_DYN;
329 } else {
330 ATH5K_ERR(ah->ah_sc,
331 "invalid radio modulation mode\n");
332 return -EINVAL;
333 }
334 } else if (flags & CHANNEL_5GHZ) {
335 mode |= AR5K_PHY_MODE_FREQ_5GHZ;
336 clock |= AR5K_PHY_PLL_40MHZ;
337
338 if (flags & CHANNEL_OFDM)
339 mode |= AR5K_PHY_MODE_MOD_OFDM;
340 else {
341 ATH5K_ERR(ah->ah_sc,
342 "invalid radio modulation mode\n");
343 return -EINVAL;
344 }
345 } else {
346 ATH5K_ERR(ah->ah_sc, "invalid radio frequency mode\n");
347 return -EINVAL;
348 }
349
350 if (flags & CHANNEL_TURBO)
351 turbo = AR5K_PHY_TURBO_MODE | AR5K_PHY_TURBO_SHORT;
352 } else { /* Reset the device */
353
354 /* ...enable Atheros turbo mode if requested */
355 if (flags & CHANNEL_TURBO)
356 ath5k_hw_reg_write(ah, AR5K_PHY_TURBO_MODE,
357 AR5K_PHY_TURBO);
358 }
359
360 /* ...reset chipset and PCI device */
361 if (ah->ah_single_chip == false && ath5k_hw_nic_reset(ah,
362 AR5K_RESET_CTL_CHIP | AR5K_RESET_CTL_PCI)) {
363 ATH5K_ERR(ah->ah_sc, "failed to reset the MAC Chip + PCI\n");
364 return -EIO;
365 }
366
367 if (ah->ah_version == AR5K_AR5210)
368 udelay(2300);
369
370 /* ...wakeup again!*/
371 ret = ath5k_hw_set_power(ah, AR5K_PM_AWAKE, true, 0);
372 if (ret) {
373 ATH5K_ERR(ah->ah_sc, "failed to resume the MAC Chip\n");
374 return ret;
375 }
376
377 /* ...final warm reset */
378 if (ath5k_hw_nic_reset(ah, 0)) {
379 ATH5K_ERR(ah->ah_sc, "failed to warm reset the MAC Chip\n");
380 return -EIO;
381 }
382
383 if (ah->ah_version != AR5K_AR5210) {
384 /* ...set the PHY operating mode */
385 ath5k_hw_reg_write(ah, clock, AR5K_PHY_PLL);
386 udelay(300);
387
388 ath5k_hw_reg_write(ah, mode, AR5K_PHY_MODE);
389 ath5k_hw_reg_write(ah, turbo, AR5K_PHY_TURBO);
390 }
391
392 return 0;
393 }
394
395 /*
396 * Get the rate table for a specific operation mode
397 */
398 const struct ath5k_rate_table *ath5k_hw_get_rate_table(struct ath5k_hw *ah,
399 unsigned int mode)
400 {
401 ATH5K_TRACE(ah->ah_sc);
402
403 if (!test_bit(mode, ah->ah_capabilities.cap_mode))
404 return NULL;
405
406 /* Get rate tables */
407 switch (mode) {
408 case MODE_IEEE80211A:
409 return &ath5k_rt_11a;
410 case MODE_ATHEROS_TURBO:
411 return &ath5k_rt_turbo;
412 case MODE_IEEE80211B:
413 return &ath5k_rt_11b;
414 case MODE_IEEE80211G:
415 return &ath5k_rt_11g;
416 case MODE_ATHEROS_TURBOG:
417 return &ath5k_rt_xr;
418 }
419
420 return NULL;
421 }
422
423 /*
424 * Free the ath5k_hw struct
425 */
426 void ath5k_hw_detach(struct ath5k_hw *ah)
427 {
428 ATH5K_TRACE(ah->ah_sc);
429
430 if (ah->ah_rf_banks != NULL)
431 kfree(ah->ah_rf_banks);
432
433 /* assume interrupts are down */
434 kfree(ah);
435 }
436
437 /****************************\
438 Reset function and helpers
439 \****************************/
440
441 /**
442 * ath5k_hw_write_ofdm_timings - set OFDM timings on AR5212
443 *
444 * @ah: the &struct ath5k_hw
445 * @channel: the currently set channel upon reset
446 *
447 * Write the OFDM timings for the AR5212 upon reset. This is a helper for
448 * ath5k_hw_reset(). This seems to tune the PLL a specified frequency
449 * depending on the bandwidth of the channel.
450 *
451 */
452 static inline int ath5k_hw_write_ofdm_timings(struct ath5k_hw *ah,
453 struct ieee80211_channel *channel)
454 {
455 /* Get exponent and mantissa and set it */
456 u32 coef_scaled, coef_exp, coef_man,
457 ds_coef_exp, ds_coef_man, clock;
458
459 if (!(ah->ah_version == AR5K_AR5212) ||
460 !(channel->val & CHANNEL_OFDM))
461 BUG();
462
463 /* Seems there are two PLLs, one for baseband sampling and one
464 * for tuning. Tuning basebands are 40 MHz or 80MHz when in
465 * turbo. */
466 clock = channel->val & CHANNEL_TURBO ? 80 : 40;
467 coef_scaled = ((5 * (clock << 24)) / 2) /
468 channel->freq;
469
470 for (coef_exp = 31; coef_exp > 0; coef_exp--)
471 if ((coef_scaled >> coef_exp) & 0x1)
472 break;
473
474 if (!coef_exp)
475 return -EINVAL;
476
477 coef_exp = 14 - (coef_exp - 24);
478 coef_man = coef_scaled +
479 (1 << (24 - coef_exp - 1));
480 ds_coef_man = coef_man >> (24 - coef_exp);
481 ds_coef_exp = coef_exp - 16;
482
483 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_TIMING_3,
484 AR5K_PHY_TIMING_3_DSC_MAN, ds_coef_man);
485 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_TIMING_3,
486 AR5K_PHY_TIMING_3_DSC_EXP, ds_coef_exp);
487
488 return 0;
489 }
490
491 /**
492 * ath5k_hw_write_rate_duration - set rate duration during hw resets
493 *
494 * @ah: the &struct ath5k_hw
495 * @driver_mode: one of enum ieee80211_phymode or our one of our own
496 * vendor modes
497 *
498 * Write the rate duration table for the current mode upon hw reset. This
499 * is a helper for ath5k_hw_reset(). It seems all this is doing is setting
500 * an ACK timeout for the hardware for the current mode for each rate. The
501 * rates which are capable of short preamble (802.11b rates 2Mbps, 5.5Mbps,
502 * and 11Mbps) have another register for the short preamble ACK timeout
503 * calculation.
504 *
505 */
506 static inline void ath5k_hw_write_rate_duration(struct ath5k_hw *ah,
507 unsigned int driver_mode)
508 {
509 struct ath5k_softc *sc = ah->ah_sc;
510 const struct ath5k_rate_table *rt;
511 unsigned int i;
512
513 /* Get rate table for the current operating mode */
514 rt = ath5k_hw_get_rate_table(ah,
515 driver_mode);
516
517 /* Write rate duration table */
518 for (i = 0; i < rt->rate_count; i++) {
519 const struct ath5k_rate *rate, *control_rate;
520 u32 reg;
521 u16 tx_time;
522
523 rate = &rt->rates[i];
524 control_rate = &rt->rates[rate->control_rate];
525
526 /* Set ACK timeout */
527 reg = AR5K_RATE_DUR(rate->rate_code);
528
529 /* An ACK frame consists of 10 bytes. If you add the FCS,
530 * which ieee80211_generic_frame_duration() adds,
531 * its 14 bytes. Note we use the control rate and not the
532 * actual rate for this rate. See mac80211 tx.c
533 * ieee80211_duration() for a brief description of
534 * what rate we should choose to TX ACKs. */
535 tx_time = ieee80211_generic_frame_duration(sc->hw,
536 sc->vif, 10, control_rate->rate_kbps/100);
537
538 ath5k_hw_reg_write(ah, tx_time, reg);
539
540 if (!HAS_SHPREAMBLE(i))
541 continue;
542
543 /*
544 * We're not distinguishing short preamble here,
545 * This is true, all we'll get is a longer value here
546 * which is not necessarilly bad. We could use
547 * export ieee80211_frame_duration() but that needs to be
548 * fixed first to be properly used by mac802111 drivers:
549 *
550 * - remove erp stuff and let the routine figure ofdm
551 * erp rates
552 * - remove passing argument ieee80211_local as
553 * drivers don't have access to it
554 * - move drivers using ieee80211_generic_frame_duration()
555 * to this
556 */
557 ath5k_hw_reg_write(ah, tx_time,
558 reg + (AR5K_SET_SHORT_PREAMBLE << 2));
559 }
560 }
561
562 /*
563 * Main reset function
564 */
565 int ath5k_hw_reset(struct ath5k_hw *ah, enum ieee80211_if_types op_mode,
566 struct ieee80211_channel *channel, bool change_channel)
567 {
568 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
569 u32 data, s_seq, s_ant, s_led[3];
570 unsigned int i, mode, freq, ee_mode, ant[2], driver_mode = -1;
571 int ret;
572
573 ATH5K_TRACE(ah->ah_sc);
574
575 s_seq = 0;
576 s_ant = 0;
577 ee_mode = 0;
578 freq = 0;
579 mode = 0;
580
581 /*
582 * Save some registers before a reset
583 */
584 /*DCU/Antenna selection not available on 5210*/
585 if (ah->ah_version != AR5K_AR5210) {
586 if (change_channel == true) {
587 /* Seq number for queue 0 -do this for all queues ? */
588 s_seq = ath5k_hw_reg_read(ah,
589 AR5K_QUEUE_DFS_SEQNUM(0));
590 /*Default antenna*/
591 s_ant = ath5k_hw_reg_read(ah, AR5K_DEFAULT_ANTENNA);
592 }
593 }
594
595 /*GPIOs*/
596 s_led[0] = ath5k_hw_reg_read(ah, AR5K_PCICFG) & AR5K_PCICFG_LEDSTATE;
597 s_led[1] = ath5k_hw_reg_read(ah, AR5K_GPIOCR);
598 s_led[2] = ath5k_hw_reg_read(ah, AR5K_GPIODO);
599
600 if (change_channel == true && ah->ah_rf_banks != NULL)
601 ath5k_hw_get_rf_gain(ah);
602
603
604 /*Wakeup the device*/
605 ret = ath5k_hw_nic_wakeup(ah, channel->val, false);
606 if (ret)
607 return ret;
608
609 /*
610 * Initialize operating mode
611 */
612 ah->ah_op_mode = op_mode;
613
614 /*
615 * 5111/5112 Settings
616 * 5210 only comes with RF5110
617 */
618 if (ah->ah_version != AR5K_AR5210) {
619 if (ah->ah_radio != AR5K_RF5111 &&
620 ah->ah_radio != AR5K_RF5112 &&
621 ah->ah_radio != AR5K_RF5413) {
622 ATH5K_ERR(ah->ah_sc,
623 "invalid phy radio: %u\n", ah->ah_radio);
624 return -EINVAL;
625 }
626
627 switch (channel->val & CHANNEL_MODES) {
628 case CHANNEL_A:
629 mode = AR5K_INI_VAL_11A;
630 freq = AR5K_INI_RFGAIN_5GHZ;
631 ee_mode = AR5K_EEPROM_MODE_11A;
632 driver_mode = MODE_IEEE80211A;
633 break;
634 case CHANNEL_G:
635 mode = AR5K_INI_VAL_11G;
636 freq = AR5K_INI_RFGAIN_2GHZ;
637 ee_mode = AR5K_EEPROM_MODE_11G;
638 driver_mode = MODE_IEEE80211G;
639 break;
640 case CHANNEL_B:
641 mode = AR5K_INI_VAL_11B;
642 freq = AR5K_INI_RFGAIN_2GHZ;
643 ee_mode = AR5K_EEPROM_MODE_11B;
644 driver_mode = MODE_IEEE80211B;
645 break;
646 case CHANNEL_T:
647 mode = AR5K_INI_VAL_11A_TURBO;
648 freq = AR5K_INI_RFGAIN_5GHZ;
649 ee_mode = AR5K_EEPROM_MODE_11A;
650 driver_mode = MODE_ATHEROS_TURBO;
651 break;
652 /*Is this ok on 5211 too ?*/
653 case CHANNEL_TG:
654 mode = AR5K_INI_VAL_11G_TURBO;
655 freq = AR5K_INI_RFGAIN_2GHZ;
656 ee_mode = AR5K_EEPROM_MODE_11G;
657 driver_mode = MODE_ATHEROS_TURBOG;
658 break;
659 case CHANNEL_XR:
660 if (ah->ah_version == AR5K_AR5211) {
661 ATH5K_ERR(ah->ah_sc,
662 "XR mode not available on 5211");
663 return -EINVAL;
664 }
665 mode = AR5K_INI_VAL_XR;
666 freq = AR5K_INI_RFGAIN_5GHZ;
667 ee_mode = AR5K_EEPROM_MODE_11A;
668 driver_mode = MODE_IEEE80211A;
669 break;
670 default:
671 ATH5K_ERR(ah->ah_sc,
672 "invalid channel: %d\n", channel->freq);
673 return -EINVAL;
674 }
675
676 /* PHY access enable */
677 ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_5GHZ, AR5K_PHY(0));
678
679 }
680
681 ret = ath5k_hw_write_initvals(ah, mode, change_channel);
682 if (ret)
683 return ret;
684
685 /*
686 * 5211/5212 Specific
687 */
688 if (ah->ah_version != AR5K_AR5210) {
689 /*
690 * Write initial RF gain settings
691 * This should work for both 5111/5112
692 */
693 ret = ath5k_hw_rfgain(ah, freq);
694 if (ret)
695 return ret;
696
697 mdelay(1);
698
699 /*
700 * Write some more initial register settings
701 */
702 if (ah->ah_version > AR5K_AR5211){ /* found on 5213+ */
703 ath5k_hw_reg_write(ah, 0x0002a002, AR5K_PHY(11));
704
705 if (channel->val == CHANNEL_G)
706 ath5k_hw_reg_write(ah, 0x00f80d80, AR5K_PHY(83)); /* 0x00fc0ec0 */
707 else
708 ath5k_hw_reg_write(ah, 0x00000000, AR5K_PHY(83));
709
710 ath5k_hw_reg_write(ah, 0x000001b5, 0xa228); /* 0x000009b5 */
711 ath5k_hw_reg_write(ah, 0x000009b5, 0xa228);
712 ath5k_hw_reg_write(ah, 0x0000000f, 0x8060);
713 ath5k_hw_reg_write(ah, 0x00000000, 0xa254);
714 ath5k_hw_reg_write(ah, 0x0000000e, AR5K_PHY_SCAL);
715 }
716
717 /* Fix for first revision of the RF5112 RF chipset */
718 if (ah->ah_radio >= AR5K_RF5112 &&
719 ah->ah_radio_5ghz_revision <
720 AR5K_SREV_RAD_5112A) {
721 ath5k_hw_reg_write(ah, AR5K_PHY_CCKTXCTL_WORLD,
722 AR5K_PHY_CCKTXCTL);
723 if (channel->val & CHANNEL_5GHZ)
724 data = 0xffb81020;
725 else
726 data = 0xffb80d20;
727 ath5k_hw_reg_write(ah, data, AR5K_PHY_FRAME_CTL);
728 }
729
730 /*
731 * Set TX power (FIXME)
732 */
733 ret = ath5k_hw_txpower(ah, channel, AR5K_TUNE_DEFAULT_TXPOWER);
734 if (ret)
735 return ret;
736
737 /* Write rate duration table only on AR5212 and if
738 * virtual interface has already been brought up
739 * XXX: rethink this after new mode changes to
740 * mac80211 are integrated */
741 if (ah->ah_version == AR5K_AR5212 &&
742 ah->ah_sc->vif != NULL)
743 ath5k_hw_write_rate_duration(ah, driver_mode);
744
745 /*
746 * Write RF registers
747 * TODO:Does this work on 5211 (5111) ?
748 */
749 ret = ath5k_hw_rfregs(ah, channel, mode);
750 if (ret)
751 return ret;
752
753 /*
754 * Configure additional registers
755 */
756
757 /* Write OFDM timings on 5212*/
758 if (ah->ah_version == AR5K_AR5212 &&
759 channel->val & CHANNEL_OFDM) {
760 ret = ath5k_hw_write_ofdm_timings(ah, channel);
761 if (ret)
762 return ret;
763 }
764
765 /*Enable/disable 802.11b mode on 5111
766 (enable 2111 frequency converter + CCK)*/
767 if (ah->ah_radio == AR5K_RF5111) {
768 if (driver_mode == MODE_IEEE80211B)
769 AR5K_REG_ENABLE_BITS(ah, AR5K_TXCFG,
770 AR5K_TXCFG_B_MODE);
771 else
772 AR5K_REG_DISABLE_BITS(ah, AR5K_TXCFG,
773 AR5K_TXCFG_B_MODE);
774 }
775
776 /*
777 * Set channel and calibrate the PHY
778 */
779 ret = ath5k_hw_channel(ah, channel);
780 if (ret)
781 return ret;
782
783 /* Set antenna mode */
784 AR5K_REG_MASKED_BITS(ah, AR5K_PHY(0x44),
785 ah->ah_antenna[ee_mode][0], 0xfffffc06);
786
787 /*
788 * In case a fixed antenna was set as default
789 * write the same settings on both AR5K_PHY_ANT_SWITCH_TABLE
790 * registers.
791 */
792 if (s_ant != 0){
793 if (s_ant == AR5K_ANT_FIXED_A) /* 1 - Main */
794 ant[0] = ant[1] = AR5K_ANT_FIXED_A;
795 else /* 2 - Aux */
796 ant[0] = ant[1] = AR5K_ANT_FIXED_B;
797 } else {
798 ant[0] = AR5K_ANT_FIXED_A;
799 ant[1] = AR5K_ANT_FIXED_B;
800 }
801
802 ath5k_hw_reg_write(ah, ah->ah_antenna[ee_mode][ant[0]],
803 AR5K_PHY_ANT_SWITCH_TABLE_0);
804 ath5k_hw_reg_write(ah, ah->ah_antenna[ee_mode][ant[1]],
805 AR5K_PHY_ANT_SWITCH_TABLE_1);
806
807 /* Commit values from EEPROM */
808 if (ah->ah_radio == AR5K_RF5111)
809 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_FRAME_CTL,
810 AR5K_PHY_FRAME_CTL_TX_CLIP, ee->ee_tx_clip);
811
812 ath5k_hw_reg_write(ah,
813 AR5K_PHY_NF_SVAL(ee->ee_noise_floor_thr[ee_mode]),
814 AR5K_PHY(0x5a));
815
816 AR5K_REG_MASKED_BITS(ah, AR5K_PHY(0x11),
817 (ee->ee_switch_settling[ee_mode] << 7) & 0x3f80,
818 0xffffc07f);
819 AR5K_REG_MASKED_BITS(ah, AR5K_PHY(0x12),
820 (ee->ee_ant_tx_rx[ee_mode] << 12) & 0x3f000,
821 0xfffc0fff);
822 AR5K_REG_MASKED_BITS(ah, AR5K_PHY(0x14),
823 (ee->ee_adc_desired_size[ee_mode] & 0x00ff) |
824 ((ee->ee_pga_desired_size[ee_mode] << 8) & 0xff00),
825 0xffff0000);
826
827 ath5k_hw_reg_write(ah,
828 (ee->ee_tx_end2xpa_disable[ee_mode] << 24) |
829 (ee->ee_tx_end2xpa_disable[ee_mode] << 16) |
830 (ee->ee_tx_frm2xpa_enable[ee_mode] << 8) |
831 (ee->ee_tx_frm2xpa_enable[ee_mode]), AR5K_PHY(0x0d));
832
833 AR5K_REG_MASKED_BITS(ah, AR5K_PHY(0x0a),
834 ee->ee_tx_end2xlna_enable[ee_mode] << 8, 0xffff00ff);
835 AR5K_REG_MASKED_BITS(ah, AR5K_PHY(0x19),
836 (ee->ee_thr_62[ee_mode] << 12) & 0x7f000, 0xfff80fff);
837 AR5K_REG_MASKED_BITS(ah, AR5K_PHY(0x49), 4, 0xffffff01);
838
839 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_IQ,
840 AR5K_PHY_IQ_CORR_ENABLE |
841 (ee->ee_i_cal[ee_mode] << AR5K_PHY_IQ_CORR_Q_I_COFF_S) |
842 ee->ee_q_cal[ee_mode]);
843
844 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_1)
845 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_GAIN_2GHZ,
846 AR5K_PHY_GAIN_2GHZ_MARGIN_TXRX,
847 ee->ee_margin_tx_rx[ee_mode]);
848
849 } else {
850 mdelay(1);
851 /* Disable phy and wait */
852 ath5k_hw_reg_write(ah, AR5K_PHY_ACT_DISABLE, AR5K_PHY_ACT);
853 mdelay(1);
854 }
855
856 /*
857 * Restore saved values
858 */
859 /*DCU/Antenna selection not available on 5210*/
860 if (ah->ah_version != AR5K_AR5210) {
861 ath5k_hw_reg_write(ah, s_seq, AR5K_QUEUE_DFS_SEQNUM(0));
862 ath5k_hw_reg_write(ah, s_ant, AR5K_DEFAULT_ANTENNA);
863 }
864 AR5K_REG_ENABLE_BITS(ah, AR5K_PCICFG, s_led[0]);
865 ath5k_hw_reg_write(ah, s_led[1], AR5K_GPIOCR);
866 ath5k_hw_reg_write(ah, s_led[2], AR5K_GPIODO);
867
868 /*
869 * Misc
870 */
871 /* XXX: add ah->aid once mac80211 gives this to us */
872 ath5k_hw_set_associd(ah, ah->ah_bssid, 0);
873
874 ath5k_hw_set_opmode(ah);
875 /*PISR/SISR Not available on 5210*/
876 if (ah->ah_version != AR5K_AR5210) {
877 ath5k_hw_reg_write(ah, 0xffffffff, AR5K_PISR);
878 /* If we later allow tuning for this, store into sc structure */
879 data = AR5K_TUNE_RSSI_THRES |
880 AR5K_TUNE_BMISS_THRES << AR5K_RSSI_THR_BMISS_S;
881 ath5k_hw_reg_write(ah, data, AR5K_RSSI_THR);
882 }
883
884 /*
885 * Set Rx/Tx DMA Configuration
886 *(passing dma size not available on 5210)
887 */
888 if (ah->ah_version != AR5K_AR5210) {
889 AR5K_REG_WRITE_BITS(ah, AR5K_TXCFG, AR5K_TXCFG_SDMAMR,
890 AR5K_DMASIZE_512B | AR5K_TXCFG_DMASIZE);
891 AR5K_REG_WRITE_BITS(ah, AR5K_RXCFG, AR5K_RXCFG_SDMAMW,
892 AR5K_DMASIZE_512B);
893 }
894
895 /*
896 * Enable the PHY and wait until completion
897 */
898 ath5k_hw_reg_write(ah, AR5K_PHY_ACT_ENABLE, AR5K_PHY_ACT);
899
900 /*
901 * 5111/5112 Specific
902 */
903 if (ah->ah_version != AR5K_AR5210) {
904 data = ath5k_hw_reg_read(ah, AR5K_PHY_RX_DELAY) &
905 AR5K_PHY_RX_DELAY_M;
906 data = (channel->val & CHANNEL_CCK) ?
907 ((data << 2) / 22) : (data / 10);
908
909 udelay(100 + data);
910 } else {
911 mdelay(1);
912 }
913
914 /*
915 * Enable calibration and wait until completion
916 */
917 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_AGCCTL,
918 AR5K_PHY_AGCCTL_CAL);
919
920 if (ath5k_hw_register_timeout(ah, AR5K_PHY_AGCCTL,
921 AR5K_PHY_AGCCTL_CAL, 0, false)) {
922 ATH5K_ERR(ah->ah_sc, "calibration timeout (%uMHz)\n",
923 channel->freq);
924 return -EAGAIN;
925 }
926
927 ret = ath5k_hw_noise_floor_calibration(ah, channel->freq);
928 if (ret)
929 return ret;
930
931 ah->ah_calibration = false;
932
933 /* A and G modes can use QAM modulation which requires enabling
934 * I and Q calibration. Don't bother in B mode. */
935 if (!(driver_mode == MODE_IEEE80211B)) {
936 ah->ah_calibration = true;
937 AR5K_REG_WRITE_BITS(ah, AR5K_PHY_IQ,
938 AR5K_PHY_IQ_CAL_NUM_LOG_MAX, 15);
939 AR5K_REG_ENABLE_BITS(ah, AR5K_PHY_IQ,
940 AR5K_PHY_IQ_RUN);
941 }
942
943 /*
944 * Reset queues and start beacon timers at the end of the reset routine
945 */
946 for (i = 0; i < ah->ah_capabilities.cap_queues.q_tx_num; i++) {
947 /*No QCU on 5210*/
948 if (ah->ah_version != AR5K_AR5210)
949 AR5K_REG_WRITE_Q(ah, AR5K_QUEUE_QCUMASK(i), i);
950
951 ret = ath5k_hw_reset_tx_queue(ah, i);
952 if (ret) {
953 ATH5K_ERR(ah->ah_sc,
954 "failed to reset TX queue #%d\n", i);
955 return ret;
956 }
957 }
958
959 /* Pre-enable interrupts on 5211/5212*/
960 if (ah->ah_version != AR5K_AR5210)
961 ath5k_hw_set_intr(ah, AR5K_INT_RX | AR5K_INT_TX |
962 AR5K_INT_FATAL);
963
964 /*
965 * Set RF kill flags if supported by the device (read from the EEPROM)
966 * Disable gpio_intr for now since it results system hang.
967 * TODO: Handle this in ath5k_intr
968 */
969 #if 0
970 if (AR5K_EEPROM_HDR_RFKILL(ah->ah_capabilities.cap_eeprom.ee_header)) {
971 ath5k_hw_set_gpio_input(ah, 0);
972 ah->ah_gpio[0] = ath5k_hw_get_gpio(ah, 0);
973 if (ah->ah_gpio[0] == 0)
974 ath5k_hw_set_gpio_intr(ah, 0, 1);
975 else
976 ath5k_hw_set_gpio_intr(ah, 0, 0);
977 }
978 #endif
979
980 /*
981 * Set the 32MHz reference clock on 5212 phy clock sleep register
982 */
983 if (ah->ah_version == AR5K_AR5212) {
984 ath5k_hw_reg_write(ah, AR5K_PHY_SCR_32MHZ, AR5K_PHY_SCR);
985 ath5k_hw_reg_write(ah, AR5K_PHY_SLMT_32MHZ, AR5K_PHY_SLMT);
986 ath5k_hw_reg_write(ah, AR5K_PHY_SCAL_32MHZ, AR5K_PHY_SCAL);
987 ath5k_hw_reg_write(ah, AR5K_PHY_SCLOCK_32MHZ, AR5K_PHY_SCLOCK);
988 ath5k_hw_reg_write(ah, AR5K_PHY_SDELAY_32MHZ, AR5K_PHY_SDELAY);
989 ath5k_hw_reg_write(ah, ah->ah_radio == AR5K_RF5111 ?
990 AR5K_PHY_SPENDING_RF5111 : AR5K_PHY_SPENDING_RF5112,
991 AR5K_PHY_SPENDING);
992 }
993
994 /*
995 * Disable beacons and reset the register
996 */
997 AR5K_REG_DISABLE_BITS(ah, AR5K_BEACON, AR5K_BEACON_ENABLE |
998 AR5K_BEACON_RESET_TSF);
999
1000 return 0;
1001 }
1002
1003 /*
1004 * Reset chipset
1005 */
1006 static int ath5k_hw_nic_reset(struct ath5k_hw *ah, u32 val)
1007 {
1008 int ret;
1009 u32 mask = val ? val : ~0U;
1010
1011 ATH5K_TRACE(ah->ah_sc);
1012
1013 /* Read-and-clear RX Descriptor Pointer*/
1014 ath5k_hw_reg_read(ah, AR5K_RXDP);
1015
1016 /*
1017 * Reset the device and wait until success
1018 */
1019 ath5k_hw_reg_write(ah, val, AR5K_RESET_CTL);
1020
1021 /* Wait at least 128 PCI clocks */
1022 udelay(15);
1023
1024 if (ah->ah_version == AR5K_AR5210) {
1025 val &= AR5K_RESET_CTL_CHIP;
1026 mask &= AR5K_RESET_CTL_CHIP;
1027 } else {
1028 val &= AR5K_RESET_CTL_PCU | AR5K_RESET_CTL_BASEBAND;
1029 mask &= AR5K_RESET_CTL_PCU | AR5K_RESET_CTL_BASEBAND;
1030 }
1031
1032 ret = ath5k_hw_register_timeout(ah, AR5K_RESET_CTL, mask, val, false);
1033
1034 /*
1035 * Reset configuration register (for hw byte-swap). Note that this
1036 * is only set for big endian. We do the necessary magic in
1037 * AR5K_INIT_CFG.
1038 */
1039 if ((val & AR5K_RESET_CTL_PCU) == 0)
1040 ath5k_hw_reg_write(ah, AR5K_INIT_CFG, AR5K_CFG);
1041
1042 return ret;
1043 }
1044
1045 /*
1046 * Power management functions
1047 */
1048
1049 /*
1050 * Sleep control
1051 */
1052 int ath5k_hw_set_power(struct ath5k_hw *ah, enum ath5k_power_mode mode,
1053 bool set_chip, u16 sleep_duration)
1054 {
1055 unsigned int i;
1056 u32 staid;
1057
1058 ATH5K_TRACE(ah->ah_sc);
1059 staid = ath5k_hw_reg_read(ah, AR5K_STA_ID1);
1060
1061 switch (mode) {
1062 case AR5K_PM_AUTO:
1063 staid &= ~AR5K_STA_ID1_DEFAULT_ANTENNA;
1064 /* fallthrough */
1065 case AR5K_PM_NETWORK_SLEEP:
1066 if (set_chip == true)
1067 ath5k_hw_reg_write(ah,
1068 AR5K_SLEEP_CTL_SLE | sleep_duration,
1069 AR5K_SLEEP_CTL);
1070
1071 staid |= AR5K_STA_ID1_PWR_SV;
1072 break;
1073
1074 case AR5K_PM_FULL_SLEEP:
1075 if (set_chip == true)
1076 ath5k_hw_reg_write(ah, AR5K_SLEEP_CTL_SLE_SLP,
1077 AR5K_SLEEP_CTL);
1078
1079 staid |= AR5K_STA_ID1_PWR_SV;
1080 break;
1081
1082 case AR5K_PM_AWAKE:
1083 if (set_chip == false)
1084 goto commit;
1085
1086 ath5k_hw_reg_write(ah, AR5K_SLEEP_CTL_SLE_WAKE,
1087 AR5K_SLEEP_CTL);
1088
1089 for (i = 5000; i > 0; i--) {
1090 /* Check if the chip did wake up */
1091 if ((ath5k_hw_reg_read(ah, AR5K_PCICFG) &
1092 AR5K_PCICFG_SPWR_DN) == 0)
1093 break;
1094
1095 /* Wait a bit and retry */
1096 udelay(200);
1097 ath5k_hw_reg_write(ah, AR5K_SLEEP_CTL_SLE_WAKE,
1098 AR5K_SLEEP_CTL);
1099 }
1100
1101 /* Fail if the chip didn't wake up */
1102 if (i <= 0)
1103 return -EIO;
1104
1105 staid &= ~AR5K_STA_ID1_PWR_SV;
1106 break;
1107
1108 default:
1109 return -EINVAL;
1110 }
1111
1112 commit:
1113 ah->ah_power_mode = mode;
1114 ath5k_hw_reg_write(ah, staid, AR5K_STA_ID1);
1115
1116 return 0;
1117 }
1118
1119 /***********************\
1120 DMA Related Functions
1121 \***********************/
1122
1123 /*
1124 * Receive functions
1125 */
1126
1127 /*
1128 * Start DMA receive
1129 */
1130 void ath5k_hw_start_rx(struct ath5k_hw *ah)
1131 {
1132 ATH5K_TRACE(ah->ah_sc);
1133 ath5k_hw_reg_write(ah, AR5K_CR_RXE, AR5K_CR);
1134 }
1135
1136 /*
1137 * Stop DMA receive
1138 */
1139 int ath5k_hw_stop_rx_dma(struct ath5k_hw *ah)
1140 {
1141 unsigned int i;
1142
1143 ATH5K_TRACE(ah->ah_sc);
1144 ath5k_hw_reg_write(ah, AR5K_CR_RXD, AR5K_CR);
1145
1146 /*
1147 * It may take some time to disable the DMA receive unit
1148 */
1149 for (i = 2000; i > 0 &&
1150 (ath5k_hw_reg_read(ah, AR5K_CR) & AR5K_CR_RXE) != 0;
1151 i--)
1152 udelay(10);
1153
1154 return i ? 0 : -EBUSY;
1155 }
1156
1157 /*
1158 * Get the address of the RX Descriptor
1159 */
1160 u32 ath5k_hw_get_rx_buf(struct ath5k_hw *ah)
1161 {
1162 return ath5k_hw_reg_read(ah, AR5K_RXDP);
1163 }
1164
1165 /*
1166 * Set the address of the RX Descriptor
1167 */
1168 void ath5k_hw_put_rx_buf(struct ath5k_hw *ah, u32 phys_addr)
1169 {
1170 ATH5K_TRACE(ah->ah_sc);
1171
1172 /*TODO:Shouldn't we check if RX is enabled first ?*/
1173 ath5k_hw_reg_write(ah, phys_addr, AR5K_RXDP);
1174 }
1175
1176 /*
1177 * Transmit functions
1178 */
1179
1180 /*
1181 * Start DMA transmit for a specific queue
1182 * (see also QCU/DCU functions)
1183 */
1184 int ath5k_hw_tx_start(struct ath5k_hw *ah, unsigned int queue)
1185 {
1186 u32 tx_queue;
1187
1188 ATH5K_TRACE(ah->ah_sc);
1189 AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
1190
1191 /* Return if queue is declared inactive */
1192 if (ah->ah_txq[queue].tqi_type == AR5K_TX_QUEUE_INACTIVE)
1193 return -EIO;
1194
1195 if (ah->ah_version == AR5K_AR5210) {
1196 tx_queue = ath5k_hw_reg_read(ah, AR5K_CR);
1197
1198 /*
1199 * Set the queue by type on 5210
1200 */
1201 switch (ah->ah_txq[queue].tqi_type) {
1202 case AR5K_TX_QUEUE_DATA:
1203 tx_queue |= AR5K_CR_TXE0 & ~AR5K_CR_TXD0;
1204 break;
1205 case AR5K_TX_QUEUE_BEACON:
1206 tx_queue |= AR5K_CR_TXE1 & ~AR5K_CR_TXD1;
1207 ath5k_hw_reg_write(ah, AR5K_BCR_TQ1V | AR5K_BCR_BDMAE,
1208 AR5K_BSR);
1209 break;
1210 case AR5K_TX_QUEUE_CAB:
1211 tx_queue |= AR5K_CR_TXE1 & ~AR5K_CR_TXD1;
1212 ath5k_hw_reg_write(ah, AR5K_BCR_TQ1FV | AR5K_BCR_TQ1V |
1213 AR5K_BCR_BDMAE, AR5K_BSR);
1214 break;
1215 default:
1216 return -EINVAL;
1217 }
1218 /* Start queue */
1219 ath5k_hw_reg_write(ah, tx_queue, AR5K_CR);
1220 } else {
1221 /* Return if queue is disabled */
1222 if (AR5K_REG_READ_Q(ah, AR5K_QCU_TXD, queue))
1223 return -EIO;
1224
1225 /* Start queue */
1226 AR5K_REG_WRITE_Q(ah, AR5K_QCU_TXE, queue);
1227 }
1228
1229 return 0;
1230 }
1231
1232 /*
1233 * Stop DMA transmit for a specific queue
1234 * (see also QCU/DCU functions)
1235 */
1236 int ath5k_hw_stop_tx_dma(struct ath5k_hw *ah, unsigned int queue)
1237 {
1238 unsigned int i = 100;
1239 u32 tx_queue, pending;
1240
1241 ATH5K_TRACE(ah->ah_sc);
1242 AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
1243
1244 /* Return if queue is declared inactive */
1245 if (ah->ah_txq[queue].tqi_type == AR5K_TX_QUEUE_INACTIVE)
1246 return -EIO;
1247
1248 if (ah->ah_version == AR5K_AR5210) {
1249 tx_queue = ath5k_hw_reg_read(ah, AR5K_CR);
1250
1251 /*
1252 * Set by queue type
1253 */
1254 switch (ah->ah_txq[queue].tqi_type) {
1255 case AR5K_TX_QUEUE_DATA:
1256 tx_queue |= AR5K_CR_TXD0 & ~AR5K_CR_TXE0;
1257 break;
1258 case AR5K_TX_QUEUE_BEACON:
1259 case AR5K_TX_QUEUE_CAB:
1260 /* XXX Fix me... */
1261 tx_queue |= AR5K_CR_TXD1 & ~AR5K_CR_TXD1;
1262 ath5k_hw_reg_write(ah, 0, AR5K_BSR);
1263 break;
1264 default:
1265 return -EINVAL;
1266 }
1267
1268 /* Stop queue */
1269 ath5k_hw_reg_write(ah, tx_queue, AR5K_CR);
1270 } else {
1271 /*
1272 * Schedule TX disable and wait until queue is empty
1273 */
1274 AR5K_REG_WRITE_Q(ah, AR5K_QCU_TXD, queue);
1275
1276 /*Check for pending frames*/
1277 do {
1278 pending = ath5k_hw_reg_read(ah,
1279 AR5K_QUEUE_STATUS(queue)) &
1280 AR5K_QCU_STS_FRMPENDCNT;
1281 udelay(100);
1282 } while (--i && pending);
1283
1284 /* Clear register */
1285 ath5k_hw_reg_write(ah, 0, AR5K_QCU_TXD);
1286 }
1287
1288 /* TODO: Check for success else return error */
1289 return 0;
1290 }
1291
1292 /*
1293 * Get the address of the TX Descriptor for a specific queue
1294 * (see also QCU/DCU functions)
1295 */
1296 u32 ath5k_hw_get_tx_buf(struct ath5k_hw *ah, unsigned int queue)
1297 {
1298 u16 tx_reg;
1299
1300 ATH5K_TRACE(ah->ah_sc);
1301 AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
1302
1303 /*
1304 * Get the transmit queue descriptor pointer from the selected queue
1305 */
1306 /*5210 doesn't have QCU*/
1307 if (ah->ah_version == AR5K_AR5210) {
1308 switch (ah->ah_txq[queue].tqi_type) {
1309 case AR5K_TX_QUEUE_DATA:
1310 tx_reg = AR5K_NOQCU_TXDP0;
1311 break;
1312 case AR5K_TX_QUEUE_BEACON:
1313 case AR5K_TX_QUEUE_CAB:
1314 tx_reg = AR5K_NOQCU_TXDP1;
1315 break;
1316 default:
1317 return 0xffffffff;
1318 }
1319 } else {
1320 tx_reg = AR5K_QUEUE_TXDP(queue);
1321 }
1322
1323 return ath5k_hw_reg_read(ah, tx_reg);
1324 }
1325
1326 /*
1327 * Set the address of the TX Descriptor for a specific queue
1328 * (see also QCU/DCU functions)
1329 */
1330 int ath5k_hw_put_tx_buf(struct ath5k_hw *ah, unsigned int queue, u32 phys_addr)
1331 {
1332 u16 tx_reg;
1333
1334 ATH5K_TRACE(ah->ah_sc);
1335 AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
1336
1337 /*
1338 * Set the transmit queue descriptor pointer register by type
1339 * on 5210
1340 */
1341 if (ah->ah_version == AR5K_AR5210) {
1342 switch (ah->ah_txq[queue].tqi_type) {
1343 case AR5K_TX_QUEUE_DATA:
1344 tx_reg = AR5K_NOQCU_TXDP0;
1345 break;
1346 case AR5K_TX_QUEUE_BEACON:
1347 case AR5K_TX_QUEUE_CAB:
1348 tx_reg = AR5K_NOQCU_TXDP1;
1349 break;
1350 default:
1351 return -EINVAL;
1352 }
1353 } else {
1354 /*
1355 * Set the transmit queue descriptor pointer for
1356 * the selected queue on QCU for 5211+
1357 * (this won't work if the queue is still active)
1358 */
1359 if (AR5K_REG_READ_Q(ah, AR5K_QCU_TXE, queue))
1360 return -EIO;
1361
1362 tx_reg = AR5K_QUEUE_TXDP(queue);
1363 }
1364
1365 /* Set descriptor pointer */
1366 ath5k_hw_reg_write(ah, phys_addr, tx_reg);
1367
1368 return 0;
1369 }
1370
1371 /*
1372 * Update tx trigger level
1373 */
1374 int ath5k_hw_update_tx_triglevel(struct ath5k_hw *ah, bool increase)
1375 {
1376 u32 trigger_level, imr;
1377 int ret = -EIO;
1378
1379 ATH5K_TRACE(ah->ah_sc);
1380
1381 /*
1382 * Disable interrupts by setting the mask
1383 */
1384 imr = ath5k_hw_set_intr(ah, ah->ah_imr & ~AR5K_INT_GLOBAL);
1385
1386 /*TODO: Boundary check on trigger_level*/
1387 trigger_level = AR5K_REG_MS(ath5k_hw_reg_read(ah, AR5K_TXCFG),
1388 AR5K_TXCFG_TXFULL);
1389
1390 if (increase == false) {
1391 if (--trigger_level < AR5K_TUNE_MIN_TX_FIFO_THRES)
1392 goto done;
1393 } else
1394 trigger_level +=
1395 ((AR5K_TUNE_MAX_TX_FIFO_THRES - trigger_level) / 2);
1396
1397 /*
1398 * Update trigger level on success
1399 */
1400 if (ah->ah_version == AR5K_AR5210)
1401 ath5k_hw_reg_write(ah, trigger_level, AR5K_TRIG_LVL);
1402 else
1403 AR5K_REG_WRITE_BITS(ah, AR5K_TXCFG,
1404 AR5K_TXCFG_TXFULL, trigger_level);
1405
1406 ret = 0;
1407
1408 done:
1409 /*
1410 * Restore interrupt mask
1411 */
1412 ath5k_hw_set_intr(ah, imr);
1413
1414 return ret;
1415 }
1416
1417 /*
1418 * Interrupt handling
1419 */
1420
1421 /*
1422 * Check if we have pending interrupts
1423 */
1424 bool ath5k_hw_is_intr_pending(struct ath5k_hw *ah)
1425 {
1426 ATH5K_TRACE(ah->ah_sc);
1427 return ath5k_hw_reg_read(ah, AR5K_INTPEND);
1428 }
1429
1430 /*
1431 * Get interrupt mask (ISR)
1432 */
1433 int ath5k_hw_get_isr(struct ath5k_hw *ah, enum ath5k_int *interrupt_mask)
1434 {
1435 u32 data;
1436
1437 ATH5K_TRACE(ah->ah_sc);
1438
1439 /*
1440 * Read interrupt status from the Interrupt Status register
1441 * on 5210
1442 */
1443 if (ah->ah_version == AR5K_AR5210) {
1444 data = ath5k_hw_reg_read(ah, AR5K_ISR);
1445 if (unlikely(data == AR5K_INT_NOCARD)) {
1446 *interrupt_mask = data;
1447 return -ENODEV;
1448 }
1449 } else {
1450 /*
1451 * Read interrupt status from the Read-And-Clear shadow register
1452 * Note: PISR/SISR Not available on 5210
1453 */
1454 data = ath5k_hw_reg_read(ah, AR5K_RAC_PISR);
1455 }
1456
1457 /*
1458 * Get abstract interrupt mask (driver-compatible)
1459 */
1460 *interrupt_mask = (data & AR5K_INT_COMMON) & ah->ah_imr;
1461
1462 if (unlikely(data == AR5K_INT_NOCARD))
1463 return -ENODEV;
1464
1465 if (data & (AR5K_ISR_RXOK | AR5K_ISR_RXERR))
1466 *interrupt_mask |= AR5K_INT_RX;
1467
1468 if (data & (AR5K_ISR_TXOK | AR5K_ISR_TXERR
1469 | AR5K_ISR_TXDESC | AR5K_ISR_TXEOL))
1470 *interrupt_mask |= AR5K_INT_TX;
1471
1472 if (ah->ah_version != AR5K_AR5210) {
1473 /*HIU = Host Interface Unit (PCI etc)*/
1474 if (unlikely(data & (AR5K_ISR_HIUERR)))
1475 *interrupt_mask |= AR5K_INT_FATAL;
1476
1477 /*Beacon Not Ready*/
1478 if (unlikely(data & (AR5K_ISR_BNR)))
1479 *interrupt_mask |= AR5K_INT_BNR;
1480 }
1481
1482 /*
1483 * XXX: BMISS interrupts may occur after association.
1484 * I found this on 5210 code but it needs testing. If this is
1485 * true we should disable them before assoc and re-enable them
1486 * after a successfull assoc + some jiffies.
1487 */
1488 #if 0
1489 interrupt_mask &= ~AR5K_INT_BMISS;
1490 #endif
1491
1492 /*
1493 * In case we didn't handle anything,
1494 * print the register value.
1495 */
1496 if (unlikely(*interrupt_mask == 0 && net_ratelimit()))
1497 ATH5K_PRINTF("0x%08x\n", data);
1498
1499 return 0;
1500 }
1501
1502 /*
1503 * Set interrupt mask
1504 */
1505 enum ath5k_int ath5k_hw_set_intr(struct ath5k_hw *ah, enum ath5k_int new_mask)
1506 {
1507 enum ath5k_int old_mask, int_mask;
1508
1509 /*
1510 * Disable card interrupts to prevent any race conditions
1511 * (they will be re-enabled afterwards).
1512 */
1513 ath5k_hw_reg_write(ah, AR5K_IER_DISABLE, AR5K_IER);
1514
1515 old_mask = ah->ah_imr;
1516
1517 /*
1518 * Add additional, chipset-dependent interrupt mask flags
1519 * and write them to the IMR (interrupt mask register).
1520 */
1521 int_mask = new_mask & AR5K_INT_COMMON;
1522
1523 if (new_mask & AR5K_INT_RX)
1524 int_mask |= AR5K_IMR_RXOK | AR5K_IMR_RXERR | AR5K_IMR_RXORN |
1525 AR5K_IMR_RXDESC;
1526
1527 if (new_mask & AR5K_INT_TX)
1528 int_mask |= AR5K_IMR_TXOK | AR5K_IMR_TXERR | AR5K_IMR_TXDESC |
1529 AR5K_IMR_TXURN;
1530
1531 if (ah->ah_version != AR5K_AR5210) {
1532 if (new_mask & AR5K_INT_FATAL) {
1533 int_mask |= AR5K_IMR_HIUERR;
1534 AR5K_REG_ENABLE_BITS(ah, AR5K_SIMR2, AR5K_SIMR2_MCABT |
1535 AR5K_SIMR2_SSERR | AR5K_SIMR2_DPERR);
1536 }
1537 }
1538
1539 ath5k_hw_reg_write(ah, int_mask, AR5K_PIMR);
1540
1541 /* Store new interrupt mask */
1542 ah->ah_imr = new_mask;
1543
1544 /* ..re-enable interrupts */
1545 ath5k_hw_reg_write(ah, AR5K_IER_ENABLE, AR5K_IER);
1546
1547 return old_mask;
1548 }
1549
1550
1551 /*************************\
1552 EEPROM access functions
1553 \*************************/
1554
1555 /*
1556 * Read from eeprom
1557 */
1558 static int ath5k_hw_eeprom_read(struct ath5k_hw *ah, u32 offset, u16 *data)
1559 {
1560 u32 status, timeout;
1561
1562 ATH5K_TRACE(ah->ah_sc);
1563 /*
1564 * Initialize EEPROM access
1565 */
1566 if (ah->ah_version == AR5K_AR5210) {
1567 AR5K_REG_ENABLE_BITS(ah, AR5K_PCICFG, AR5K_PCICFG_EEAE);
1568 (void)ath5k_hw_reg_read(ah, AR5K_EEPROM_BASE + (4 * offset));
1569 } else {
1570 ath5k_hw_reg_write(ah, offset, AR5K_EEPROM_BASE);
1571 AR5K_REG_ENABLE_BITS(ah, AR5K_EEPROM_CMD,
1572 AR5K_EEPROM_CMD_READ);
1573 }
1574
1575 for (timeout = AR5K_TUNE_REGISTER_TIMEOUT; timeout > 0; timeout--) {
1576 status = ath5k_hw_reg_read(ah, AR5K_EEPROM_STATUS);
1577 if (status & AR5K_EEPROM_STAT_RDDONE) {
1578 if (status & AR5K_EEPROM_STAT_RDERR)
1579 return -EIO;
1580 *data = (u16)(ath5k_hw_reg_read(ah, AR5K_EEPROM_DATA) &
1581 0xffff);
1582 return 0;
1583 }
1584 udelay(15);
1585 }
1586
1587 return -ETIMEDOUT;
1588 }
1589
1590 /*
1591 * Write to eeprom - currently disabled, use at your own risk
1592 */
1593 static int ath5k_hw_eeprom_write(struct ath5k_hw *ah, u32 offset, u16 data)
1594 {
1595 #if 0
1596 u32 status, timeout;
1597
1598 ATH5K_TRACE(ah->ah_sc);
1599
1600 /*
1601 * Initialize eeprom access
1602 */
1603
1604 if (ah->ah_version == AR5K_AR5210) {
1605 AR5K_REG_ENABLE_BITS(ah, AR5K_PCICFG, AR5K_PCICFG_EEAE);
1606 } else {
1607 AR5K_REG_ENABLE_BITS(ah, AR5K_EEPROM_CMD,
1608 AR5K_EEPROM_CMD_RESET);
1609 }
1610
1611 /*
1612 * Write data to data register
1613 */
1614
1615 if (ah->ah_version == AR5K_AR5210) {
1616 ath5k_hw_reg_write(ah, data, AR5K_EEPROM_BASE + (4 * offset));
1617 } else {
1618 ath5k_hw_reg_write(ah, offset, AR5K_EEPROM_BASE);
1619 ath5k_hw_reg_write(ah, data, AR5K_EEPROM_DATA);
1620 AR5K_REG_ENABLE_BITS(ah, AR5K_EEPROM_CMD,
1621 AR5K_EEPROM_CMD_WRITE);
1622 }
1623
1624 /*
1625 * Check status
1626 */
1627
1628 for (timeout = AR5K_TUNE_REGISTER_TIMEOUT; timeout > 0; timeout--) {
1629 status = ath5k_hw_reg_read(ah, AR5K_EEPROM_STATUS);
1630 if (status & AR5K_EEPROM_STAT_WRDONE) {
1631 if (status & AR5K_EEPROM_STAT_WRERR)
1632 return EIO;
1633 return 0;
1634 }
1635 udelay(15);
1636 }
1637 #endif
1638 ATH5K_ERR(ah->ah_sc, "EEPROM Write is disabled!");
1639 return -EIO;
1640 }
1641
1642 /*
1643 * Translate binary channel representation in EEPROM to frequency
1644 */
1645 static u16 ath5k_eeprom_bin2freq(struct ath5k_hw *ah, u16 bin, unsigned int mode)
1646 {
1647 u16 val;
1648
1649 if (bin == AR5K_EEPROM_CHANNEL_DIS)
1650 return bin;
1651
1652 if (mode == AR5K_EEPROM_MODE_11A) {
1653 if (ah->ah_ee_version > AR5K_EEPROM_VERSION_3_2)
1654 val = (5 * bin) + 4800;
1655 else
1656 val = bin > 62 ? (10 * 62) + (5 * (bin - 62)) + 5100 :
1657 (bin * 10) + 5100;
1658 } else {
1659 if (ah->ah_ee_version > AR5K_EEPROM_VERSION_3_2)
1660 val = bin + 2300;
1661 else
1662 val = bin + 2400;
1663 }
1664
1665 return val;
1666 }
1667
1668 /*
1669 * Read antenna infos from eeprom
1670 */
1671 static int ath5k_eeprom_read_ants(struct ath5k_hw *ah, u32 *offset,
1672 unsigned int mode)
1673 {
1674 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
1675 u32 o = *offset;
1676 u16 val;
1677 int ret, i = 0;
1678
1679 AR5K_EEPROM_READ(o++, val);
1680 ee->ee_switch_settling[mode] = (val >> 8) & 0x7f;
1681 ee->ee_ant_tx_rx[mode] = (val >> 2) & 0x3f;
1682 ee->ee_ant_control[mode][i] = (val << 4) & 0x3f;
1683
1684 AR5K_EEPROM_READ(o++, val);
1685 ee->ee_ant_control[mode][i++] |= (val >> 12) & 0xf;
1686 ee->ee_ant_control[mode][i++] = (val >> 6) & 0x3f;
1687 ee->ee_ant_control[mode][i++] = val & 0x3f;
1688
1689 AR5K_EEPROM_READ(o++, val);
1690 ee->ee_ant_control[mode][i++] = (val >> 10) & 0x3f;
1691 ee->ee_ant_control[mode][i++] = (val >> 4) & 0x3f;
1692 ee->ee_ant_control[mode][i] = (val << 2) & 0x3f;
1693
1694 AR5K_EEPROM_READ(o++, val);
1695 ee->ee_ant_control[mode][i++] |= (val >> 14) & 0x3;
1696 ee->ee_ant_control[mode][i++] = (val >> 8) & 0x3f;
1697 ee->ee_ant_control[mode][i++] = (val >> 2) & 0x3f;
1698 ee->ee_ant_control[mode][i] = (val << 4) & 0x3f;
1699
1700 AR5K_EEPROM_READ(o++, val);
1701 ee->ee_ant_control[mode][i++] |= (val >> 12) & 0xf;
1702 ee->ee_ant_control[mode][i++] = (val >> 6) & 0x3f;
1703 ee->ee_ant_control[mode][i++] = val & 0x3f;
1704
1705 /* Get antenna modes */
1706 ah->ah_antenna[mode][0] =
1707 (ee->ee_ant_control[mode][0] << 4) | 0x1;
1708 ah->ah_antenna[mode][AR5K_ANT_FIXED_A] =
1709 ee->ee_ant_control[mode][1] |
1710 (ee->ee_ant_control[mode][2] << 6) |
1711 (ee->ee_ant_control[mode][3] << 12) |
1712 (ee->ee_ant_control[mode][4] << 18) |
1713 (ee->ee_ant_control[mode][5] << 24);
1714 ah->ah_antenna[mode][AR5K_ANT_FIXED_B] =
1715 ee->ee_ant_control[mode][6] |
1716 (ee->ee_ant_control[mode][7] << 6) |
1717 (ee->ee_ant_control[mode][8] << 12) |
1718 (ee->ee_ant_control[mode][9] << 18) |
1719 (ee->ee_ant_control[mode][10] << 24);
1720
1721 /* return new offset */
1722 *offset = o;
1723
1724 return 0;
1725 }
1726
1727 /*
1728 * Read supported modes from eeprom
1729 */
1730 static int ath5k_eeprom_read_modes(struct ath5k_hw *ah, u32 *offset,
1731 unsigned int mode)
1732 {
1733 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
1734 u32 o = *offset;
1735 u16 val;
1736 int ret;
1737
1738 AR5K_EEPROM_READ(o++, val);
1739 ee->ee_tx_end2xlna_enable[mode] = (val >> 8) & 0xff;
1740 ee->ee_thr_62[mode] = val & 0xff;
1741
1742 if (ah->ah_ee_version <= AR5K_EEPROM_VERSION_3_2)
1743 ee->ee_thr_62[mode] = mode == AR5K_EEPROM_MODE_11A ? 15 : 28;
1744
1745 AR5K_EEPROM_READ(o++, val);
1746 ee->ee_tx_end2xpa_disable[mode] = (val >> 8) & 0xff;
1747 ee->ee_tx_frm2xpa_enable[mode] = val & 0xff;
1748
1749 AR5K_EEPROM_READ(o++, val);
1750 ee->ee_pga_desired_size[mode] = (val >> 8) & 0xff;
1751
1752 if ((val & 0xff) & 0x80)
1753 ee->ee_noise_floor_thr[mode] = -((((val & 0xff) ^ 0xff)) + 1);
1754 else
1755 ee->ee_noise_floor_thr[mode] = val & 0xff;
1756
1757 if (ah->ah_ee_version <= AR5K_EEPROM_VERSION_3_2)
1758 ee->ee_noise_floor_thr[mode] =
1759 mode == AR5K_EEPROM_MODE_11A ? -54 : -1;
1760
1761 AR5K_EEPROM_READ(o++, val);
1762 ee->ee_xlna_gain[mode] = (val >> 5) & 0xff;
1763 ee->ee_x_gain[mode] = (val >> 1) & 0xf;
1764 ee->ee_xpd[mode] = val & 0x1;
1765
1766 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_0)
1767 ee->ee_fixed_bias[mode] = (val >> 13) & 0x1;
1768
1769 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_3_3) {
1770 AR5K_EEPROM_READ(o++, val);
1771 ee->ee_false_detect[mode] = (val >> 6) & 0x7f;
1772
1773 if (mode == AR5K_EEPROM_MODE_11A)
1774 ee->ee_xr_power[mode] = val & 0x3f;
1775 else {
1776 ee->ee_ob[mode][0] = val & 0x7;
1777 ee->ee_db[mode][0] = (val >> 3) & 0x7;
1778 }
1779 }
1780
1781 if (ah->ah_ee_version < AR5K_EEPROM_VERSION_3_4) {
1782 ee->ee_i_gain[mode] = AR5K_EEPROM_I_GAIN;
1783 ee->ee_cck_ofdm_power_delta = AR5K_EEPROM_CCK_OFDM_DELTA;
1784 } else {
1785 ee->ee_i_gain[mode] = (val >> 13) & 0x7;
1786
1787 AR5K_EEPROM_READ(o++, val);
1788 ee->ee_i_gain[mode] |= (val << 3) & 0x38;
1789
1790 if (mode == AR5K_EEPROM_MODE_11G)
1791 ee->ee_cck_ofdm_power_delta = (val >> 3) & 0xff;
1792 }
1793
1794 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_0 &&
1795 mode == AR5K_EEPROM_MODE_11A) {
1796 ee->ee_i_cal[mode] = (val >> 8) & 0x3f;
1797 ee->ee_q_cal[mode] = (val >> 3) & 0x1f;
1798 }
1799
1800 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_6 &&
1801 mode == AR5K_EEPROM_MODE_11G)
1802 ee->ee_scaled_cck_delta = (val >> 11) & 0x1f;
1803
1804 /* return new offset */
1805 *offset = o;
1806
1807 return 0;
1808 }
1809
1810 /*
1811 * Initialize eeprom & capabilities structs
1812 */
1813 static int ath5k_eeprom_init(struct ath5k_hw *ah)
1814 {
1815 struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
1816 unsigned int mode, i;
1817 int ret;
1818 u32 offset;
1819 u16 val;
1820
1821 /* Initial TX thermal adjustment values */
1822 ee->ee_tx_clip = 4;
1823 ee->ee_pwd_84 = ee->ee_pwd_90 = 1;
1824 ee->ee_gain_select = 1;
1825
1826 /*
1827 * Read values from EEPROM and store them in the capability structure
1828 */
1829 AR5K_EEPROM_READ_HDR(AR5K_EEPROM_MAGIC, ee_magic);
1830 AR5K_EEPROM_READ_HDR(AR5K_EEPROM_PROTECT, ee_protect);
1831 AR5K_EEPROM_READ_HDR(AR5K_EEPROM_REG_DOMAIN, ee_regdomain);
1832 AR5K_EEPROM_READ_HDR(AR5K_EEPROM_VERSION, ee_version);
1833 AR5K_EEPROM_READ_HDR(AR5K_EEPROM_HDR, ee_header);
1834
1835 /* Return if we have an old EEPROM */
1836 if (ah->ah_ee_version < AR5K_EEPROM_VERSION_3_0)
1837 return 0;
1838
1839 #ifdef notyet
1840 /*
1841 * Validate the checksum of the EEPROM date. There are some
1842 * devices with invalid EEPROMs.
1843 */
1844 for (cksum = 0, offset = 0; offset < AR5K_EEPROM_INFO_MAX; offset++) {
1845 AR5K_EEPROM_READ(AR5K_EEPROM_INFO(offset), val);
1846 cksum ^= val;
1847 }
1848 if (cksum != AR5K_EEPROM_INFO_CKSUM) {
1849 ATH5K_ERR(ah->ah_sc, "Invalid EEPROM checksum 0x%04x\n", cksum);
1850 return -EIO;
1851 }
1852 #endif
1853
1854 AR5K_EEPROM_READ_HDR(AR5K_EEPROM_ANT_GAIN(ah->ah_ee_version),
1855 ee_ant_gain);
1856
1857 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_0) {
1858 AR5K_EEPROM_READ_HDR(AR5K_EEPROM_MISC0, ee_misc0);
1859 AR5K_EEPROM_READ_HDR(AR5K_EEPROM_MISC1, ee_misc1);
1860 }
1861
1862 if (ah->ah_ee_version < AR5K_EEPROM_VERSION_3_3) {
1863 AR5K_EEPROM_READ(AR5K_EEPROM_OBDB0_2GHZ, val);
1864 ee->ee_ob[AR5K_EEPROM_MODE_11B][0] = val & 0x7;
1865 ee->ee_db[AR5K_EEPROM_MODE_11B][0] = (val >> 3) & 0x7;
1866
1867 AR5K_EEPROM_READ(AR5K_EEPROM_OBDB1_2GHZ, val);
1868 ee->ee_ob[AR5K_EEPROM_MODE_11G][0] = val & 0x7;
1869 ee->ee_db[AR5K_EEPROM_MODE_11G][0] = (val >> 3) & 0x7;
1870 }
1871
1872 /*
1873 * Get conformance test limit values
1874 */
1875 offset = AR5K_EEPROM_CTL(ah->ah_ee_version);
1876 ee->ee_ctls = AR5K_EEPROM_N_CTLS(ah->ah_ee_version);
1877
1878 for (i = 0; i < ee->ee_ctls; i++) {
1879 AR5K_EEPROM_READ(offset++, val);
1880 ee->ee_ctl[i] = (val >> 8) & 0xff;
1881 ee->ee_ctl[i + 1] = val & 0xff;
1882 }
1883
1884 /*
1885 * Get values for 802.11a (5GHz)
1886 */
1887 mode = AR5K_EEPROM_MODE_11A;
1888
1889 ee->ee_turbo_max_power[mode] =
1890 AR5K_EEPROM_HDR_T_5GHZ_DBM(ee->ee_header);
1891
1892 offset = AR5K_EEPROM_MODES_11A(ah->ah_ee_version);
1893
1894 ret = ath5k_eeprom_read_ants(ah, &offset, mode);
1895 if (ret)
1896 return ret;
1897
1898 AR5K_EEPROM_READ(offset++, val);
1899 ee->ee_adc_desired_size[mode] = (s8)((val >> 8) & 0xff);
1900 ee->ee_ob[mode][3] = (val >> 5) & 0x7;
1901 ee->ee_db[mode][3] = (val >> 2) & 0x7;
1902 ee->ee_ob[mode][2] = (val << 1) & 0x7;
1903
1904 AR5K_EEPROM_READ(offset++, val);
1905 ee->ee_ob[mode][2] |= (val >> 15) & 0x1;
1906 ee->ee_db[mode][2] = (val >> 12) & 0x7;
1907 ee->ee_ob[mode][1] = (val >> 9) & 0x7;
1908 ee->ee_db[mode][1] = (val >> 6) & 0x7;
1909 ee->ee_ob[mode][0] = (val >> 3) & 0x7;
1910 ee->ee_db[mode][0] = val & 0x7;
1911
1912 ret = ath5k_eeprom_read_modes(ah, &offset, mode);
1913 if (ret)
1914 return ret;
1915
1916 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_1) {
1917 AR5K_EEPROM_READ(offset++, val);
1918 ee->ee_margin_tx_rx[mode] = val & 0x3f;
1919 }
1920
1921 /*
1922 * Get values for 802.11b (2.4GHz)
1923 */
1924 mode = AR5K_EEPROM_MODE_11B;
1925 offset = AR5K_EEPROM_MODES_11B(ah->ah_ee_version);
1926
1927 ret = ath5k_eeprom_read_ants(ah, &offset, mode);
1928 if (ret)
1929 return ret;
1930
1931 AR5K_EEPROM_READ(offset++, val);
1932 ee->ee_adc_desired_size[mode] = (s8)((val >> 8) & 0xff);
1933 ee->ee_ob[mode][1] = (val >> 4) & 0x7;
1934 ee->ee_db[mode][1] = val & 0x7;
1935
1936 ret = ath5k_eeprom_read_modes(ah, &offset, mode);
1937 if (ret)
1938 return ret;
1939
1940 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_0) {
1941 AR5K_EEPROM_READ(offset++, val);
1942 ee->ee_cal_pier[mode][0] =
1943 ath5k_eeprom_bin2freq(ah, val & 0xff, mode);
1944 ee->ee_cal_pier[mode][1] =
1945 ath5k_eeprom_bin2freq(ah, (val >> 8) & 0xff, mode);
1946
1947 AR5K_EEPROM_READ(offset++, val);
1948 ee->ee_cal_pier[mode][2] =
1949 ath5k_eeprom_bin2freq(ah, val & 0xff, mode);
1950 }
1951
1952 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_1)
1953 ee->ee_margin_tx_rx[mode] = (val >> 8) & 0x3f;
1954
1955 /*
1956 * Get values for 802.11g (2.4GHz)
1957 */
1958 mode = AR5K_EEPROM_MODE_11G;
1959 offset = AR5K_EEPROM_MODES_11G(ah->ah_ee_version);
1960
1961 ret = ath5k_eeprom_read_ants(ah, &offset, mode);
1962 if (ret)
1963 return ret;
1964
1965 AR5K_EEPROM_READ(offset++, val);
1966 ee->ee_adc_desired_size[mode] = (s8)((val >> 8) & 0xff);
1967 ee->ee_ob[mode][1] = (val >> 4) & 0x7;
1968 ee->ee_db[mode][1] = val & 0x7;
1969
1970 ret = ath5k_eeprom_read_modes(ah, &offset, mode);
1971 if (ret)
1972 return ret;
1973
1974 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_0) {
1975 AR5K_EEPROM_READ(offset++, val);
1976 ee->ee_cal_pier[mode][0] =
1977 ath5k_eeprom_bin2freq(ah, val & 0xff, mode);
1978 ee->ee_cal_pier[mode][1] =
1979 ath5k_eeprom_bin2freq(ah, (val >> 8) & 0xff, mode);
1980
1981 AR5K_EEPROM_READ(offset++, val);
1982 ee->ee_turbo_max_power[mode] = val & 0x7f;
1983 ee->ee_xr_power[mode] = (val >> 7) & 0x3f;
1984
1985 AR5K_EEPROM_READ(offset++, val);
1986 ee->ee_cal_pier[mode][2] =
1987 ath5k_eeprom_bin2freq(ah, val & 0xff, mode);
1988
1989 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_1)
1990 ee->ee_margin_tx_rx[mode] = (val >> 8) & 0x3f;
1991
1992 AR5K_EEPROM_READ(offset++, val);
1993 ee->ee_i_cal[mode] = (val >> 8) & 0x3f;
1994 ee->ee_q_cal[mode] = (val >> 3) & 0x1f;
1995
1996 if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_2) {
1997 AR5K_EEPROM_READ(offset++, val);
1998 ee->ee_cck_ofdm_gain_delta = val & 0xff;
1999 }
2000 }
2001
2002 /*
2003 * Read 5GHz EEPROM channels
2004 */
2005
2006 return 0;
2007 }
2008
2009 /*
2010 * Read the MAC address from eeprom
2011 */
2012 static int ath5k_eeprom_read_mac(struct ath5k_hw *ah, u8 *mac)
2013 {
2014 u8 mac_d[ETH_ALEN];
2015 u32 total, offset;
2016 u16 data;
2017 int octet, ret;
2018
2019 memset(mac, 0, ETH_ALEN);
2020 memset(mac_d, 0, ETH_ALEN);
2021
2022 ret = ath5k_hw_eeprom_read(ah, 0x20, &data);
2023 if (ret)
2024 return ret;
2025
2026 for (offset = 0x1f, octet = 0, total = 0; offset >= 0x1d; offset--) {
2027 ret = ath5k_hw_eeprom_read(ah, offset, &data);
2028 if (ret)
2029 return ret;
2030
2031 total += data;
2032 mac_d[octet + 1] = data & 0xff;
2033 mac_d[octet] = data >> 8;
2034 octet += 2;
2035 }
2036
2037 memcpy(mac, mac_d, ETH_ALEN);
2038
2039 if (!total || total == 3 * 0xffff)
2040 return -EINVAL;
2041
2042 return 0;
2043 }
2044
2045 /*
2046 * Read/Write regulatory domain
2047 */
2048 static bool ath5k_eeprom_regulation_domain(struct ath5k_hw *ah, bool write,
2049 enum ath5k_regdom *regdomain)
2050 {
2051 u16 ee_regdomain;
2052
2053 /* Read current value */
2054 if (write != true) {
2055 ee_regdomain = ah->ah_capabilities.cap_eeprom.ee_regdomain;
2056 *regdomain = ath5k_regdom_to_ieee(ee_regdomain);
2057 return true;
2058 }
2059
2060 ee_regdomain = ath5k_regdom_from_ieee(*regdomain);
2061
2062 /* Try to write a new value */
2063 if (ah->ah_capabilities.cap_eeprom.ee_protect &
2064 AR5K_EEPROM_PROTECT_WR_128_191)
2065 return false;
2066 if (ath5k_hw_eeprom_write(ah, AR5K_EEPROM_REG_DOMAIN, ee_regdomain)!=0)
2067 return false;
2068
2069 ah->ah_capabilities.cap_eeprom.ee_regdomain = ee_regdomain;
2070
2071 return true;
2072 }
2073
2074 /*
2075 * Use the above to write a new regulatory domain
2076 */
2077 int ath5k_hw_set_regdomain(struct ath5k_hw *ah, u16 regdomain)
2078 {
2079 enum ath5k_regdom ieee_regdomain;
2080
2081 ieee_regdomain = ath5k_regdom_to_ieee(regdomain);
2082
2083 if (ath5k_eeprom_regulation_domain(ah, true, &ieee_regdomain) == true)
2084 return 0;
2085
2086 return -EIO;
2087 }
2088
2089 /*
2090 * Fill the capabilities struct
2091 */
2092 static int ath5k_hw_get_capabilities(struct ath5k_hw *ah)
2093 {
2094 u16 ee_header;
2095
2096 ATH5K_TRACE(ah->ah_sc);
2097 /* Capabilities stored in the EEPROM */
2098 ee_header = ah->ah_capabilities.cap_eeprom.ee_header;
2099
2100 if (ah->ah_version == AR5K_AR5210) {
2101 /*
2102 * Set radio capabilities
2103 * (The AR5110 only supports the middle 5GHz band)
2104 */
2105 ah->ah_capabilities.cap_range.range_5ghz_min = 5120;
2106 ah->ah_capabilities.cap_range.range_5ghz_max = 5430;
2107 ah->ah_capabilities.cap_range.range_2ghz_min = 0;
2108 ah->ah_capabilities.cap_range.range_2ghz_max = 0;
2109
2110 /* Set supported modes */
2111 __set_bit(MODE_IEEE80211A, ah->ah_capabilities.cap_mode);
2112 __set_bit(MODE_ATHEROS_TURBO, ah->ah_capabilities.cap_mode);
2113 } else {
2114 /*
2115 * XXX The tranceiver supports frequencies from 4920 to 6100GHz
2116 * XXX and from 2312 to 2732GHz. There are problems with the
2117 * XXX current ieee80211 implementation because the IEEE
2118 * XXX channel mapping does not support negative channel
2119 * XXX numbers (2312MHz is channel -19). Of course, this
2120 * XXX doesn't matter because these channels are out of range
2121 * XXX but some regulation domains like MKK (Japan) will
2122 * XXX support frequencies somewhere around 4.8GHz.
2123 */
2124
2125 /*
2126 * Set radio capabilities
2127 */
2128
2129 if (AR5K_EEPROM_HDR_11A(ee_header)) {
2130 ah->ah_capabilities.cap_range.range_5ghz_min = 5005; /* 4920 */
2131 ah->ah_capabilities.cap_range.range_5ghz_max = 6100;
2132
2133 /* Set supported modes */
2134 __set_bit(MODE_IEEE80211A,
2135 ah->ah_capabilities.cap_mode);
2136 __set_bit(MODE_ATHEROS_TURBO,
2137 ah->ah_capabilities.cap_mode);
2138 if (ah->ah_version == AR5K_AR5212)
2139 __set_bit(MODE_ATHEROS_TURBOG,
2140 ah->ah_capabilities.cap_mode);
2141 }
2142
2143 /* Enable 802.11b if a 2GHz capable radio (2111/5112) is
2144 * connected */
2145 if (AR5K_EEPROM_HDR_11B(ee_header) ||
2146 AR5K_EEPROM_HDR_11G(ee_header)) {
2147 ah->ah_capabilities.cap_range.range_2ghz_min = 2412; /* 2312 */
2148 ah->ah_capabilities.cap_range.range_2ghz_max = 2732;
2149
2150 if (AR5K_EEPROM_HDR_11B(ee_header))
2151 __set_bit(MODE_IEEE80211B,
2152 ah->ah_capabilities.cap_mode);
2153
2154 if (AR5K_EEPROM_HDR_11G(ee_header))
2155 __set_bit(MODE_IEEE80211G,
2156 ah->ah_capabilities.cap_mode);
2157 }
2158 }
2159
2160 /* GPIO */
2161 ah->ah_gpio_npins = AR5K_NUM_GPIO;
2162
2163 /* Set number of supported TX queues */
2164 if (ah->ah_version == AR5K_AR5210)
2165 ah->ah_capabilities.cap_queues.q_tx_num =
2166 AR5K_NUM_TX_QUEUES_NOQCU;
2167 else
2168 ah->ah_capabilities.cap_queues.q_tx_num = AR5K_NUM_TX_QUEUES;
2169
2170 return 0;
2171 }
2172
2173 /*********************************\
2174 Protocol Control Unit Functions
2175 \*********************************/
2176
2177 /*
2178 * Set Operation mode
2179 */
2180 int ath5k_hw_set_opmode(struct ath5k_hw *ah)
2181 {
2182 u32 pcu_reg, beacon_reg, low_id, high_id;
2183
2184 pcu_reg = 0;
2185 beacon_reg = 0;
2186
2187 ATH5K_TRACE(ah->ah_sc);
2188
2189 switch (ah->ah_op_mode) {
2190 case IEEE80211_IF_TYPE_IBSS:
2191 pcu_reg |= AR5K_STA_ID1_ADHOC | AR5K_STA_ID1_DESC_ANTENNA |
2192 (ah->ah_version == AR5K_AR5210 ?
2193 AR5K_STA_ID1_NO_PSPOLL : 0);
2194 beacon_reg |= AR5K_BCR_ADHOC;
2195 break;
2196
2197 case IEEE80211_IF_TYPE_AP:
2198 pcu_reg |= AR5K_STA_ID1_AP | AR5K_STA_ID1_RTS_DEF_ANTENNA |
2199 (ah->ah_version == AR5K_AR5210 ?
2200 AR5K_STA_ID1_NO_PSPOLL : 0);
2201 beacon_reg |= AR5K_BCR_AP;
2202 break;
2203
2204 case IEEE80211_IF_TYPE_STA:
2205 pcu_reg |= AR5K_STA_ID1_DEFAULT_ANTENNA |
2206 (ah->ah_version == AR5K_AR5210 ?
2207 AR5K_STA_ID1_PWR_SV : 0);
2208 case IEEE80211_IF_TYPE_MNTR:
2209 pcu_reg |= AR5K_STA_ID1_DEFAULT_ANTENNA |
2210 (ah->ah_version == AR5K_AR5210 ?
2211 AR5K_STA_ID1_NO_PSPOLL : 0);
2212 break;
2213
2214 default:
2215 return -EINVAL;
2216 }
2217
2218 /*
2219 * Set PCU registers
2220 */
2221 low_id = AR5K_LOW_ID(ah->ah_sta_id);
2222 high_id = AR5K_HIGH_ID(ah->ah_sta_id);
2223 ath5k_hw_reg_write(ah, low_id, AR5K_STA_ID0);
2224 ath5k_hw_reg_write(ah, pcu_reg | high_id, AR5K_STA_ID1);
2225
2226 /*
2227 * Set Beacon Control Register on 5210
2228 */
2229 if (ah->ah_version == AR5K_AR5210)
2230 ath5k_hw_reg_write(ah, beacon_reg, AR5K_BCR);
2231
2232 return 0;
2233 }
2234
2235 /*
2236 * BSSID Functions
2237 */
2238
2239 /*
2240 * Get station id
2241 */
2242 void ath5k_hw_get_lladdr(struct ath5k_hw *ah, u8 *mac)
2243 {
2244 ATH5K_TRACE(ah->ah_sc);
2245 memcpy(mac, ah->ah_sta_id, ETH_ALEN);
2246 }
2247
2248 /*
2249 * Set station id
2250 */
2251 int ath5k_hw_set_lladdr(struct ath5k_hw *ah, const u8 *mac)
2252 {
2253 u32 low_id, high_id;
2254
2255 ATH5K_TRACE(ah->ah_sc);
2256 /* Set new station ID */
2257 memcpy(ah->ah_sta_id, mac, ETH_ALEN);
2258
2259 low_id = AR5K_LOW_ID(mac);
2260 high_id = AR5K_HIGH_ID(mac);
2261
2262 ath5k_hw_reg_write(ah, low_id, AR5K_STA_ID0);
2263 ath5k_hw_reg_write(ah, high_id, AR5K_STA_ID1);
2264
2265 return 0;
2266 }
2267
2268 /*
2269 * Set BSSID
2270 */
2271 void ath5k_hw_set_associd(struct ath5k_hw *ah, const u8 *bssid, u16 assoc_id)
2272 {
2273 u32 low_id, high_id;
2274 u16 tim_offset = 0;
2275
2276 /*
2277 * Set simple BSSID mask on 5212
2278 */
2279 if (ah->ah_version == AR5K_AR5212) {
2280 ath5k_hw_reg_write(ah, 0xfffffff, AR5K_BSS_IDM0);
2281 ath5k_hw_reg_write(ah, 0xfffffff, AR5K_BSS_IDM1);
2282 }
2283
2284 /*
2285 * Set BSSID which triggers the "SME Join" operation
2286 */
2287 low_id = AR5K_LOW_ID(bssid);
2288 high_id = AR5K_HIGH_ID(bssid);
2289 ath5k_hw_reg_write(ah, low_id, AR5K_BSS_ID0);
2290 ath5k_hw_reg_write(ah, high_id | ((assoc_id & 0x3fff) <<
2291 AR5K_BSS_ID1_AID_S), AR5K_BSS_ID1);
2292
2293 if (assoc_id == 0) {
2294 ath5k_hw_disable_pspoll(ah);
2295 return;
2296 }
2297
2298 AR5K_REG_WRITE_BITS(ah, AR5K_BEACON, AR5K_BEACON_TIM,
2299 tim_offset ? tim_offset + 4 : 0);
2300
2301 ath5k_hw_enable_pspoll(ah, NULL, 0);
2302 }
2303 /**
2304 * ath5k_hw_set_bssid_mask - set common bits we should listen to
2305 *
2306 * The bssid_mask is a utility used by AR5212 hardware to inform the hardware
2307 * which bits of the interface's MAC address should be looked at when trying
2308 * to decide which packets to ACK. In station mode every bit matters. In AP
2309 * mode with a single BSS every bit matters as well. In AP mode with
2310 * multiple BSSes not every bit matters.
2311 *
2312 * @ah: the &struct ath5k_hw
2313 * @mask: the bssid_mask, a u8 array of size ETH_ALEN
2314 *
2315 * Note that this is a simple filter and *does* not filter out all
2316 * relevant frames. Some non-relevant frames will get through, probability
2317 * jocks are welcomed to compute.
2318 *
2319 * When handling multiple BSSes (or VAPs) you can get the BSSID mask by
2320 * computing the set of:
2321 *
2322 * ~ ( MAC XOR BSSID )
2323 *
2324 * When you do this you are essentially computing the common bits. Later it
2325 * is assumed the harware will "and" (&) the BSSID mask with the MAC address
2326 * to obtain the relevant bits which should match on the destination frame.
2327 *
2328 * Simple example: on your card you have have two BSSes you have created with
2329 * BSSID-01 and BSSID-02. Lets assume BSSID-01 will not use the MAC address.
2330 * There is another BSSID-03 but you are not part of it. For simplicity's sake,
2331 * assuming only 4 bits for a mac address and for BSSIDs you can then have:
2332 *
2333 * \
2334 * MAC: 0001 |
2335 * BSSID-01: 0100 | --> Belongs to us
2336 * BSSID-02: 1001 |
2337 * /
2338 * -------------------
2339 * BSSID-03: 0110 | --> External
2340 * -------------------
2341 *
2342 * Our bssid_mask would then be:
2343 *
2344 * On loop iteration for BSSID-01:
2345 * ~(0001 ^ 0100) -> ~(0101)
2346 * -> 1010
2347 * bssid_mask = 1010
2348 *
2349 * On loop iteration for BSSID-02:
2350 * bssid_mask &= ~(0001 ^ 1001)
2351 * bssid_mask = (1010) & ~(0001 ^ 1001)
2352 * bssid_mask = (1010) & ~(1001)
2353 * bssid_mask = (1010) & (0110)
2354 * bssid_mask = 0010
2355 *
2356 * A bssid_mask of 0010 means "only pay attention to the second least
2357 * significant bit". This is because its the only bit common
2358 * amongst the MAC and all BSSIDs we support. To findout what the real
2359 * common bit is we can simply "&" the bssid_mask now with any BSSID we have
2360 * or our MAC address (we assume the hardware uses the MAC address).
2361 *
2362 * Now, suppose there's an incoming frame for BSSID-03:
2363 *
2364 * IFRAME-01: 0110
2365 *
2366 * An easy eye-inspeciton of this already should tell you that this frame
2367 * will not pass our check. This is beacuse the bssid_mask tells the
2368 * hardware to only look at the second least significant bit and the
2369 * common bit amongst the MAC and BSSIDs is 0, this frame has the 2nd LSB
2370 * as 1, which does not match 0.
2371 *
2372 * So with IFRAME-01 we *assume* the hardware will do:
2373 *
2374 * allow = (IFRAME-01 & bssid_mask) == (bssid_mask & MAC) ? 1 : 0;
2375 * --> allow = (0110 & 0010) == (0010 & 0001) ? 1 : 0;
2376 * --> allow = (0010) == 0000 ? 1 : 0;
2377 * --> allow = 0
2378 *
2379 * Lets now test a frame that should work:
2380 *
2381 * IFRAME-02: 0001 (we should allow)
2382 *
2383 * allow = (0001 & 1010) == 1010
2384 *
2385 * allow = (IFRAME-02 & bssid_mask) == (bssid_mask & MAC) ? 1 : 0;
2386 * --> allow = (0001 & 0010) == (0010 & 0001) ? 1 :0;
2387 * --> allow = (0010) == (0010)
2388 * --> allow = 1
2389 *
2390 * Other examples:
2391 *
2392 * IFRAME-03: 0100 --> allowed
2393 * IFRAME-04: 1001 --> allowed
2394 * IFRAME-05: 1101 --> allowed but its not for us!!!
2395 *
2396 */
2397 int ath5k_hw_set_bssid_mask(struct ath5k_hw *ah, const u8 *mask)
2398 {
2399 u32 low_id, high_id;
2400 ATH5K_TRACE(ah->ah_sc);
2401
2402 if (ah->ah_version == AR5K_AR5212) {
2403 low_id = AR5K_LOW_ID(mask);
2404 high_id = AR5K_HIGH_ID(mask);
2405
2406 ath5k_hw_reg_write(ah, low_id, AR5K_BSS_IDM0);
2407 ath5k_hw_reg_write(ah, high_id, AR5K_BSS_IDM1);
2408
2409 return 0;
2410 }
2411
2412 return -EIO;
2413 }
2414
2415 /*
2416 * Receive start/stop functions
2417 */
2418
2419 /*
2420 * Start receive on PCU
2421 */
2422 void ath5k_hw_start_rx_pcu(struct ath5k_hw *ah)
2423 {
2424 ATH5K_TRACE(ah->ah_sc);
2425 AR5K_REG_DISABLE_BITS(ah, AR5K_DIAG_SW, AR5K_DIAG_SW_DIS_RX);
2426 }
2427
2428 /*
2429 * Stop receive on PCU
2430 */
2431 void ath5k_hw_stop_pcu_recv(struct ath5k_hw *ah)
2432 {
2433 ATH5K_TRACE(ah->ah_sc);
2434 AR5K_REG_ENABLE_BITS(ah, AR5K_DIAG_SW, AR5K_DIAG_SW_DIS_RX);
2435 }
2436
2437 /*
2438 * RX Filter functions
2439 */
2440
2441 /*
2442 * Set multicast filter
2443 */
2444 void ath5k_hw_set_mcast_filter(struct ath5k_hw *ah, u32 filter0, u32 filter1)
2445 {
2446 ATH5K_TRACE(ah->ah_sc);
2447 /* Set the multicat filter */
2448 ath5k_hw_reg_write(ah, filter0, AR5K_MCAST_FILTER0);
2449 ath5k_hw_reg_write(ah, filter1, AR5K_MCAST_FILTER1);
2450 }
2451
2452 /*
2453 * Set multicast filter by index
2454 */
2455 int ath5k_hw_set_mcast_filterindex(struct ath5k_hw *ah, u32 index)
2456 {
2457
2458 ATH5K_TRACE(ah->ah_sc);
2459 if (index >= 64)
2460 return -EINVAL;
2461 else if (index >= 32)
2462 AR5K_REG_ENABLE_BITS(ah, AR5K_MCAST_FILTER1,
2463 (1 << (index - 32)));
2464 else
2465 AR5K_REG_ENABLE_BITS(ah, AR5K_MCAST_FILTER0, (1 << index));
2466
2467 return 0;
2468 }
2469
2470 /*
2471 * Clear Multicast filter by index
2472 */
2473 int ath5k_hw_clear_mcast_filter_idx(struct ath5k_hw *ah, u32 index)
2474 {
2475
2476 ATH5K_TRACE(ah->ah_sc);
2477 if (index >= 64)
2478 return -EINVAL;
2479 else if (index >= 32)
2480 AR5K_REG_DISABLE_BITS(ah, AR5K_MCAST_FILTER1,
2481 (1 << (index - 32)));
2482 else
2483 AR5K_REG_DISABLE_BITS(ah, AR5K_MCAST_FILTER0, (1 << index));
2484
2485 return 0;
2486 }
2487
2488 /*
2489 * Get current rx filter
2490 */
2491 u32 ath5k_hw_get_rx_filter(struct ath5k_hw *ah)
2492 {
2493 u32 data, filter = 0;
2494
2495 ATH5K_TRACE(ah->ah_sc);
2496 filter = ath5k_hw_reg_read(ah, AR5K_RX_FILTER);
2497
2498 /*Radar detection for 5212*/
2499 if (ah->ah_version == AR5K_AR5212) {
2500 data = ath5k_hw_reg_read(ah, AR5K_PHY_ERR_FIL);
2501
2502 if (data & AR5K_PHY_ERR_FIL_RADAR)
2503 filter |= AR5K_RX_FILTER_RADARERR;
2504 if (data & (AR5K_PHY_ERR_FIL_OFDM | AR5K_PHY_ERR_FIL_CCK))
2505 filter |= AR5K_RX_FILTER_PHYERR;
2506 }
2507
2508 return filter;
2509 }
2510
2511 /*
2512 * Set rx filter
2513 */
2514 void ath5k_hw_set_rx_filter(struct ath5k_hw *ah, u32 filter)
2515 {
2516 u32 data = 0;
2517
2518 ATH5K_TRACE(ah->ah_sc);
2519
2520 /* Set PHY error filter register on 5212*/
2521 if (ah->ah_version == AR5K_AR5212) {
2522 if (filter & AR5K_RX_FILTER_RADARERR)
2523 data |= AR5K_PHY_ERR_FIL_RADAR;
2524 if (filter & AR5K_RX_FILTER_PHYERR)
2525 data |= AR5K_PHY_ERR_FIL_OFDM | AR5K_PHY_ERR_FIL_CCK;
2526 }
2527
2528 /*
2529 * The AR5210 uses promiscous mode to detect radar activity
2530 */
2531 if (ah->ah_version == AR5K_AR5210 &&
2532 (filter & AR5K_RX_FILTER_RADARERR)) {
2533 filter &= ~AR5K_RX_FILTER_RADARERR;
2534 filter |= AR5K_RX_FILTER_PROM;
2535 }
2536
2537 /*Zero length DMA*/
2538 if (data)
2539 AR5K_REG_ENABLE_BITS(ah, AR5K_RXCFG, AR5K_RXCFG_ZLFDMA);
2540 else
2541 AR5K_REG_DISABLE_BITS(ah, AR5K_RXCFG, AR5K_RXCFG_ZLFDMA);
2542
2543 /*Write RX Filter register*/
2544 ath5k_hw_reg_write(ah, filter & 0xff, AR5K_RX_FILTER);
2545
2546 /*Write PHY error filter register on 5212*/
2547 if (ah->ah_version == AR5K_AR5212)
2548 ath5k_hw_reg_write(ah, data, AR5K_PHY_ERR_FIL);
2549
2550 }
2551
2552 /*
2553 * Beacon related functions
2554 */
2555
2556 /*
2557 * Get a 32bit TSF
2558 */
2559 u32 ath5k_hw_get_tsf32(struct ath5k_hw *ah)
2560 {
2561 ATH5K_TRACE(ah->ah_sc);
2562 return ath5k_hw_reg_read(ah, AR5K_TSF_L32);
2563 }
2564
2565 /*
2566 * Get the full 64bit TSF
2567 */
2568 u64 ath5k_hw_get_tsf64(struct ath5k_hw *ah)
2569 {
2570 u64 tsf = ath5k_hw_reg_read(ah, AR5K_TSF_U32);
2571 ATH5K_TRACE(ah->ah_sc);
2572
2573 return ath5k_hw_reg_read(ah, AR5K_TSF_L32) | (tsf << 32);
2574 }
2575
2576 /*
2577 * Force a TSF reset
2578 */
2579 void ath5k_hw_reset_tsf(struct ath5k_hw *ah)
2580 {
2581 ATH5K_TRACE(ah->ah_sc);
2582 AR5K_REG_ENABLE_BITS(ah, AR5K_BEACON, AR5K_BEACON_RESET_TSF);
2583 }
2584
2585 /*
2586 * Initialize beacon timers
2587 */
2588 void ath5k_hw_init_beacon(struct ath5k_hw *ah, u32 next_beacon, u32 interval)
2589 {
2590 u32 timer1, timer2, timer3;
2591
2592 ATH5K_TRACE(ah->ah_sc);
2593 /*
2594 * Set the additional timers by mode
2595 */
2596 switch (ah->ah_op_mode) {
2597 case IEEE80211_IF_TYPE_STA:
2598 if (ah->ah_version == AR5K_AR5210) {
2599 timer1 = 0xffffffff;
2600 timer2 = 0xffffffff;
2601 } else {
2602 timer1 = 0x0000ffff;
2603 timer2 = 0x0007ffff;
2604 }
2605 break;
2606
2607 default:
2608 timer1 = (next_beacon - AR5K_TUNE_DMA_BEACON_RESP) << 3;
2609 timer2 = (next_beacon - AR5K_TUNE_SW_BEACON_RESP) << 3;
2610 }
2611
2612 timer3 = next_beacon + (ah->ah_atim_window ? ah->ah_atim_window : 1);
2613
2614 /*
2615 * Set the beacon register and enable all timers.
2616 * (next beacon, DMA beacon, software beacon, ATIM window time)
2617 */
2618 ath5k_hw_reg_write(ah, next_beacon, AR5K_TIMER0);
2619 ath5k_hw_reg_write(ah, timer1, AR5K_TIMER1);
2620 ath5k_hw_reg_write(ah, timer2, AR5K_TIMER2);
2621 ath5k_hw_reg_write(ah, timer3, AR5K_TIMER3);
2622
2623 ath5k_hw_reg_write(ah, interval & (AR5K_BEACON_PERIOD |
2624 AR5K_BEACON_RESET_TSF | AR5K_BEACON_ENABLE),
2625 AR5K_BEACON);
2626 }
2627
2628 #if 0
2629 /*
2630 * Set beacon timers
2631 */
2632 int ath5k_hw_set_beacon_timers(struct ath5k_hw *ah,
2633 const struct ath5k_beacon_state *state)
2634 {
2635 u32 cfp_period, next_cfp, dtim, interval, next_beacon;
2636
2637 /*
2638 * TODO: should be changed through *state
2639 * review struct ath5k_beacon_state struct
2640 *
2641 * XXX: These are used for cfp period bellow, are they
2642 * ok ? Is it O.K. for tsf here to be 0 or should we use
2643 * get_tsf ?
2644 */
2645 u32 dtim_count = 0; /* XXX */
2646 u32 cfp_count = 0; /* XXX */
2647 u32 tsf = 0; /* XXX */
2648
2649 ATH5K_TRACE(ah->ah_sc);
2650 /* Return on an invalid beacon state */
2651 if (state->bs_interval < 1)
2652 return -EINVAL;
2653
2654 interval = state->bs_interval;
2655 dtim = state->bs_dtim_period;
2656
2657 /*
2658 * PCF support?
2659 */
2660 if (state->bs_cfp_period > 0) {
2661 /*
2662 * Enable PCF mode and set the CFP
2663 * (Contention Free Period) and timer registers
2664 */
2665 cfp_period = state->bs_cfp_period * state->bs_dtim_period *
2666 state->bs_interval;
2667 next_cfp = (cfp_count * state->bs_dtim_period + dtim_count) *
2668 state->bs_interval;
2669
2670 AR5K_REG_ENABLE_BITS(ah, AR5K_STA_ID1,
2671 AR5K_STA_ID1_DEFAULT_ANTENNA |
2672 AR5K_STA_ID1_PCF);
2673 ath5k_hw_reg_write(ah, cfp_period, AR5K_CFP_PERIOD);
2674 ath5k_hw_reg_write(ah, state->bs_cfp_max_duration,
2675 AR5K_CFP_DUR);
2676 ath5k_hw_reg_write(ah, (tsf + (next_cfp == 0 ? cfp_period :
2677 next_cfp)) << 3, AR5K_TIMER2);
2678 } else {
2679 /* Disable PCF mode */
2680 AR5K_REG_DISABLE_BITS(ah, AR5K_STA_ID1,
2681 AR5K_STA_ID1_DEFAULT_ANTENNA |
2682 AR5K_STA_ID1_PCF);
2683 }
2684
2685 /*
2686 * Enable the beacon timer register
2687 */
2688 ath5k_hw_reg_write(ah, state->bs_next_beacon, AR5K_TIMER0);
2689
2690 /*
2691 * Start the beacon timers
2692 */
2693 ath5k_hw_reg_write(ah, (ath5k_hw_reg_read(ah, AR5K_BEACON) &~
2694 (AR5K_BEACON_PERIOD | AR5K_BEACON_TIM)) |
2695 AR5K_REG_SM(state->bs_tim_offset ? state->bs_tim_offset + 4 : 0,
2696 AR5K_BEACON_TIM) | AR5K_REG_SM(state->bs_interval,
2697 AR5K_BEACON_PERIOD), AR5K_BEACON);
2698
2699 /*
2700 * Write new beacon miss threshold, if it appears to be valid
2701 * XXX: Figure out right values for min <= bs_bmiss_threshold <= max
2702 * and return if its not in range. We can test this by reading value and
2703 * setting value to a largest value and seeing which values register.
2704 */
2705
2706 AR5K_REG_WRITE_BITS(ah, AR5K_RSSI_THR, AR5K_RSSI_THR_BMISS,
2707 state->bs_bmiss_threshold);
2708
2709 /*
2710 * Set sleep control register
2711 * XXX: Didn't find this in 5210 code but since this register
2712 * exists also in ar5k's 5210 headers i leave it as common code.
2713 */
2714 AR5K_REG_WRITE_BITS(ah, AR5K_SLEEP_CTL, AR5K_SLEEP_CTL_SLDUR,
2715 (state->bs_sleep_duration - 3) << 3);
2716
2717 /*
2718 * Set enhanced sleep registers on 5212
2719 */
2720 if (ah->ah_version == AR5K_AR5212) {
2721 if (state->bs_sleep_duration > state->bs_interval &&
2722 roundup(state->bs_sleep_duration, interval) ==
2723 state->bs_sleep_duration)
2724 interval = state->bs_sleep_duration;
2725
2726 if (state->bs_sleep_duration > dtim && (dtim == 0 ||
2727 roundup(state->bs_sleep_duration, dtim) ==
2728 state->bs_sleep_duration))
2729 dtim = state->bs_sleep_duration;
2730
2731 if (interval > dtim)
2732 return -EINVAL;
2733
2734 next_beacon = interval == dtim ? state->bs_next_dtim :
2735 state->bs_next_beacon;
2736
2737 ath5k_hw_reg_write(ah,
2738 AR5K_REG_SM((state->bs_next_dtim - 3) << 3,
2739 AR5K_SLEEP0_NEXT_DTIM) |
2740 AR5K_REG_SM(10, AR5K_SLEEP0_CABTO) |
2741 AR5K_SLEEP0_ENH_SLEEP_EN |
2742 AR5K_SLEEP0_ASSUME_DTIM, AR5K_SLEEP0);
2743
2744 ath5k_hw_reg_write(ah, AR5K_REG_SM((next_beacon - 3) << 3,
2745 AR5K_SLEEP1_NEXT_TIM) |
2746 AR5K_REG_SM(10, AR5K_SLEEP1_BEACON_TO), AR5K_SLEEP1);
2747
2748 ath5k_hw_reg_write(ah,
2749 AR5K_REG_SM(interval, AR5K_SLEEP2_TIM_PER) |
2750 AR5K_REG_SM(dtim, AR5K_SLEEP2_DTIM_PER), AR5K_SLEEP2);
2751 }
2752
2753 return 0;
2754 }
2755
2756 /*
2757 * Reset beacon timers
2758 */
2759 void ath5k_hw_reset_beacon(struct ath5k_hw *ah)
2760 {
2761 ATH5K_TRACE(ah->ah_sc);
2762 /*
2763 * Disable beacon timer
2764 */
2765 ath5k_hw_reg_write(ah, 0, AR5K_TIMER0);
2766
2767 /*
2768 * Disable some beacon register values
2769 */
2770 AR5K_REG_DISABLE_BITS(ah, AR5K_STA_ID1,
2771 AR5K_STA_ID1_DEFAULT_ANTENNA | AR5K_STA_ID1_PCF);
2772 ath5k_hw_reg_write(ah, AR5K_BEACON_PERIOD, AR5K_BEACON);
2773 }
2774
2775 /*
2776 * Wait for beacon queue to finish
2777 */
2778 int ath5k_hw_beaconq_finish(struct ath5k_hw *ah, unsigned long phys_addr)
2779 {
2780 unsigned int i;
2781 int ret;
2782
2783 ATH5K_TRACE(ah->ah_sc);
2784
2785 /* 5210 doesn't have QCU*/
2786 if (ah->ah_version == AR5K_AR5210) {
2787 /*
2788 * Wait for beaconn queue to finish by checking
2789 * Control Register and Beacon Status Register.
2790 */
2791 for (i = AR5K_TUNE_BEACON_INTERVAL / 2; i > 0; i--) {
2792 if (!(ath5k_hw_reg_read(ah, AR5K_BSR) & AR5K_BSR_TXQ1F)
2793 ||
2794 !(ath5k_hw_reg_read(ah, AR5K_CR) & AR5K_BSR_TXQ1F))
2795 break;
2796 udelay(10);
2797 }
2798
2799 /* Timeout... */
2800 if (i <= 0) {
2801 /*
2802 * Re-schedule the beacon queue
2803 */
2804 ath5k_hw_reg_write(ah, phys_addr, AR5K_NOQCU_TXDP1);
2805 ath5k_hw_reg_write(ah, AR5K_BCR_TQ1V | AR5K_BCR_BDMAE,
2806 AR5K_BCR);
2807
2808 return -EIO;
2809 }
2810 ret = 0;
2811 } else {
2812 /*5211/5212*/
2813 ret = ath5k_hw_register_timeout(ah,
2814 AR5K_QUEUE_STATUS(AR5K_TX_QUEUE_ID_BEACON),
2815 AR5K_QCU_STS_FRMPENDCNT, 0, false);
2816
2817 if (AR5K_REG_READ_Q(ah, AR5K_QCU_TXE, AR5K_TX_QUEUE_ID_BEACON))
2818 return -EIO;
2819 }
2820
2821 return ret;
2822 }
2823 #endif
2824
2825 /*
2826 * Update mib counters (statistics)
2827 */
2828 void ath5k_hw_update_mib_counters(struct ath5k_hw *ah,
2829 struct ath5k_mib_stats *statistics)
2830 {
2831 ATH5K_TRACE(ah->ah_sc);
2832 /* Read-And-Clear */
2833 statistics->ackrcv_bad += ath5k_hw_reg_read(ah, AR5K_ACK_FAIL);
2834 statistics->rts_bad += ath5k_hw_reg_read(ah, AR5K_RTS_FAIL);
2835 statistics->rts_good += ath5k_hw_reg_read(ah, AR5K_RTS_OK);
2836 statistics->fcs_bad += ath5k_hw_reg_read(ah, AR5K_FCS_FAIL);
2837 statistics->beacons += ath5k_hw_reg_read(ah, AR5K_BEACON_CNT);
2838
2839 /* Reset profile count registers on 5212*/
2840 if (ah->ah_version == AR5K_AR5212) {
2841 ath5k_hw_reg_write(ah, 0, AR5K_PROFCNT_TX);
2842 ath5k_hw_reg_write(ah, 0, AR5K_PROFCNT_RX);
2843 ath5k_hw_reg_write(ah, 0, AR5K_PROFCNT_RXCLR);
2844 ath5k_hw_reg_write(ah, 0, AR5K_PROFCNT_CYCLE);
2845 }
2846 }
2847
2848 /** ath5k_hw_set_ack_bitrate - set bitrate for ACKs
2849 *
2850 * @ah: the &struct ath5k_hw
2851 * @high: determines if to use low bit rate or now
2852 */
2853 void ath5k_hw_set_ack_bitrate_high(struct ath5k_hw *ah, bool high)
2854 {
2855 if (ah->ah_version != AR5K_AR5212)
2856 return;
2857 else {
2858 u32 val = AR5K_STA_ID1_BASE_RATE_11B | AR5K_STA_ID1_ACKCTS_6MB;
2859 if (high)
2860 AR5K_REG_ENABLE_BITS(ah, AR5K_STA_ID1, val);
2861 else
2862 AR5K_REG_DISABLE_BITS(ah, AR5K_STA_ID1, val);
2863 }
2864 }
2865
2866
2867 /*
2868 * ACK/CTS Timeouts
2869 */
2870
2871 /*
2872 * Set ACK timeout on PCU
2873 */
2874 int ath5k_hw_set_ack_timeout(struct ath5k_hw *ah, unsigned int timeout)
2875 {
2876 ATH5K_TRACE(ah->ah_sc);
2877 if (ath5k_hw_clocktoh(AR5K_REG_MS(0xffffffff, AR5K_TIME_OUT_ACK),
2878 ah->ah_turbo) <= timeout)
2879 return -EINVAL;
2880
2881 AR5K_REG_WRITE_BITS(ah, AR5K_TIME_OUT, AR5K_TIME_OUT_ACK,
2882 ath5k_hw_htoclock(timeout, ah->ah_turbo));
2883
2884 return 0;
2885 }
2886
2887 /*
2888 * Read the ACK timeout from PCU
2889 */
2890 unsigned int ath5k_hw_get_ack_timeout(struct ath5k_hw *ah)
2891 {
2892 ATH5K_TRACE(ah->ah_sc);
2893
2894 return ath5k_hw_clocktoh(AR5K_REG_MS(ath5k_hw_reg_read(ah,
2895 AR5K_TIME_OUT), AR5K_TIME_OUT_ACK), ah->ah_turbo);
2896 }
2897
2898 /*
2899 * Set CTS timeout on PCU
2900 */
2901 int ath5k_hw_set_cts_timeout(struct ath5k_hw *ah, unsigned int timeout)
2902 {
2903 ATH5K_TRACE(ah->ah_sc);
2904 if (ath5k_hw_clocktoh(AR5K_REG_MS(0xffffffff, AR5K_TIME_OUT_CTS),
2905 ah->ah_turbo) <= timeout)
2906 return -EINVAL;
2907
2908 AR5K_REG_WRITE_BITS(ah, AR5K_TIME_OUT, AR5K_TIME_OUT_CTS,
2909 ath5k_hw_htoclock(timeout, ah->ah_turbo));
2910
2911 return 0;
2912 }
2913
2914 /*
2915 * Read CTS timeout from PCU
2916 */
2917 unsigned int ath5k_hw_get_cts_timeout(struct ath5k_hw *ah)
2918 {
2919 ATH5K_TRACE(ah->ah_sc);
2920 return ath5k_hw_clocktoh(AR5K_REG_MS(ath5k_hw_reg_read(ah,
2921 AR5K_TIME_OUT), AR5K_TIME_OUT_CTS), ah->ah_turbo);
2922 }
2923
2924 /*
2925 * Key table (WEP) functions
2926 */
2927
2928 int ath5k_hw_reset_key(struct ath5k_hw *ah, u16 entry)
2929 {
2930 unsigned int i;
2931
2932 ATH5K_TRACE(ah->ah_sc);
2933 AR5K_ASSERT_ENTRY(entry, AR5K_KEYTABLE_SIZE);
2934
2935 for (i = 0; i < AR5K_KEYCACHE_SIZE; i++)
2936 ath5k_hw_reg_write(ah, 0, AR5K_KEYTABLE_OFF(entry, i));
2937
2938 /* Set NULL encryption on non-5210*/
2939 if (ah->ah_version != AR5K_AR5210)
2940 ath5k_hw_reg_write(ah, AR5K_KEYTABLE_TYPE_NULL,
2941 AR5K_KEYTABLE_TYPE(entry));
2942
2943 return 0;
2944 }
2945
2946 int ath5k_hw_is_key_valid(struct ath5k_hw *ah, u16 entry)
2947 {
2948 ATH5K_TRACE(ah->ah_sc);
2949 AR5K_ASSERT_ENTRY(entry, AR5K_KEYTABLE_SIZE);
2950
2951 /* Check the validation flag at the end of the entry */
2952 return ath5k_hw_reg_read(ah, AR5K_KEYTABLE_MAC1(entry)) &
2953 AR5K_KEYTABLE_VALID;
2954 }
2955
2956 int ath5k_hw_set_key(struct ath5k_hw *ah, u16 entry,
2957 const struct ieee80211_key_conf *key, const u8 *mac)
2958 {
2959 unsigned int i;
2960 __le32 key_v[5] = {};
2961 u32 keytype;
2962
2963 ATH5K_TRACE(ah->ah_sc);
2964
2965 /* key->keylen comes in from mac80211 in bytes */
2966
2967 if (key->keylen > AR5K_KEYTABLE_SIZE / 8)
2968 return -EOPNOTSUPP;
2969
2970 switch (key->keylen) {
2971 /* WEP 40-bit = 40-bit entered key + 24 bit IV = 64-bit */
2972 case 40 / 8:
2973 memcpy(&key_v[0], key->key, 5);
2974 keytype = AR5K_KEYTABLE_TYPE_40;
2975 break;
2976
2977 /* WEP 104-bit = 104-bit entered key + 24-bit IV = 128-bit */
2978 case 104 / 8:
2979 memcpy(&key_v[0], &key->key[0], 6);
2980 memcpy(&key_v[2], &key->key[6], 6);
2981 memcpy(&key_v[4], &key->key[12], 1);
2982 keytype = AR5K_KEYTABLE_TYPE_104;
2983 break;
2984 /* WEP 128-bit = 128-bit entered key + 24 bit IV = 152-bit */
2985 case 128 / 8:
2986 memcpy(&key_v[0], &key->key[0], 6);
2987 memcpy(&key_v[2], &key->key[6], 6);
2988 memcpy(&key_v[4], &key->key[12], 4);
2989 keytype = AR5K_KEYTABLE_TYPE_128;
2990 break;
2991
2992 default:
2993 return -EINVAL; /* shouldn't happen */
2994 }
2995
2996 for (i = 0; i < ARRAY_SIZE(key_v); i++)
2997 ath5k_hw_reg_write(ah, le32_to_cpu(key_v[i]),
2998 AR5K_KEYTABLE_OFF(entry, i));
2999
3000 ath5k_hw_reg_write(ah, keytype, AR5K_KEYTABLE_TYPE(entry));
3001
3002 return ath5k_hw_set_key_lladdr(ah, entry, mac);
3003 }
3004
3005 int ath5k_hw_set_key_lladdr(struct ath5k_hw *ah, u16 entry, const u8 *mac)
3006 {
3007 u32 low_id, high_id;
3008
3009 ATH5K_TRACE(ah->ah_sc);
3010 /* Invalid entry (key table overflow) */
3011 AR5K_ASSERT_ENTRY(entry, AR5K_KEYTABLE_SIZE);
3012
3013 /* MAC may be NULL if it's a broadcast key. In this case no need to
3014 * to compute AR5K_LOW_ID and AR5K_HIGH_ID as we already know it. */
3015 if (unlikely(mac == NULL)) {
3016 low_id = 0xffffffff;
3017 high_id = 0xffff | AR5K_KEYTABLE_VALID;
3018 } else {
3019 low_id = AR5K_LOW_ID(mac);
3020 high_id = AR5K_HIGH_ID(mac) | AR5K_KEYTABLE_VALID;
3021 }
3022
3023 ath5k_hw_reg_write(ah, low_id, AR5K_KEYTABLE_MAC0(entry));
3024 ath5k_hw_reg_write(ah, high_id, AR5K_KEYTABLE_MAC1(entry));
3025
3026 return 0;
3027 }
3028
3029
3030 /********************************************\
3031 Queue Control Unit, DFS Control Unit Functions
3032 \********************************************/
3033
3034 /*
3035 * Initialize a transmit queue
3036 */
3037 int ath5k_hw_setup_tx_queue(struct ath5k_hw *ah, enum ath5k_tx_queue queue_type,
3038 struct ath5k_txq_info *queue_info)
3039 {
3040 unsigned int queue;
3041 int ret;
3042
3043 ATH5K_TRACE(ah->ah_sc);
3044
3045 /*
3046 * Get queue by type
3047 */
3048 /*5210 only has 2 queues*/
3049 if (ah->ah_version == AR5K_AR5210) {
3050 switch (queue_type) {
3051 case AR5K_TX_QUEUE_DATA:
3052 queue = AR5K_TX_QUEUE_ID_NOQCU_DATA;
3053 break;
3054 case AR5K_TX_QUEUE_BEACON:
3055 case AR5K_TX_QUEUE_CAB:
3056 queue = AR5K_TX_QUEUE_ID_NOQCU_BEACON;
3057 break;
3058 default:
3059 return -EINVAL;
3060 }
3061 } else {
3062 switch (queue_type) {
3063 case AR5K_TX_QUEUE_DATA:
3064 for (queue = AR5K_TX_QUEUE_ID_DATA_MIN;
3065 ah->ah_txq[queue].tqi_type !=
3066 AR5K_TX_QUEUE_INACTIVE; queue++) {
3067
3068 if (queue > AR5K_TX_QUEUE_ID_DATA_MAX)
3069 return -EINVAL;
3070 }
3071 break;
3072 case AR5K_TX_QUEUE_UAPSD:
3073 queue = AR5K_TX_QUEUE_ID_UAPSD;
3074 break;
3075 case AR5K_TX_QUEUE_BEACON:
3076 queue = AR5K_TX_QUEUE_ID_BEACON;
3077 break;
3078 case AR5K_TX_QUEUE_CAB:
3079 queue = AR5K_TX_QUEUE_ID_CAB;
3080 break;
3081 case AR5K_TX_QUEUE_XR_DATA:
3082 if (ah->ah_version != AR5K_AR5212)
3083 ATH5K_ERR(ah->ah_sc,
3084 "XR data queues only supported in"
3085 " 5212!\n");
3086 queue = AR5K_TX_QUEUE_ID_XR_DATA;
3087 break;
3088 default:
3089 return -EINVAL;
3090 }
3091 }
3092
3093 /*
3094 * Setup internal queue structure
3095 */
3096 memset(&ah->ah_txq[queue], 0, sizeof(struct ath5k_txq_info));
3097 ah->ah_txq[queue].tqi_type = queue_type;
3098
3099 if (queue_info != NULL) {
3100 queue_info->tqi_type = queue_type;
3101 ret = ath5k_hw_setup_tx_queueprops(ah, queue, queue_info);
3102 if (ret)
3103 return ret;
3104 }
3105 /*
3106 * We use ah_txq_status to hold a temp value for
3107 * the Secondary interrupt mask registers on 5211+
3108 * check out ath5k_hw_reset_tx_queue
3109 */
3110 AR5K_Q_ENABLE_BITS(ah->ah_txq_status, queue);
3111
3112 return queue;
3113 }
3114
3115 /*
3116 * Setup a transmit queue
3117 */
3118 int ath5k_hw_setup_tx_queueprops(struct ath5k_hw *ah, int queue,
3119 const struct ath5k_txq_info *queue_info)
3120 {
3121 ATH5K_TRACE(ah->ah_sc);
3122 AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
3123
3124 if (ah->ah_txq[queue].tqi_type == AR5K_TX_QUEUE_INACTIVE)
3125 return -EIO;
3126
3127 memcpy(&ah->ah_txq[queue], queue_info, sizeof(struct ath5k_txq_info));
3128
3129 /*XXX: Is this supported on 5210 ?*/
3130 if ((queue_info->tqi_type == AR5K_TX_QUEUE_DATA &&
3131 ((queue_info->tqi_subtype == AR5K_WME_AC_VI) ||
3132 (queue_info->tqi_subtype == AR5K_WME_AC_VO))) ||
3133 queue_info->tqi_type == AR5K_TX_QUEUE_UAPSD)
3134 ah->ah_txq[queue].tqi_flags |= AR5K_TXQ_FLAG_POST_FR_BKOFF_DIS;
3135
3136 return 0;
3137 }
3138
3139 /*
3140 * Get properties for a specific transmit queue
3141 */
3142 int ath5k_hw_get_tx_queueprops(struct ath5k_hw *ah, int queue,
3143 struct ath5k_txq_info *queue_info)
3144 {
3145 ATH5K_TRACE(ah->ah_sc);
3146 memcpy(queue_info, &ah->ah_txq[queue], sizeof(struct ath5k_txq_info));
3147 return 0;
3148 }
3149
3150 /*
3151 * Set a transmit queue inactive
3152 */
3153 void ath5k_hw_release_tx_queue(struct ath5k_hw *ah, unsigned int queue)
3154 {
3155 ATH5K_TRACE(ah->ah_sc);
3156 if (WARN_ON(queue >= ah->ah_capabilities.cap_queues.q_tx_num))
3157 return;
3158
3159 /* This queue will be skipped in further operations */
3160 ah->ah_txq[queue].tqi_type = AR5K_TX_QUEUE_INACTIVE;
3161 /*For SIMR setup*/
3162 AR5K_Q_DISABLE_BITS(ah->ah_txq_status, queue);
3163 }
3164
3165 /*
3166 * Set DFS params for a transmit queue
3167 */
3168 int ath5k_hw_reset_tx_queue(struct ath5k_hw *ah, unsigned int queue)
3169 {
3170 u32 cw_min, cw_max, retry_lg, retry_sh;
3171 struct ath5k_txq_info *tq = &ah->ah_txq[queue];
3172
3173 ATH5K_TRACE(ah->ah_sc);
3174 AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
3175
3176 tq = &ah->ah_txq[queue];
3177
3178 if (tq->tqi_type == AR5K_TX_QUEUE_INACTIVE)
3179 return 0;
3180
3181 if (ah->ah_version == AR5K_AR5210) {
3182 /* Only handle data queues, others will be ignored */
3183 if (tq->tqi_type != AR5K_TX_QUEUE_DATA)
3184 return 0;
3185
3186 /* Set Slot time */
3187 ath5k_hw_reg_write(ah, ah->ah_turbo == true ?
3188 AR5K_INIT_SLOT_TIME_TURBO : AR5K_INIT_SLOT_TIME,
3189 AR5K_SLOT_TIME);
3190 /* Set ACK_CTS timeout */
3191 ath5k_hw_reg_write(ah, ah->ah_turbo == true ?
3192 AR5K_INIT_ACK_CTS_TIMEOUT_TURBO :
3193 AR5K_INIT_ACK_CTS_TIMEOUT, AR5K_SLOT_TIME);
3194 /* Set Transmit Latency */
3195 ath5k_hw_reg_write(ah, ah->ah_turbo == true ?
3196 AR5K_INIT_TRANSMIT_LATENCY_TURBO :
3197 AR5K_INIT_TRANSMIT_LATENCY, AR5K_USEC_5210);
3198 /* Set IFS0 */
3199 if (ah->ah_turbo == true)
3200 ath5k_hw_reg_write(ah, ((AR5K_INIT_SIFS_TURBO +
3201 (ah->ah_aifs + tq->tqi_aifs) *
3202 AR5K_INIT_SLOT_TIME_TURBO) <<
3203 AR5K_IFS0_DIFS_S) | AR5K_INIT_SIFS_TURBO,
3204 AR5K_IFS0);
3205 else
3206 ath5k_hw_reg_write(ah, ((AR5K_INIT_SIFS +
3207 (ah->ah_aifs + tq->tqi_aifs) *
3208 AR5K_INIT_SLOT_TIME) << AR5K_IFS0_DIFS_S) |
3209 AR5K_INIT_SIFS, AR5K_IFS0);
3210
3211 /* Set IFS1 */
3212 ath5k_hw_reg_write(ah, ah->ah_turbo == true ?
3213 AR5K_INIT_PROTO_TIME_CNTRL_TURBO :
3214 AR5K_INIT_PROTO_TIME_CNTRL, AR5K_IFS1);
3215 /* Set PHY register 0x9844 (??) */
3216 ath5k_hw_reg_write(ah, ah->ah_turbo == true ?
3217 (ath5k_hw_reg_read(ah, AR5K_PHY(17)) & ~0x7F) | 0x38 :
3218 (ath5k_hw_reg_read(ah, AR5K_PHY(17)) & ~0x7F) | 0x1C,
3219 AR5K_PHY(17));
3220 /* Set Frame Control Register */
3221 ath5k_hw_reg_write(ah, ah->ah_turbo == true ?
3222 (AR5K_PHY_FRAME_CTL_INI | AR5K_PHY_TURBO_MODE |
3223 AR5K_PHY_TURBO_SHORT | 0x2020) :
3224 (AR5K_PHY_FRAME_CTL_INI | 0x1020),
3225 AR5K_PHY_FRAME_CTL_5210);
3226 }
3227
3228 /*
3229 * Calculate cwmin/max by channel mode
3230 */
3231 cw_min = ah->ah_cw_min = AR5K_TUNE_CWMIN;
3232 cw_max = ah->ah_cw_max = AR5K_TUNE_CWMAX;
3233 ah->ah_aifs = AR5K_TUNE_AIFS;
3234 /*XR is only supported on 5212*/
3235 if (IS_CHAN_XR(ah->ah_current_channel) &&
3236 ah->ah_version == AR5K_AR5212) {
3237 cw_min = ah->ah_cw_min = AR5K_TUNE_CWMIN_XR;
3238 cw_max = ah->ah_cw_max = AR5K_TUNE_CWMAX_XR;
3239 ah->ah_aifs = AR5K_TUNE_AIFS_XR;
3240 /*B mode is not supported on 5210*/
3241 } else if (IS_CHAN_B(ah->ah_current_channel) &&
3242 ah->ah_version != AR5K_AR5210) {
3243 cw_min = ah->ah_cw_min = AR5K_TUNE_CWMIN_11B;
3244 cw_max = ah->ah_cw_max = AR5K_TUNE_CWMAX_11B;
3245 ah->ah_aifs = AR5K_TUNE_AIFS_11B;
3246 }
3247
3248 cw_min = 1;
3249 while (cw_min < ah->ah_cw_min)
3250 cw_min = (cw_min << 1) | 1;
3251
3252 cw_min = tq->tqi_cw_min < 0 ? (cw_min >> (-tq->tqi_cw_min)) :
3253 ((cw_min << tq->tqi_cw_min) + (1 << tq->tqi_cw_min) - 1);
3254 cw_max = tq->tqi_cw_max < 0 ? (cw_max >> (-tq->tqi_cw_max)) :
3255 ((cw_max << tq->tqi_cw_max) + (1 << tq->tqi_cw_max) - 1);
3256
3257 /*
3258 * Calculate and set retry limits
3259 */
3260 if (ah->ah_software_retry == true) {
3261 /* XXX Need to test this */
3262 retry_lg = ah->ah_limit_tx_retries;
3263 retry_sh = retry_lg = retry_lg > AR5K_DCU_RETRY_LMT_SH_RETRY ?
3264 AR5K_DCU_RETRY_LMT_SH_RETRY : retry_lg;
3265 } else {
3266 retry_lg = AR5K_INIT_LG_RETRY;
3267 retry_sh = AR5K_INIT_SH_RETRY;
3268 }
3269
3270 /*No QCU/DCU [5210]*/
3271 if (ah->ah_version == AR5K_AR5210) {
3272 ath5k_hw_reg_write(ah,
3273 (cw_min << AR5K_NODCU_RETRY_LMT_CW_MIN_S)
3274 | AR5K_REG_SM(AR5K_INIT_SLG_RETRY,
3275 AR5K_NODCU_RETRY_LMT_SLG_RETRY)
3276 | AR5K_REG_SM(AR5K_INIT_SSH_RETRY,
3277 AR5K_NODCU_RETRY_LMT_SSH_RETRY)
3278 | AR5K_REG_SM(retry_lg, AR5K_NODCU_RETRY_LMT_LG_RETRY)
3279 | AR5K_REG_SM(retry_sh, AR5K_NODCU_RETRY_LMT_SH_RETRY),
3280 AR5K_NODCU_RETRY_LMT);
3281 } else {
3282 /*QCU/DCU [5211+]*/
3283 ath5k_hw_reg_write(ah,
3284 AR5K_REG_SM(AR5K_INIT_SLG_RETRY,
3285 AR5K_DCU_RETRY_LMT_SLG_RETRY) |
3286 AR5K_REG_SM(AR5K_INIT_SSH_RETRY,
3287 AR5K_DCU_RETRY_LMT_SSH_RETRY) |
3288 AR5K_REG_SM(retry_lg, AR5K_DCU_RETRY_LMT_LG_RETRY) |
3289 AR5K_REG_SM(retry_sh, AR5K_DCU_RETRY_LMT_SH_RETRY),
3290 AR5K_QUEUE_DFS_RETRY_LIMIT(queue));
3291
3292 /*===Rest is also for QCU/DCU only [5211+]===*/
3293
3294 /*
3295 * Set initial content window (cw_min/cw_max)
3296 * and arbitrated interframe space (aifs)...
3297 */
3298 ath5k_hw_reg_write(ah,
3299 AR5K_REG_SM(cw_min, AR5K_DCU_LCL_IFS_CW_MIN) |
3300 AR5K_REG_SM(cw_max, AR5K_DCU_LCL_IFS_CW_MAX) |
3301 AR5K_REG_SM(ah->ah_aifs + tq->tqi_aifs,
3302 AR5K_DCU_LCL_IFS_AIFS),
3303 AR5K_QUEUE_DFS_LOCAL_IFS(queue));
3304
3305 /*
3306 * Set misc registers
3307 */
3308 ath5k_hw_reg_write(ah, AR5K_QCU_MISC_DCU_EARLY,
3309 AR5K_QUEUE_MISC(queue));
3310
3311 if (tq->tqi_cbr_period) {
3312 ath5k_hw_reg_write(ah, AR5K_REG_SM(tq->tqi_cbr_period,
3313 AR5K_QCU_CBRCFG_INTVAL) |
3314 AR5K_REG_SM(tq->tqi_cbr_overflow_limit,
3315 AR5K_QCU_CBRCFG_ORN_THRES),
3316 AR5K_QUEUE_CBRCFG(queue));
3317 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
3318 AR5K_QCU_MISC_FRSHED_CBR);
3319 if (tq->tqi_cbr_overflow_limit)
3320 AR5K_REG_ENABLE_BITS(ah,
3321 AR5K_QUEUE_MISC(queue),
3322 AR5K_QCU_MISC_CBR_THRES_ENABLE);
3323 }
3324
3325 if (tq->tqi_ready_time)
3326 ath5k_hw_reg_write(ah, AR5K_REG_SM(tq->tqi_ready_time,
3327 AR5K_QCU_RDYTIMECFG_INTVAL) |
3328 AR5K_QCU_RDYTIMECFG_ENABLE,
3329 AR5K_QUEUE_RDYTIMECFG(queue));
3330
3331 if (tq->tqi_burst_time) {
3332 ath5k_hw_reg_write(ah, AR5K_REG_SM(tq->tqi_burst_time,
3333 AR5K_DCU_CHAN_TIME_DUR) |
3334 AR5K_DCU_CHAN_TIME_ENABLE,
3335 AR5K_QUEUE_DFS_CHANNEL_TIME(queue));
3336
3337 if (tq->tqi_flags & AR5K_TXQ_FLAG_RDYTIME_EXP_POLICY_ENABLE)
3338 AR5K_REG_ENABLE_BITS(ah,
3339 AR5K_QUEUE_MISC(queue),
3340 AR5K_QCU_MISC_TXE);
3341 }
3342
3343 if (tq->tqi_flags & AR5K_TXQ_FLAG_BACKOFF_DISABLE)
3344 ath5k_hw_reg_write(ah, AR5K_DCU_MISC_POST_FR_BKOFF_DIS,
3345 AR5K_QUEUE_DFS_MISC(queue));
3346
3347 if (tq->tqi_flags & AR5K_TXQ_FLAG_FRAG_BURST_BACKOFF_ENABLE)
3348 ath5k_hw_reg_write(ah, AR5K_DCU_MISC_BACKOFF_FRAG,
3349 AR5K_QUEUE_DFS_MISC(queue));
3350
3351 /*
3352 * Set registers by queue type
3353 */
3354 switch (tq->tqi_type) {
3355 case AR5K_TX_QUEUE_BEACON:
3356 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
3357 AR5K_QCU_MISC_FRSHED_DBA_GT |
3358 AR5K_QCU_MISC_CBREXP_BCN |
3359 AR5K_QCU_MISC_BCN_ENABLE);
3360
3361 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_DFS_MISC(queue),
3362 (AR5K_DCU_MISC_ARBLOCK_CTL_GLOBAL <<
3363 AR5K_DCU_MISC_ARBLOCK_CTL_S) |
3364 AR5K_DCU_MISC_POST_FR_BKOFF_DIS |
3365 AR5K_DCU_MISC_BCN_ENABLE);
3366
3367 ath5k_hw_reg_write(ah, ((AR5K_TUNE_BEACON_INTERVAL -
3368 (AR5K_TUNE_SW_BEACON_RESP -
3369 AR5K_TUNE_DMA_BEACON_RESP) -
3370 AR5K_TUNE_ADDITIONAL_SWBA_BACKOFF) * 1024) |
3371 AR5K_QCU_RDYTIMECFG_ENABLE,
3372 AR5K_QUEUE_RDYTIMECFG(queue));
3373 break;
3374
3375 case AR5K_TX_QUEUE_CAB:
3376 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
3377 AR5K_QCU_MISC_FRSHED_DBA_GT |
3378 AR5K_QCU_MISC_CBREXP |
3379 AR5K_QCU_MISC_CBREXP_BCN);
3380
3381 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_DFS_MISC(queue),
3382 (AR5K_DCU_MISC_ARBLOCK_CTL_GLOBAL <<
3383 AR5K_DCU_MISC_ARBLOCK_CTL_S));
3384 break;
3385
3386 case AR5K_TX_QUEUE_UAPSD:
3387 AR5K_REG_ENABLE_BITS(ah, AR5K_QUEUE_MISC(queue),
3388 AR5K_QCU_MISC_CBREXP);
3389 break;
3390
3391 case AR5K_TX_QUEUE_DATA:
3392 default:
3393 break;
3394 }
3395
3396 /*
3397 * Enable interrupts for this tx queue
3398 * in the secondary interrupt mask registers
3399 */
3400 if (tq->tqi_flags & AR5K_TXQ_FLAG_TXOKINT_ENABLE)
3401 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txok, queue);
3402
3403 if (tq->tqi_flags & AR5K_TXQ_FLAG_TXERRINT_ENABLE)
3404 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txerr, queue);
3405
3406 if (tq->tqi_flags & AR5K_TXQ_FLAG_TXURNINT_ENABLE)
3407 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txurn, queue);
3408
3409 if (tq->tqi_flags & AR5K_TXQ_FLAG_TXDESCINT_ENABLE)
3410 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txdesc, queue);
3411
3412 if (tq->tqi_flags & AR5K_TXQ_FLAG_TXEOLINT_ENABLE)
3413 AR5K_Q_ENABLE_BITS(ah->ah_txq_imr_txeol, queue);
3414
3415
3416 /* Update secondary interrupt mask registers */
3417 ah->ah_txq_imr_txok &= ah->ah_txq_status;
3418 ah->ah_txq_imr_txerr &= ah->ah_txq_status;
3419 ah->ah_txq_imr_txurn &= ah->ah_txq_status;
3420 ah->ah_txq_imr_txdesc &= ah->ah_txq_status;
3421 ah->ah_txq_imr_txeol &= ah->ah_txq_status;
3422
3423 ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txq_imr_txok,
3424 AR5K_SIMR0_QCU_TXOK) |
3425 AR5K_REG_SM(ah->ah_txq_imr_txdesc,
3426 AR5K_SIMR0_QCU_TXDESC), AR5K_SIMR0);
3427 ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txq_imr_txerr,
3428 AR5K_SIMR1_QCU_TXERR) |
3429 AR5K_REG_SM(ah->ah_txq_imr_txeol,
3430 AR5K_SIMR1_QCU_TXEOL), AR5K_SIMR1);
3431 ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txq_imr_txurn,
3432 AR5K_SIMR2_QCU_TXURN), AR5K_SIMR2);
3433 }
3434
3435 return 0;
3436 }
3437
3438 /*
3439 * Get number of pending frames
3440 * for a specific queue [5211+]
3441 */
3442 u32 ath5k_hw_num_tx_pending(struct ath5k_hw *ah, unsigned int queue) {
3443 ATH5K_TRACE(ah->ah_sc);
3444 AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
3445
3446 /* Return if queue is declared inactive */
3447 if (ah->ah_txq[queue].tqi_type == AR5K_TX_QUEUE_INACTIVE)
3448 return false;
3449
3450 /* XXX: How about AR5K_CFG_TXCNT ? */
3451 if (ah->ah_version == AR5K_AR5210)
3452 return false;
3453
3454 return AR5K_QUEUE_STATUS(queue) & AR5K_QCU_STS_FRMPENDCNT;
3455 }
3456
3457 /*
3458 * Set slot time
3459 */
3460 int ath5k_hw_set_slot_time(struct ath5k_hw *ah, unsigned int slot_time)
3461 {
3462 ATH5K_TRACE(ah->ah_sc);
3463 if (slot_time < AR5K_SLOT_TIME_9 || slot_time > AR5K_SLOT_TIME_MAX)
3464 return -EINVAL;
3465
3466 if (ah->ah_version == AR5K_AR5210)
3467 ath5k_hw_reg_write(ah, ath5k_hw_htoclock(slot_time,
3468 ah->ah_turbo), AR5K_SLOT_TIME);
3469 else
3470 ath5k_hw_reg_write(ah, slot_time, AR5K_DCU_GBL_IFS_SLOT);
3471
3472 return 0;
3473 }
3474
3475 /*
3476 * Get slot time
3477 */
3478 unsigned int ath5k_hw_get_slot_time(struct ath5k_hw *ah)
3479 {
3480 ATH5K_TRACE(ah->ah_sc);
3481 if (ah->ah_version == AR5K_AR5210)
3482 return ath5k_hw_clocktoh(ath5k_hw_reg_read(ah,
3483 AR5K_SLOT_TIME) & 0xffff, ah->ah_turbo);
3484 else
3485 return ath5k_hw_reg_read(ah, AR5K_DCU_GBL_IFS_SLOT) & 0xffff;
3486 }
3487
3488
3489 /******************************\
3490 Hardware Descriptor Functions
3491 \******************************/
3492
3493 /*
3494 * TX Descriptor
3495 */
3496
3497 /*
3498 * Initialize the 2-word tx descriptor on 5210/5211
3499 */
3500 static int
3501 ath5k_hw_setup_2word_tx_desc(struct ath5k_hw *ah, struct ath5k_desc *desc,
3502 unsigned int pkt_len, unsigned int hdr_len, enum ath5k_pkt_type type,
3503 unsigned int tx_power, unsigned int tx_rate0, unsigned int tx_tries0,
3504 unsigned int key_index, unsigned int antenna_mode, unsigned int flags,
3505 unsigned int rtscts_rate, unsigned int rtscts_duration)
3506 {
3507 u32 frame_type;
3508 struct ath5k_hw_2w_tx_desc *tx_desc;
3509 unsigned int buff_len;
3510
3511 tx_desc = (struct ath5k_hw_2w_tx_desc *)&desc->ds_ctl0;
3512
3513 /*
3514 * Validate input
3515 * - Zero retries don't make sense.
3516 * - A zero rate will put the HW into a mode where it continously sends
3517 * noise on the channel, so it is important to avoid this.
3518 */
3519 if (unlikely(tx_tries0 == 0)) {
3520 ATH5K_ERR(ah->ah_sc, "zero retries\n");
3521 WARN_ON(1);
3522 return -EINVAL;
3523 }
3524 if (unlikely(tx_rate0 == 0)) {
3525 ATH5K_ERR(ah->ah_sc, "zero rate\n");
3526 WARN_ON(1);
3527 return -EINVAL;
3528 }
3529
3530 /* Clear status descriptor */
3531 memset(desc->ds_hw, 0, sizeof(struct ath5k_hw_tx_status));
3532
3533 /* Initialize control descriptor */
3534 tx_desc->tx_control_0 = 0;
3535 tx_desc->tx_control_1 = 0;
3536
3537 /* Setup control descriptor */
3538
3539 /* Verify and set frame length */
3540 if (pkt_len & ~AR5K_2W_TX_DESC_CTL0_FRAME_LEN)
3541 return -EINVAL;
3542
3543 tx_desc->tx_control_0 = pkt_len & AR5K_2W_TX_DESC_CTL0_FRAME_LEN;
3544
3545 /* Verify and set buffer length */
3546 buff_len = pkt_len - FCS_LEN;
3547
3548 /* NB: beacon's BufLen must be a multiple of 4 bytes */
3549 if(type == AR5K_PKT_TYPE_BEACON)
3550 buff_len = roundup(buff_len, 4);
3551
3552 if (buff_len & ~AR5K_2W_TX_DESC_CTL1_BUF_LEN)
3553 return -EINVAL;
3554
3555 tx_desc->tx_control_1 = buff_len & AR5K_2W_TX_DESC_CTL1_BUF_LEN;
3556
3557 /*
3558 * Verify and set header length
3559 * XXX: I only found that on 5210 code, does it work on 5211 ?
3560 */
3561 if (ah->ah_version == AR5K_AR5210) {
3562 if (hdr_len & ~AR5K_2W_TX_DESC_CTL0_HEADER_LEN)
3563 return -EINVAL;
3564 tx_desc->tx_control_0 |=
3565 AR5K_REG_SM(hdr_len, AR5K_2W_TX_DESC_CTL0_HEADER_LEN);
3566 }
3567
3568 /*Diferences between 5210-5211*/
3569 if (ah->ah_version == AR5K_AR5210) {
3570 switch (type) {
3571 case AR5K_PKT_TYPE_BEACON:
3572 case AR5K_PKT_TYPE_PROBE_RESP:
3573 frame_type = AR5K_AR5210_TX_DESC_FRAME_TYPE_NO_DELAY;
3574 case AR5K_PKT_TYPE_PIFS:
3575 frame_type = AR5K_AR5210_TX_DESC_FRAME_TYPE_PIFS;
3576 default:
3577 frame_type = type /*<< 2 ?*/;
3578 }
3579
3580 tx_desc->tx_control_0 |=
3581 AR5K_REG_SM(frame_type, AR5K_2W_TX_DESC_CTL0_FRAME_TYPE) |
3582 AR5K_REG_SM(tx_rate0, AR5K_2W_TX_DESC_CTL0_XMIT_RATE);
3583 } else {
3584 tx_desc->tx_control_0 |=
3585 AR5K_REG_SM(tx_rate0, AR5K_2W_TX_DESC_CTL0_XMIT_RATE) |
3586 AR5K_REG_SM(antenna_mode, AR5K_2W_TX_DESC_CTL0_ANT_MODE_XMIT);
3587 tx_desc->tx_control_1 |=
3588 AR5K_REG_SM(type, AR5K_2W_TX_DESC_CTL1_FRAME_TYPE);
3589 }
3590 #define _TX_FLAGS(_c, _flag) \
3591 if (flags & AR5K_TXDESC_##_flag) \
3592 tx_desc->tx_control_##_c |= \
3593 AR5K_2W_TX_DESC_CTL##_c##_##_flag
3594
3595 _TX_FLAGS(0, CLRDMASK);
3596 _TX_FLAGS(0, VEOL);
3597 _TX_FLAGS(0, INTREQ);
3598 _TX_FLAGS(0, RTSENA);
3599 _TX_FLAGS(1, NOACK);
3600
3601 #undef _TX_FLAGS
3602
3603 /*
3604 * WEP crap
3605 */
3606 if (key_index != AR5K_TXKEYIX_INVALID) {
3607 tx_desc->tx_control_0 |=
3608 AR5K_2W_TX_DESC_CTL0_ENCRYPT_KEY_VALID;
3609 tx_desc->tx_control_1 |=
3610 AR5K_REG_SM(key_index,
3611 AR5K_2W_TX_DESC_CTL1_ENCRYPT_KEY_INDEX);
3612 }
3613
3614 /*
3615 * RTS/CTS Duration [5210 ?]
3616 */
3617 if ((ah->ah_version == AR5K_AR5210) &&
3618 (flags & (AR5K_TXDESC_RTSENA | AR5K_TXDESC_CTSENA)))
3619 tx_desc->tx_control_1 |= rtscts_duration &
3620 AR5K_2W_TX_DESC_CTL1_RTS_DURATION;
3621
3622 return 0;
3623 }
3624
3625 /*
3626 * Initialize the 4-word tx descriptor on 5212
3627 */
3628 static int ath5k_hw_setup_4word_tx_desc(struct ath5k_hw *ah,
3629 struct ath5k_desc *desc, unsigned int pkt_len, unsigned int hdr_len,
3630 enum ath5k_pkt_type type, unsigned int tx_power, unsigned int tx_rate0,
3631 unsigned int tx_tries0, unsigned int key_index,
3632 unsigned int antenna_mode, unsigned int flags, unsigned int rtscts_rate,
3633 unsigned int rtscts_duration)
3634 {
3635 struct ath5k_hw_4w_tx_desc *tx_desc;
3636 struct ath5k_hw_tx_status *tx_status;
3637 unsigned int buff_len;
3638
3639 ATH5K_TRACE(ah->ah_sc);
3640 tx_desc = (struct ath5k_hw_4w_tx_desc *)&desc->ds_ctl0;
3641 tx_status = (struct ath5k_hw_tx_status *)&desc->ds_hw[2];
3642
3643 /*
3644 * Validate input
3645 * - Zero retries don't make sense.
3646 * - A zero rate will put the HW into a mode where it continously sends
3647 * noise on the channel, so it is important to avoid this.
3648 */
3649 if (unlikely(tx_tries0 == 0)) {
3650 ATH5K_ERR(ah->ah_sc, "zero retries\n");
3651 WARN_ON(1);
3652 return -EINVAL;
3653 }
3654 if (unlikely(tx_rate0 == 0)) {
3655 ATH5K_ERR(ah->ah_sc, "zero rate\n");
3656 WARN_ON(1);
3657 return -EINVAL;
3658 }
3659
3660 /* Clear status descriptor */
3661 memset(tx_status, 0, sizeof(struct ath5k_hw_tx_status));
3662
3663 /* Initialize control descriptor */
3664 tx_desc->tx_control_0 = 0;
3665 tx_desc->tx_control_1 = 0;
3666 tx_desc->tx_control_2 = 0;
3667 tx_desc->tx_control_3 = 0;
3668
3669 /* Setup control descriptor */
3670
3671 /* Verify and set frame length */
3672 if (pkt_len & ~AR5K_4W_TX_DESC_CTL0_FRAME_LEN)
3673 return -EINVAL;
3674
3675 tx_desc->tx_control_0 = pkt_len & AR5K_4W_TX_DESC_CTL0_FRAME_LEN;
3676
3677 /* Verify and set buffer length */
3678 buff_len = pkt_len - FCS_LEN;
3679
3680 /* NB: beacon's BufLen must be a multiple of 4 bytes */
3681 if(type == AR5K_PKT_TYPE_BEACON)
3682 buff_len = roundup(buff_len, 4);
3683
3684 if (buff_len & ~AR5K_4W_TX_DESC_CTL1_BUF_LEN)
3685 return -EINVAL;
3686
3687 tx_desc->tx_control_1 = buff_len & AR5K_4W_TX_DESC_CTL1_BUF_LEN;
3688
3689 tx_desc->tx_control_0 |=
3690 AR5K_REG_SM(tx_power, AR5K_4W_TX_DESC_CTL0_XMIT_POWER) |
3691 AR5K_REG_SM(antenna_mode, AR5K_4W_TX_DESC_CTL0_ANT_MODE_XMIT);
3692 tx_desc->tx_control_1 |= AR5K_REG_SM(type,
3693 AR5K_4W_TX_DESC_CTL1_FRAME_TYPE);
3694 tx_desc->tx_control_2 = AR5K_REG_SM(tx_tries0 + AR5K_TUNE_HWTXTRIES,
3695 AR5K_4W_TX_DESC_CTL2_XMIT_TRIES0);
3696 tx_desc->tx_control_3 = tx_rate0 & AR5K_4W_TX_DESC_CTL3_XMIT_RATE0;
3697
3698 #define _TX_FLAGS(_c, _flag) \
3699 if (flags & AR5K_TXDESC_##_flag) \
3700 tx_desc->tx_control_##_c |= \
3701 AR5K_4W_TX_DESC_CTL##_c##_##_flag
3702
3703 _TX_FLAGS(0, CLRDMASK);
3704 _TX_FLAGS(0, VEOL);
3705 _TX_FLAGS(0, INTREQ);
3706 _TX_FLAGS(0, RTSENA);
3707 _TX_FLAGS(0, CTSENA);
3708 _TX_FLAGS(1, NOACK);
3709
3710 #undef _TX_FLAGS
3711
3712 /*
3713 * WEP crap
3714 */
3715 if (key_index != AR5K_TXKEYIX_INVALID) {
3716 tx_desc->tx_control_0 |= AR5K_4W_TX_DESC_CTL0_ENCRYPT_KEY_VALID;
3717 tx_desc->tx_control_1 |= AR5K_REG_SM(key_index,
3718 AR5K_4W_TX_DESC_CTL1_ENCRYPT_KEY_INDEX);
3719 }
3720
3721 /*
3722 * RTS/CTS
3723 */
3724 if (flags & (AR5K_TXDESC_RTSENA | AR5K_TXDESC_CTSENA)) {
3725 if ((flags & AR5K_TXDESC_RTSENA) &&
3726 (flags & AR5K_TXDESC_CTSENA))
3727 return -EINVAL;
3728 tx_desc->tx_control_2 |= rtscts_duration &
3729 AR5K_4W_TX_DESC_CTL2_RTS_DURATION;
3730 tx_desc->tx_control_3 |= AR5K_REG_SM(rtscts_rate,
3731 AR5K_4W_TX_DESC_CTL3_RTS_CTS_RATE);
3732 }
3733
3734 return 0;
3735 }
3736
3737 /*
3738 * Initialize a 4-word multirate tx descriptor on 5212
3739 */
3740 static bool
3741 ath5k_hw_setup_xr_tx_desc(struct ath5k_hw *ah, struct ath5k_desc *desc,
3742 unsigned int tx_rate1, u_int tx_tries1, u_int tx_rate2, u_int tx_tries2,
3743 unsigned int tx_rate3, u_int tx_tries3)
3744 {
3745 struct ath5k_hw_4w_tx_desc *tx_desc;
3746
3747 /*
3748 * Rates can be 0 as long as the retry count is 0 too.
3749 * A zero rate and nonzero retry count will put the HW into a mode where
3750 * it continously sends noise on the channel, so it is important to
3751 * avoid this.
3752 */
3753 if (unlikely((tx_rate1 == 0 && tx_tries1 != 0) ||
3754 (tx_rate2 == 0 && tx_tries2 != 0) ||
3755 (tx_rate3 == 0 && tx_tries3 != 0))) {
3756 ATH5K_ERR(ah->ah_sc, "zero rate\n");
3757 WARN_ON(1);
3758 return -EINVAL;
3759 }
3760
3761 if (ah->ah_version == AR5K_AR5212) {
3762 tx_desc = (struct ath5k_hw_4w_tx_desc *)&desc->ds_ctl0;
3763
3764 #define _XTX_TRIES(_n) \
3765 if (tx_tries##_n) { \
3766 tx_desc->tx_control_2 |= \
3767 AR5K_REG_SM(tx_tries##_n, \
3768 AR5K_4W_TX_DESC_CTL2_XMIT_TRIES##_n); \
3769 tx_desc->tx_control_3 |= \
3770 AR5K_REG_SM(tx_rate##_n, \
3771 AR5K_4W_TX_DESC_CTL3_XMIT_RATE##_n); \
3772 }
3773
3774 _XTX_TRIES(1);
3775 _XTX_TRIES(2);
3776 _XTX_TRIES(3);
3777
3778 #undef _XTX_TRIES
3779
3780 return true;
3781 }
3782
3783 return false;
3784 }
3785
3786 /*
3787 * Proccess the tx status descriptor on 5210/5211
3788 */
3789 static int ath5k_hw_proc_2word_tx_status(struct ath5k_hw *ah,
3790 struct ath5k_desc *desc)
3791 {
3792 struct ath5k_hw_tx_status *tx_status;
3793 struct ath5k_hw_2w_tx_desc *tx_desc;
3794
3795 tx_desc = (struct ath5k_hw_2w_tx_desc *)&desc->ds_ctl0;
3796 tx_status = (struct ath5k_hw_tx_status *)&desc->ds_hw[0];
3797
3798 /* No frame has been send or error */
3799 if (unlikely((tx_status->tx_status_1 & AR5K_DESC_TX_STATUS1_DONE) == 0))
3800 return -EINPROGRESS;
3801
3802 /*
3803 * Get descriptor status
3804 */
3805 desc->ds_us.tx.ts_tstamp = AR5K_REG_MS(tx_status->tx_status_0,
3806 AR5K_DESC_TX_STATUS0_SEND_TIMESTAMP);
3807 desc->ds_us.tx.ts_shortretry = AR5K_REG_MS(tx_status->tx_status_0,
3808 AR5K_DESC_TX_STATUS0_SHORT_RETRY_COUNT);
3809 desc->ds_us.tx.ts_longretry = AR5K_REG_MS(tx_status->tx_status_0,
3810 AR5K_DESC_TX_STATUS0_LONG_RETRY_COUNT);
3811 /*TODO: desc->ds_us.tx.ts_virtcol + test*/
3812 desc->ds_us.tx.ts_seqnum = AR5K_REG_MS(tx_status->tx_status_1,
3813 AR5K_DESC_TX_STATUS1_SEQ_NUM);
3814 desc->ds_us.tx.ts_rssi = AR5K_REG_MS(tx_status->tx_status_1,
3815 AR5K_DESC_TX_STATUS1_ACK_SIG_STRENGTH);
3816 desc->ds_us.tx.ts_antenna = 1;
3817 desc->ds_us.tx.ts_status = 0;
3818 desc->ds_us.tx.ts_rate = AR5K_REG_MS(tx_desc->tx_control_0,
3819 AR5K_2W_TX_DESC_CTL0_XMIT_RATE);
3820
3821 if ((tx_status->tx_status_0 & AR5K_DESC_TX_STATUS0_FRAME_XMIT_OK) == 0){
3822 if (tx_status->tx_status_0 &
3823 AR5K_DESC_TX_STATUS0_EXCESSIVE_RETRIES)
3824 desc->ds_us.tx.ts_status |= AR5K_TXERR_XRETRY;
3825
3826 if (tx_status->tx_status_0 & AR5K_DESC_TX_STATUS0_FIFO_UNDERRUN)
3827 desc->ds_us.tx.ts_status |= AR5K_TXERR_FIFO;
3828
3829 if (tx_status->tx_status_0 & AR5K_DESC_TX_STATUS0_FILTERED)
3830 desc->ds_us.tx.ts_status |= AR5K_TXERR_FILT;
3831 }
3832
3833 return 0;
3834 }
3835
3836 /*
3837 * Proccess a tx descriptor on 5212
3838 */
3839 static int ath5k_hw_proc_4word_tx_status(struct ath5k_hw *ah,
3840 struct ath5k_desc *desc)
3841 {
3842 struct ath5k_hw_tx_status *tx_status;
3843 struct ath5k_hw_4w_tx_desc *tx_desc;
3844
3845 ATH5K_TRACE(ah->ah_sc);
3846 tx_desc = (struct ath5k_hw_4w_tx_desc *)&desc->ds_ctl0;
3847 tx_status = (struct ath5k_hw_tx_status *)&desc->ds_hw[2];
3848
3849 /* No frame has been send or error */
3850 if (unlikely((tx_status->tx_status_1 & AR5K_DESC_TX_STATUS1_DONE) == 0))
3851 return -EINPROGRESS;
3852
3853 /*
3854 * Get descriptor status
3855 */
3856 desc->ds_us.tx.ts_tstamp = AR5K_REG_MS(tx_status->tx_status_0,
3857 AR5K_DESC_TX_STATUS0_SEND_TIMESTAMP);
3858 desc->ds_us.tx.ts_shortretry = AR5K_REG_MS(tx_status->tx_status_0,
3859 AR5K_DESC_TX_STATUS0_SHORT_RETRY_COUNT);
3860 desc->ds_us.tx.ts_longretry = AR5K_REG_MS(tx_status->tx_status_0,
3861 AR5K_DESC_TX_STATUS0_LONG_RETRY_COUNT);
3862 desc->ds_us.tx.ts_seqnum = AR5K_REG_MS(tx_status->tx_status_1,
3863 AR5K_DESC_TX_STATUS1_SEQ_NUM);
3864 desc->ds_us.tx.ts_rssi = AR5K_REG_MS(tx_status->tx_status_1,
3865 AR5K_DESC_TX_STATUS1_ACK_SIG_STRENGTH);
3866 desc->ds_us.tx.ts_antenna = (tx_status->tx_status_1 &
3867 AR5K_DESC_TX_STATUS1_XMIT_ANTENNA) ? 2 : 1;
3868 desc->ds_us.tx.ts_status = 0;
3869
3870 switch (AR5K_REG_MS(tx_status->tx_status_1,
3871 AR5K_DESC_TX_STATUS1_FINAL_TS_INDEX)) {
3872 case 0:
3873 desc->ds_us.tx.ts_rate = tx_desc->tx_control_3 &
3874 AR5K_4W_TX_DESC_CTL3_XMIT_RATE0;
3875 break;
3876 case 1:
3877 desc->ds_us.tx.ts_rate = AR5K_REG_MS(tx_desc->tx_control_3,
3878 AR5K_4W_TX_DESC_CTL3_XMIT_RATE1);
3879 desc->ds_us.tx.ts_longretry +=AR5K_REG_MS(tx_desc->tx_control_2,
3880 AR5K_4W_TX_DESC_CTL2_XMIT_TRIES1);
3881 break;
3882 case 2:
3883 desc->ds_us.tx.ts_rate = AR5K_REG_MS(tx_desc->tx_control_3,
3884 AR5K_4W_TX_DESC_CTL3_XMIT_RATE2);
3885 desc->ds_us.tx.ts_longretry +=AR5K_REG_MS(tx_desc->tx_control_2,
3886 AR5K_4W_TX_DESC_CTL2_XMIT_TRIES2);
3887 break;
3888 case 3:
3889 desc->ds_us.tx.ts_rate = AR5K_REG_MS(tx_desc->tx_control_3,
3890 AR5K_4W_TX_DESC_CTL3_XMIT_RATE3);
3891 desc->ds_us.tx.ts_longretry +=AR5K_REG_MS(tx_desc->tx_control_2,
3892 AR5K_4W_TX_DESC_CTL2_XMIT_TRIES3);
3893 break;
3894 }
3895
3896 if ((tx_status->tx_status_0 & AR5K_DESC_TX_STATUS0_FRAME_XMIT_OK) == 0){
3897 if (tx_status->tx_status_0 &
3898 AR5K_DESC_TX_STATUS0_EXCESSIVE_RETRIES)
3899 desc->ds_us.tx.ts_status |= AR5K_TXERR_XRETRY;
3900
3901 if (tx_status->tx_status_0 & AR5K_DESC_TX_STATUS0_FIFO_UNDERRUN)
3902 desc->ds_us.tx.ts_status |= AR5K_TXERR_FIFO;
3903
3904 if (tx_status->tx_status_0 & AR5K_DESC_TX_STATUS0_FILTERED)
3905 desc->ds_us.tx.ts_status |= AR5K_TXERR_FILT;
3906 }
3907
3908 return 0;
3909 }
3910
3911 /*
3912 * RX Descriptor
3913 */
3914
3915 /*
3916 * Initialize an rx descriptor
3917 */
3918 int ath5k_hw_setup_rx_desc(struct ath5k_hw *ah, struct ath5k_desc *desc,
3919 u32 size, unsigned int flags)
3920 {
3921 struct ath5k_rx_desc *rx_desc;
3922
3923 ATH5K_TRACE(ah->ah_sc);
3924 rx_desc = (struct ath5k_rx_desc *)&desc->ds_ctl0;
3925
3926 /*
3927 *Clear ds_hw
3928 * If we don't clean the status descriptor,
3929 * while scanning we get too many results,
3930 * most of them virtual, after some secs
3931 * of scanning system hangs. M.F.
3932 */
3933 memset(desc->ds_hw, 0, sizeof(desc->ds_hw));
3934
3935 /*Initialize rx descriptor*/
3936 rx_desc->rx_control_0 = 0;
3937 rx_desc->rx_control_1 = 0;
3938
3939 /* Setup descriptor */
3940 rx_desc->rx_control_1 = size & AR5K_DESC_RX_CTL1_BUF_LEN;
3941 if (unlikely(rx_desc->rx_control_1 != size))
3942 return -EINVAL;
3943
3944 if (flags & AR5K_RXDESC_INTREQ)
3945 rx_desc->rx_control_1 |= AR5K_DESC_RX_CTL1_INTREQ;
3946
3947 return 0;
3948 }
3949
3950 /*
3951 * Proccess the rx status descriptor on 5210/5211
3952 */
3953 static int ath5k_hw_proc_old_rx_status(struct ath5k_hw *ah,
3954 struct ath5k_desc *desc)
3955 {
3956 struct ath5k_hw_old_rx_status *rx_status;
3957
3958 rx_status = (struct ath5k_hw_old_rx_status *)&desc->ds_hw[0];
3959
3960 /* No frame received / not ready */
3961 if (unlikely((rx_status->rx_status_1 & AR5K_OLD_RX_DESC_STATUS1_DONE)
3962 == 0))
3963 return -EINPROGRESS;
3964
3965 /*
3966 * Frame receive status
3967 */
3968 desc->ds_us.rx.rs_datalen = rx_status->rx_status_0 &
3969 AR5K_OLD_RX_DESC_STATUS0_DATA_LEN;
3970 desc->ds_us.rx.rs_rssi = AR5K_REG_MS(rx_status->rx_status_0,
3971 AR5K_OLD_RX_DESC_STATUS0_RECEIVE_SIGNAL);
3972 desc->ds_us.rx.rs_rate = AR5K_REG_MS(rx_status->rx_status_0,
3973 AR5K_OLD_RX_DESC_STATUS0_RECEIVE_RATE);
3974 desc->ds_us.rx.rs_antenna = rx_status->rx_status_0 &
3975 AR5K_OLD_RX_DESC_STATUS0_RECEIVE_ANTENNA;
3976 desc->ds_us.rx.rs_more = rx_status->rx_status_0 &
3977 AR5K_OLD_RX_DESC_STATUS0_MORE;
3978 desc->ds_us.rx.rs_tstamp = AR5K_REG_MS(rx_status->rx_status_1,
3979 AR5K_OLD_RX_DESC_STATUS1_RECEIVE_TIMESTAMP);
3980 desc->ds_us.rx.rs_status = 0;
3981
3982 /*
3983 * Key table status
3984 */
3985 if (rx_status->rx_status_1 & AR5K_OLD_RX_DESC_STATUS1_KEY_INDEX_VALID)
3986 desc->ds_us.rx.rs_keyix = AR5K_REG_MS(rx_status->rx_status_1,
3987 AR5K_OLD_RX_DESC_STATUS1_KEY_INDEX);
3988 else
3989 desc->ds_us.rx.rs_keyix = AR5K_RXKEYIX_INVALID;
3990
3991 /*
3992 * Receive/descriptor errors
3993 */
3994 if ((rx_status->rx_status_1 & AR5K_OLD_RX_DESC_STATUS1_FRAME_RECEIVE_OK)
3995 == 0) {
3996 if (rx_status->rx_status_1 & AR5K_OLD_RX_DESC_STATUS1_CRC_ERROR)
3997 desc->ds_us.rx.rs_status |= AR5K_RXERR_CRC;
3998
3999 if (rx_status->rx_status_1 &
4000 AR5K_OLD_RX_DESC_STATUS1_FIFO_OVERRUN)
4001 desc->ds_us.rx.rs_status |= AR5K_RXERR_FIFO;
4002
4003 if (rx_status->rx_status_1 &
4004 AR5K_OLD_RX_DESC_STATUS1_PHY_ERROR) {
4005 desc->ds_us.rx.rs_status |= AR5K_RXERR_PHY;
4006 desc->ds_us.rx.rs_phyerr =
4007 AR5K_REG_MS(rx_status->rx_status_1,
4008 AR5K_OLD_RX_DESC_STATUS1_PHY_ERROR);
4009 }
4010
4011 if (rx_status->rx_status_1 &
4012 AR5K_OLD_RX_DESC_STATUS1_DECRYPT_CRC_ERROR)
4013 desc->ds_us.rx.rs_status |= AR5K_RXERR_DECRYPT;
4014 }
4015
4016 return 0;
4017 }
4018
4019 /*
4020 * Proccess the rx status descriptor on 5212
4021 */
4022 static int ath5k_hw_proc_new_rx_status(struct ath5k_hw *ah,
4023 struct ath5k_desc *desc)
4024 {
4025 struct ath5k_hw_new_rx_status *rx_status;
4026 struct ath5k_hw_rx_error *rx_err;
4027
4028 ATH5K_TRACE(ah->ah_sc);
4029 rx_status = (struct ath5k_hw_new_rx_status *)&desc->ds_hw[0];
4030
4031 /* Overlay on error */
4032 rx_err = (struct ath5k_hw_rx_error *)&desc->ds_hw[0];
4033
4034 /* No frame received / not ready */
4035 if (unlikely((rx_status->rx_status_1 & AR5K_NEW_RX_DESC_STATUS1_DONE)
4036 == 0))
4037 return -EINPROGRESS;
4038
4039 /*
4040 * Frame receive status
4041 */
4042 desc->ds_us.rx.rs_datalen = rx_status->rx_status_0 &
4043 AR5K_NEW_RX_DESC_STATUS0_DATA_LEN;
4044 desc->ds_us.rx.rs_rssi = AR5K_REG_MS(rx_status->rx_status_0,
4045 AR5K_NEW_RX_DESC_STATUS0_RECEIVE_SIGNAL);
4046 desc->ds_us.rx.rs_rate = AR5K_REG_MS(rx_status->rx_status_0,
4047 AR5K_NEW_RX_DESC_STATUS0_RECEIVE_RATE);
4048 desc->ds_us.rx.rs_antenna = rx_status->rx_status_0 &
4049 AR5K_NEW_RX_DESC_STATUS0_RECEIVE_ANTENNA;
4050 desc->ds_us.rx.rs_more = rx_status->rx_status_0 &
4051 AR5K_NEW_RX_DESC_STATUS0_MORE;
4052 desc->ds_us.rx.rs_tstamp = AR5K_REG_MS(rx_status->rx_status_1,
4053 AR5K_NEW_RX_DESC_STATUS1_RECEIVE_TIMESTAMP);
4054 desc->ds_us.rx.rs_status = 0;
4055
4056 /*
4057 * Key table status
4058 */
4059 if (rx_status->rx_status_1 & AR5K_NEW_RX_DESC_STATUS1_KEY_INDEX_VALID)
4060 desc->ds_us.rx.rs_keyix = AR5K_REG_MS(rx_status->rx_status_1,
4061 AR5K_NEW_RX_DESC_STATUS1_KEY_INDEX);
4062 else
4063 desc->ds_us.rx.rs_keyix = AR5K_RXKEYIX_INVALID;
4064
4065 /*
4066 * Receive/descriptor errors
4067 */
4068 if ((rx_status->rx_status_1 &
4069 AR5K_NEW_RX_DESC_STATUS1_FRAME_RECEIVE_OK) == 0) {
4070 if (rx_status->rx_status_1 & AR5K_NEW_RX_DESC_STATUS1_CRC_ERROR)
4071 desc->ds_us.rx.rs_status |= AR5K_RXERR_CRC;
4072
4073 if (rx_status->rx_status_1 &
4074 AR5K_NEW_RX_DESC_STATUS1_PHY_ERROR) {
4075 desc->ds_us.rx.rs_status |= AR5K_RXERR_PHY;
4076 desc->ds_us.rx.rs_phyerr =
4077 AR5K_REG_MS(rx_err->rx_error_1,
4078 AR5K_RX_DESC_ERROR1_PHY_ERROR_CODE);
4079 }
4080
4081 if (rx_status->rx_status_1 &
4082 AR5K_NEW_RX_DESC_STATUS1_DECRYPT_CRC_ERROR)
4083 desc->ds_us.rx.rs_status |= AR5K_RXERR_DECRYPT;
4084
4085 if (rx_status->rx_status_1 & AR5K_NEW_RX_DESC_STATUS1_MIC_ERROR)
4086 desc->ds_us.rx.rs_status |= AR5K_RXERR_MIC;
4087 }
4088
4089 return 0;
4090 }
4091
4092
4093 /****************\
4094 GPIO Functions
4095 \****************/
4096
4097 /*
4098 * Set led state
4099 */
4100 void ath5k_hw_set_ledstate(struct ath5k_hw *ah, unsigned int state)
4101 {
4102 u32 led;
4103 /*5210 has different led mode handling*/
4104 u32 led_5210;
4105
4106 ATH5K_TRACE(ah->ah_sc);
4107
4108 /*Reset led status*/
4109 if (ah->ah_version != AR5K_AR5210)
4110 AR5K_REG_DISABLE_BITS(ah, AR5K_PCICFG,
4111 AR5K_PCICFG_LEDMODE | AR5K_PCICFG_LED);
4112 else
4113 AR5K_REG_DISABLE_BITS(ah, AR5K_PCICFG, AR5K_PCICFG_LED);
4114
4115 /*
4116 * Some blinking values, define at your wish
4117 */
4118 switch (state) {
4119 case AR5K_LED_SCAN:
4120 case AR5K_LED_AUTH:
4121 led = AR5K_PCICFG_LEDMODE_PROP | AR5K_PCICFG_LED_PEND;
4122 led_5210 = AR5K_PCICFG_LED_PEND | AR5K_PCICFG_LED_BCTL;
4123 break;
4124
4125 case AR5K_LED_INIT:
4126 led = AR5K_PCICFG_LEDMODE_PROP | AR5K_PCICFG_LED_NONE;
4127 led_5210 = AR5K_PCICFG_LED_PEND;
4128 break;
4129
4130 case AR5K_LED_ASSOC:
4131 case AR5K_LED_RUN:
4132 led = AR5K_PCICFG_LEDMODE_PROP | AR5K_PCICFG_LED_ASSOC;
4133 led_5210 = AR5K_PCICFG_LED_ASSOC;
4134 break;
4135
4136 default:
4137 led = AR5K_PCICFG_LEDMODE_PROM | AR5K_PCICFG_LED_NONE;
4138 led_5210 = AR5K_PCICFG_LED_PEND;
4139 break;
4140 }
4141
4142 /*Write new status to the register*/
4143 if (ah->ah_version != AR5K_AR5210)
4144 AR5K_REG_ENABLE_BITS(ah, AR5K_PCICFG, led);
4145 else
4146 AR5K_REG_ENABLE_BITS(ah, AR5K_PCICFG, led_5210);
4147 }
4148
4149 /*
4150 * Set GPIO outputs
4151 */
4152 int ath5k_hw_set_gpio_output(struct ath5k_hw *ah, u32 gpio)
4153 {
4154 ATH5K_TRACE(ah->ah_sc);
4155 if (gpio > AR5K_NUM_GPIO)
4156 return -EINVAL;
4157
4158 ath5k_hw_reg_write(ah, (ath5k_hw_reg_read(ah, AR5K_GPIOCR) &~
4159 AR5K_GPIOCR_OUT(gpio)) | AR5K_GPIOCR_OUT(gpio), AR5K_GPIOCR);
4160
4161 return 0;
4162 }
4163
4164 /*
4165 * Set GPIO inputs
4166 */
4167 int ath5k_hw_set_gpio_input(struct ath5k_hw *ah, u32 gpio)
4168 {
4169 ATH5K_TRACE(ah->ah_sc);
4170 if (gpio > AR5K_NUM_GPIO)
4171 return -EINVAL;
4172
4173 ath5k_hw_reg_write(ah, (ath5k_hw_reg_read(ah, AR5K_GPIOCR) &~
4174 AR5K_GPIOCR_OUT(gpio)) | AR5K_GPIOCR_IN(gpio), AR5K_GPIOCR);
4175
4176 return 0;
4177 }
4178
4179 /*
4180 * Get GPIO state
4181 */
4182 u32 ath5k_hw_get_gpio(struct ath5k_hw *ah, u32 gpio)
4183 {
4184 ATH5K_TRACE(ah->ah_sc);
4185 if (gpio > AR5K_NUM_GPIO)
4186 return 0xffffffff;
4187
4188 /* GPIO input magic */
4189 return ((ath5k_hw_reg_read(ah, AR5K_GPIODI) & AR5K_GPIODI_M) >> gpio) &
4190 0x1;
4191 }
4192
4193 /*
4194 * Set GPIO state
4195 */
4196 int ath5k_hw_set_gpio(struct ath5k_hw *ah, u32 gpio, u32 val)
4197 {
4198 u32 data;
4199 ATH5K_TRACE(ah->ah_sc);
4200
4201 if (gpio > AR5K_NUM_GPIO)
4202 return -EINVAL;
4203
4204 /* GPIO output magic */
4205 data = ath5k_hw_reg_read(ah, AR5K_GPIODO);
4206
4207 data &= ~(1 << gpio);
4208 data |= (val & 1) << gpio;
4209
4210 ath5k_hw_reg_write(ah, data, AR5K_GPIODO);
4211
4212 return 0;
4213 }
4214
4215 /*
4216 * Initialize the GPIO interrupt (RFKill switch)
4217 */
4218 void ath5k_hw_set_gpio_intr(struct ath5k_hw *ah, unsigned int gpio,
4219 u32 interrupt_level)
4220 {
4221 u32 data;
4222
4223 ATH5K_TRACE(ah->ah_sc);
4224 if (gpio > AR5K_NUM_GPIO)
4225 return;
4226
4227 /*
4228 * Set the GPIO interrupt
4229 */
4230 data = (ath5k_hw_reg_read(ah, AR5K_GPIOCR) &
4231 ~(AR5K_GPIOCR_INT_SEL(gpio) | AR5K_GPIOCR_INT_SELH |
4232 AR5K_GPIOCR_INT_ENA | AR5K_GPIOCR_OUT(gpio))) |
4233 (AR5K_GPIOCR_INT_SEL(gpio) | AR5K_GPIOCR_INT_ENA);
4234
4235 ath5k_hw_reg_write(ah, interrupt_level ? data :
4236 (data | AR5K_GPIOCR_INT_SELH), AR5K_GPIOCR);
4237
4238 ah->ah_imr |= AR5K_IMR_GPIO;
4239
4240 /* Enable GPIO interrupts */
4241 AR5K_REG_ENABLE_BITS(ah, AR5K_PIMR, AR5K_IMR_GPIO);
4242 }
4243
4244
4245 /*********************************\
4246 Regulatory Domain/Channels Setup
4247 \*********************************/
4248
4249 u16 ath5k_get_regdomain(struct ath5k_hw *ah)
4250 {
4251 u16 regdomain;
4252 enum ath5k_regdom ieee_regdomain;
4253 #ifdef COUNTRYCODE
4254 u16 code;
4255 #endif
4256
4257 ath5k_eeprom_regulation_domain(ah, false, &ieee_regdomain);
4258 ah->ah_capabilities.cap_regdomain.reg_hw = ieee_regdomain;
4259
4260 #ifdef COUNTRYCODE
4261 /*
4262 * Get the regulation domain by country code. This will ignore
4263 * the settings found in the EEPROM.
4264 */
4265 code = ieee80211_name2countrycode(COUNTRYCODE);
4266 ieee_regdomain = ieee80211_countrycode2regdomain(code);
4267 #endif
4268
4269 regdomain = ath5k_regdom_from_ieee(ieee_regdomain);
4270 ah->ah_capabilities.cap_regdomain.reg_current = regdomain;
4271
4272 return regdomain;
4273 }
4274
4275
4276 /****************\
4277 Misc functions
4278 \****************/
4279
4280 int ath5k_hw_get_capability(struct ath5k_hw *ah,
4281 enum ath5k_capability_type cap_type,
4282 u32 capability, u32 *result)
4283 {
4284 ATH5K_TRACE(ah->ah_sc);
4285
4286 switch (cap_type) {
4287 case AR5K_CAP_NUM_TXQUEUES:
4288 if (result) {
4289 if (ah->ah_version == AR5K_AR5210)
4290 *result = AR5K_NUM_TX_QUEUES_NOQCU;
4291 else
4292 *result = AR5K_NUM_TX_QUEUES;
4293 goto yes;
4294 }
4295 case AR5K_CAP_VEOL:
4296 goto yes;
4297 case AR5K_CAP_COMPRESSION:
4298 if (ah->ah_version == AR5K_AR5212)
4299 goto yes;
4300 else
4301 goto no;
4302 case AR5K_CAP_BURST:
4303 goto yes;
4304 case AR5K_CAP_TPC:
4305 goto yes;
4306 case AR5K_CAP_BSSIDMASK:
4307 if (ah->ah_version == AR5K_AR5212)
4308 goto yes;
4309 else
4310 goto no;
4311 case AR5K_CAP_XR:
4312 if (ah->ah_version == AR5K_AR5212)
4313 goto yes;
4314 else
4315 goto no;
4316 default:
4317 goto no;
4318 }
4319
4320 no:
4321 return -EINVAL;
4322 yes:
4323 return 0;
4324 }
4325
4326 static int ath5k_hw_enable_pspoll(struct ath5k_hw *ah, u8 *bssid,
4327 u16 assoc_id)
4328 {
4329 ATH5K_TRACE(ah->ah_sc);
4330
4331 if (ah->ah_version == AR5K_AR5210) {
4332 AR5K_REG_DISABLE_BITS(ah, AR5K_STA_ID1,
4333 AR5K_STA_ID1_NO_PSPOLL | AR5K_STA_ID1_DEFAULT_ANTENNA);
4334 return 0;
4335 }
4336
4337 return -EIO;
4338 }
4339
4340 static int ath5k_hw_disable_pspoll(struct ath5k_hw *ah)
4341 {
4342 ATH5K_TRACE(ah->ah_sc);
4343
4344 if (ah->ah_version == AR5K_AR5210) {
4345 AR5K_REG_ENABLE_BITS(ah, AR5K_STA_ID1,
4346 AR5K_STA_ID1_NO_PSPOLL | AR5K_STA_ID1_DEFAULT_ANTENNA);
4347 return 0;
4348 }
4349
4350 return -EIO;
4351 }
WRT350N Kernel Patches