Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
reset.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2004-2008 Reyk Floeter <[email protected]>
3  * Copyright (c) 2006-2008 Nick Kossifidis <[email protected]>
4  * Copyright (c) 2007-2008 Luis Rodriguez <[email protected]>
5  * Copyright (c) 2007-2008 Pavel Roskin <[email protected]>
6  * Copyright (c) 2007-2008 Jiri Slaby <[email protected]>
7  *
8  * Permission to use, copy, modify, and distribute this software for any
9  * purpose with or without fee is hereby granted, provided that the above
10  * copyright notice and this permission notice appear in all copies.
11  *
12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19  *
20  */
21 
22 /****************************\
23  Reset function and helpers
24 \****************************/
25 
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27 
28 #include <asm/unaligned.h>
29 
30 #include <linux/pci.h> /* To determine if a card is pci-e */
31 #include <linux/log2.h>
32 #include <linux/platform_device.h>
33 #include "ath5k.h"
34 #include "reg.h"
35 #include "debug.h"
36 
37 
47 /******************\
48 * Helper functions *
49 \******************/
50 
66 int
68  bool is_set)
69 {
70  int i;
71  u32 data;
72 
73  for (i = AR5K_TUNE_REGISTER_TIMEOUT; i > 0; i--) {
74  data = ath5k_hw_reg_read(ah, reg);
75  if (is_set && (data & flag))
76  break;
77  else if ((data & flag) == val)
78  break;
79  udelay(15);
80  }
81 
82  return (i <= 0) ? -EAGAIN : 0;
83 }
84 
85 
86 /*************************\
87 * Clock related functions *
88 \*************************/
89 
100 unsigned int
101 ath5k_hw_htoclock(struct ath5k_hw *ah, unsigned int usec)
102 {
103  struct ath_common *common = ath5k_hw_common(ah);
104  return usec * common->clockrate;
105 }
106 
117 unsigned int
118 ath5k_hw_clocktoh(struct ath5k_hw *ah, unsigned int clock)
119 {
120  struct ath_common *common = ath5k_hw_common(ah);
121  return clock / common->clockrate;
122 }
123 
131 static void
132 ath5k_hw_init_core_clock(struct ath5k_hw *ah)
133 {
135  struct ath_common *common = ath5k_hw_common(ah);
136  u32 usec_reg, txlat, rxlat, usec, clock, sclock, txf2txs;
137 
138  /*
139  * Set core clock frequency
140  */
141  switch (channel->hw_value) {
142  case AR5K_MODE_11A:
143  clock = 40;
144  break;
145  case AR5K_MODE_11B:
146  clock = 22;
147  break;
148  case AR5K_MODE_11G:
149  default:
150  clock = 44;
151  break;
152  }
153 
154  /* Use clock multiplier for non-default
155  * bwmode */
156  switch (ah->ah_bwmode) {
157  case AR5K_BWMODE_40MHZ:
158  clock *= 2;
159  break;
160  case AR5K_BWMODE_10MHZ:
161  clock /= 2;
162  break;
163  case AR5K_BWMODE_5MHZ:
164  clock /= 4;
165  break;
166  default:
167  break;
168  }
169 
170  common->clockrate = clock;
171 
172  /*
173  * Set USEC parameters
174  */
175  /* Set USEC counter on PCU*/
176  usec = clock - 1;
177  usec = AR5K_REG_SM(usec, AR5K_USEC_1);
178 
179  /* Set usec duration on DCU */
180  if (ah->ah_version != AR5K_AR5210)
183  clock);
184 
185  /* Set 32MHz USEC counter */
186  if ((ah->ah_radio == AR5K_RF5112) ||
187  (ah->ah_radio == AR5K_RF2413) ||
188  (ah->ah_radio == AR5K_RF5413) ||
189  (ah->ah_radio == AR5K_RF2316) ||
190  (ah->ah_radio == AR5K_RF2317))
191  /* Remain on 40MHz clock ? */
192  sclock = 40 - 1;
193  else
194  sclock = 32 - 1;
195  sclock = AR5K_REG_SM(sclock, AR5K_USEC_32);
196 
197  /*
198  * Set tx/rx latencies
199  */
200  usec_reg = ath5k_hw_reg_read(ah, AR5K_USEC_5211);
201  txlat = AR5K_REG_MS(usec_reg, AR5K_USEC_TX_LATENCY_5211);
202  rxlat = AR5K_REG_MS(usec_reg, AR5K_USEC_RX_LATENCY_5211);
203 
204  /*
205  * Set default Tx frame to Tx data start delay
206  */
208 
209  /*
210  * 5210 initvals don't include usec settings
211  * so we need to use magic values here for
212  * tx/rx latencies
213  */
214  if (ah->ah_version == AR5K_AR5210) {
215  /* same for turbo */
218  }
219 
220  if (ah->ah_mac_srev < AR5K_SREV_AR5211) {
221  /* 5311 has different tx/rx latency masks
222  * from 5211, since we deal 5311 the same
223  * as 5211 when setting initvals, shift
224  * values here to their proper locations
225  *
226  * Note: Initvals indicate tx/rx/ latencies
227  * are the same for turbo mode */
228  txlat = AR5K_REG_SM(txlat, AR5K_USEC_TX_LATENCY_5210);
229  rxlat = AR5K_REG_SM(rxlat, AR5K_USEC_RX_LATENCY_5210);
230  } else
231  switch (ah->ah_bwmode) {
232  case AR5K_BWMODE_10MHZ:
233  txlat = AR5K_REG_SM(txlat * 2,
238  break;
239  case AR5K_BWMODE_5MHZ:
240  txlat = AR5K_REG_SM(txlat * 4,
245  break;
246  case AR5K_BWMODE_40MHZ:
247  txlat = AR5K_INIT_TX_LAT_MIN;
248  rxlat = AR5K_REG_SM(rxlat / 2,
251  break;
252  default:
253  break;
254  }
255 
256  usec_reg = (usec | sclock | txlat | rxlat);
257  ath5k_hw_reg_write(ah, usec_reg, AR5K_USEC);
258 
259  /* On 5112 set tx frame to tx data start delay */
260  if (ah->ah_radio == AR5K_RF5112) {
263  txf2txs);
264  }
265 }
266 
280 static void
281 ath5k_hw_set_sleep_clock(struct ath5k_hw *ah, bool enable)
282 {
283  struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
284  u32 scal, spending, sclock;
285 
286  /* Only set 32KHz settings if we have an external
287  * 32KHz crystal present */
290  enable) {
291 
292  /* 1 usec/cycle */
294  /* Set up tsf increment on each cycle */
296 
297  /* Set baseband sleep control registers
298  * and sleep control rate */
299  ath5k_hw_reg_write(ah, 0x1f, AR5K_PHY_SCR);
300 
301  if ((ah->ah_radio == AR5K_RF5112) ||
302  (ah->ah_radio == AR5K_RF5413) ||
303  (ah->ah_radio == AR5K_RF2316) ||
304  (ah->ah_mac_version == (AR5K_SREV_AR2417 >> 4)))
305  spending = 0x14;
306  else
307  spending = 0x18;
308  ath5k_hw_reg_write(ah, spending, AR5K_PHY_SPENDING);
309 
310  if ((ah->ah_radio == AR5K_RF5112) ||
311  (ah->ah_radio == AR5K_RF5413) ||
312  (ah->ah_mac_version == (AR5K_SREV_AR2417 >> 4))) {
313  ath5k_hw_reg_write(ah, 0x26, AR5K_PHY_SLMT);
314  ath5k_hw_reg_write(ah, 0x0d, AR5K_PHY_SCAL);
315  ath5k_hw_reg_write(ah, 0x07, AR5K_PHY_SCLOCK);
316  ath5k_hw_reg_write(ah, 0x3f, AR5K_PHY_SDELAY);
319  } else {
320  ath5k_hw_reg_write(ah, 0x0a, AR5K_PHY_SLMT);
321  ath5k_hw_reg_write(ah, 0x0c, AR5K_PHY_SCAL);
322  ath5k_hw_reg_write(ah, 0x03, AR5K_PHY_SCLOCK);
323  ath5k_hw_reg_write(ah, 0x20, AR5K_PHY_SDELAY);
326  }
327 
328  /* Enable sleep clock operation */
331 
332  } else {
333 
334  /* Disable sleep clock operation and
335  * restore default parameters */
338 
341 
342  /* Set DAC/ADC delays */
343  ath5k_hw_reg_write(ah, 0x1f, AR5K_PHY_SCR);
344  ath5k_hw_reg_write(ah, AR5K_PHY_SLMT_32MHZ, AR5K_PHY_SLMT);
345 
346  if (ah->ah_mac_version == (AR5K_SREV_AR2417 >> 4))
348  else if (ee->ee_is_hb63)
350  else
351  scal = AR5K_PHY_SCAL_32MHZ;
352  ath5k_hw_reg_write(ah, scal, AR5K_PHY_SCAL);
353 
354  ath5k_hw_reg_write(ah, AR5K_PHY_SCLOCK_32MHZ, AR5K_PHY_SCLOCK);
355  ath5k_hw_reg_write(ah, AR5K_PHY_SDELAY_32MHZ, AR5K_PHY_SDELAY);
356 
357  if ((ah->ah_radio == AR5K_RF5112) ||
358  (ah->ah_radio == AR5K_RF5413) ||
359  (ah->ah_radio == AR5K_RF2316) ||
360  (ah->ah_mac_version == (AR5K_SREV_AR2417 >> 4)))
361  spending = 0x14;
362  else
363  spending = 0x18;
364  ath5k_hw_reg_write(ah, spending, AR5K_PHY_SPENDING);
365 
366  /* Set up tsf increment on each cycle */
368 
369  if ((ah->ah_radio == AR5K_RF5112) ||
370  (ah->ah_radio == AR5K_RF5413) ||
371  (ah->ah_radio == AR5K_RF2316) ||
372  (ah->ah_radio == AR5K_RF2317))
373  sclock = 40 - 1;
374  else
375  sclock = 32 - 1;
377  }
378 }
379 
380 
381 /*********************\
382 * Reset/Sleep control *
383 \*********************/
384 
396 static int
397 ath5k_hw_nic_reset(struct ath5k_hw *ah, u32 val)
398 {
399  int ret;
400  u32 mask = val ? val : ~0U;
401 
402  /* Read-and-clear RX Descriptor Pointer*/
403  ath5k_hw_reg_read(ah, AR5K_RXDP);
404 
405  /*
406  * Reset the device and wait until success
407  */
408  ath5k_hw_reg_write(ah, val, AR5K_RESET_CTL);
409 
410  /* Wait at least 128 PCI clocks */
411  usleep_range(15, 20);
412 
413  if (ah->ah_version == AR5K_AR5210) {
418  } else {
421  }
422 
423  ret = ath5k_hw_register_timeout(ah, AR5K_RESET_CTL, mask, val, false);
424 
425  /*
426  * Reset configuration register (for hw byte-swap). Note that this
427  * is only set for big endian. We do the necessary magic in
428  * AR5K_INIT_CFG.
429  */
430  if ((val & AR5K_RESET_CTL_PCU) == 0)
431  ath5k_hw_reg_write(ah, AR5K_INIT_CFG, AR5K_CFG);
432 
433  return ret;
434 }
435 
445 static int
446 ath5k_hw_wisoc_reset(struct ath5k_hw *ah, u32 flags)
447 {
448  u32 mask = flags ? flags : ~0U;
449  u32 __iomem *reg;
450  u32 regval;
451  u32 val = 0;
452 
453  /* ah->ah_mac_srev is not available at this point yet */
454  if (ah->devid >= AR5K_SREV_AR2315_R6) {
455  reg = (u32 __iomem *) AR5K_AR2315_RESET;
456  if (mask & AR5K_RESET_CTL_PCU)
457  val |= AR5K_AR2315_RESET_WMAC;
458  if (mask & AR5K_RESET_CTL_BASEBAND)
460  } else {
461  reg = (u32 __iomem *) AR5K_AR5312_RESET;
462  if (to_platform_device(ah->dev)->id == 0) {
463  if (mask & AR5K_RESET_CTL_PCU)
465  if (mask & AR5K_RESET_CTL_BASEBAND)
468  } else {
469  if (mask & AR5K_RESET_CTL_PCU)
471  if (mask & AR5K_RESET_CTL_BASEBAND)
474  }
475  }
476 
477  /* Put BB/MAC into reset */
478  regval = ioread32(reg);
479  iowrite32(regval | val, reg);
480  regval = ioread32(reg);
481  usleep_range(100, 150);
482 
483  /* Bring BB/MAC out of reset */
484  iowrite32(regval & ~val, reg);
485  regval = ioread32(reg);
486 
487  /*
488  * Reset configuration register (for hw byte-swap). Note that this
489  * is only set for big endian. We do the necessary magic in
490  * AR5K_INIT_CFG.
491  */
492  if ((flags & AR5K_RESET_CTL_PCU) == 0)
493  ath5k_hw_reg_write(ah, AR5K_INIT_CFG, AR5K_CFG);
494 
495  return 0;
496 }
497 
513 static int
514 ath5k_hw_set_power_mode(struct ath5k_hw *ah, enum ath5k_power_mode mode,
515  bool set_chip, u16 sleep_duration)
516 {
517  unsigned int i;
518  u32 staid, data;
519 
520  staid = ath5k_hw_reg_read(ah, AR5K_STA_ID1);
521 
522  switch (mode) {
523  case AR5K_PM_AUTO:
525  /* fallthrough */
527  if (set_chip)
528  ath5k_hw_reg_write(ah,
530  sleep_duration,
532 
533  staid |= AR5K_STA_ID1_PWR_SV;
534  break;
535 
536  case AR5K_PM_FULL_SLEEP:
537  if (set_chip)
538  ath5k_hw_reg_write(ah, AR5K_SLEEP_CTL_SLE_SLP,
540 
541  staid |= AR5K_STA_ID1_PWR_SV;
542  break;
543 
544  case AR5K_PM_AWAKE:
545 
546  staid &= ~AR5K_STA_ID1_PWR_SV;
547 
548  if (!set_chip)
549  goto commit;
550 
551  data = ath5k_hw_reg_read(ah, AR5K_SLEEP_CTL);
552 
553  /* If card is down we 'll get 0xffff... so we
554  * need to clean this up before we write the register
555  */
556  if (data & 0xffc00000)
557  data = 0;
558  else
559  /* Preserve sleep duration etc */
560  data = data & ~AR5K_SLEEP_CTL_SLE;
561 
562  ath5k_hw_reg_write(ah, data | AR5K_SLEEP_CTL_SLE_WAKE,
564  usleep_range(15, 20);
565 
566  for (i = 200; i > 0; i--) {
567  /* Check if the chip did wake up */
568  if ((ath5k_hw_reg_read(ah, AR5K_PCICFG) &
569  AR5K_PCICFG_SPWR_DN) == 0)
570  break;
571 
572  /* Wait a bit and retry */
573  usleep_range(50, 75);
574  ath5k_hw_reg_write(ah, data | AR5K_SLEEP_CTL_SLE_WAKE,
576  }
577 
578  /* Fail if the chip didn't wake up */
579  if (i == 0)
580  return -EIO;
581 
582  break;
583 
584  default:
585  return -EINVAL;
586  }
587 
588 commit:
589  ath5k_hw_reg_write(ah, staid, AR5K_STA_ID1);
590 
591  return 0;
592 }
593 
606 int
608 {
609  struct pci_dev *pdev = ah->pdev;
610  u32 bus_flags;
611  int ret;
612 
613  if (ath5k_get_bus_type(ah) == ATH_AHB)
614  return 0;
615 
616  /* Make sure device is awake */
617  ret = ath5k_hw_set_power_mode(ah, AR5K_PM_AWAKE, true, 0);
618  if (ret) {
619  ATH5K_ERR(ah, "failed to wakeup the MAC Chip\n");
620  return ret;
621  }
622 
623  /*
624  * Put chipset on warm reset...
625  *
626  * Note: putting PCI core on warm reset on PCI-E cards
627  * results card to hang and always return 0xffff... so
628  * we ignore that flag for PCI-E cards. On PCI cards
629  * this flag gets cleared after 64 PCI clocks.
630  */
631  bus_flags = (pdev && pci_is_pcie(pdev)) ? 0 : AR5K_RESET_CTL_PCI;
632 
633  if (ah->ah_version == AR5K_AR5210) {
634  ret = ath5k_hw_nic_reset(ah, AR5K_RESET_CTL_PCU |
637  usleep_range(2000, 2500);
638  } else {
639  ret = ath5k_hw_nic_reset(ah, AR5K_RESET_CTL_PCU |
640  AR5K_RESET_CTL_BASEBAND | bus_flags);
641  }
642 
643  if (ret) {
644  ATH5K_ERR(ah, "failed to put device on warm reset\n");
645  return -EIO;
646  }
647 
648  /* ...wakeup again!*/
649  ret = ath5k_hw_set_power_mode(ah, AR5K_PM_AWAKE, true, 0);
650  if (ret) {
651  ATH5K_ERR(ah, "failed to put device on hold\n");
652  return ret;
653  }
654 
655  return ret;
656 }
657 
668 int
669 ath5k_hw_nic_wakeup(struct ath5k_hw *ah, struct ieee80211_channel *channel)
670 {
671  struct pci_dev *pdev = ah->pdev;
672  u32 turbo, mode, clock, bus_flags;
673  int ret;
674 
675  turbo = 0;
676  mode = 0;
677  clock = 0;
678 
679  if ((ath5k_get_bus_type(ah) != ATH_AHB) || channel) {
680  /* Wakeup the device */
681  ret = ath5k_hw_set_power_mode(ah, AR5K_PM_AWAKE, true, 0);
682  if (ret) {
683  ATH5K_ERR(ah, "failed to wakeup the MAC Chip\n");
684  return ret;
685  }
686  }
687 
688  /*
689  * Put chipset on warm reset...
690  *
691  * Note: putting PCI core on warm reset on PCI-E cards
692  * results card to hang and always return 0xffff... so
693  * we ignore that flag for PCI-E cards. On PCI cards
694  * this flag gets cleared after 64 PCI clocks.
695  */
696  bus_flags = (pdev && pci_is_pcie(pdev)) ? 0 : AR5K_RESET_CTL_PCI;
697 
698  if (ah->ah_version == AR5K_AR5210) {
699  ret = ath5k_hw_nic_reset(ah, AR5K_RESET_CTL_PCU |
702  usleep_range(2000, 2500);
703  } else {
704  if (ath5k_get_bus_type(ah) == ATH_AHB)
705  ret = ath5k_hw_wisoc_reset(ah, AR5K_RESET_CTL_PCU |
707  else
708  ret = ath5k_hw_nic_reset(ah, AR5K_RESET_CTL_PCU |
709  AR5K_RESET_CTL_BASEBAND | bus_flags);
710  }
711 
712  if (ret) {
713  ATH5K_ERR(ah, "failed to reset the MAC Chip\n");
714  return -EIO;
715  }
716 
717  /* ...wakeup again!...*/
718  ret = ath5k_hw_set_power_mode(ah, AR5K_PM_AWAKE, true, 0);
719  if (ret) {
720  ATH5K_ERR(ah, "failed to resume the MAC Chip\n");
721  return ret;
722  }
723 
724  /* ...reset configuration register on Wisoc ...
725  * ...clear reset control register and pull device out of
726  * warm reset on others */
727  if (ath5k_get_bus_type(ah) == ATH_AHB)
728  ret = ath5k_hw_wisoc_reset(ah, 0);
729  else
730  ret = ath5k_hw_nic_reset(ah, 0);
731 
732  if (ret) {
733  ATH5K_ERR(ah, "failed to warm reset the MAC Chip\n");
734  return -EIO;
735  }
736 
737  /* On initialization skip PLL programming since we don't have
738  * a channel / mode set yet */
739  if (!channel)
740  return 0;
741 
742  if (ah->ah_version != AR5K_AR5210) {
743  /*
744  * Get channel mode flags
745  */
746 
747  if (ah->ah_radio >= AR5K_RF5112) {
749  clock = AR5K_PHY_PLL_RF5112;
750  } else {
751  mode = AR5K_PHY_MODE_RAD_RF5111; /*Zero*/
752  clock = AR5K_PHY_PLL_RF5111; /*Zero*/
753  }
754 
755  if (channel->band == IEEE80211_BAND_2GHZ) {
756  mode |= AR5K_PHY_MODE_FREQ_2GHZ;
757  clock |= AR5K_PHY_PLL_44MHZ;
758 
759  if (channel->hw_value == AR5K_MODE_11B) {
760  mode |= AR5K_PHY_MODE_MOD_CCK;
761  } else {
762  /* XXX Dynamic OFDM/CCK is not supported by the
763  * AR5211 so we set MOD_OFDM for plain g (no
764  * CCK headers) operation. We need to test
765  * this, 5211 might support ofdm-only g after
766  * all, there are also initial register values
767  * in the code for g mode (see initvals.c).
768  */
769  if (ah->ah_version == AR5K_AR5211)
770  mode |= AR5K_PHY_MODE_MOD_OFDM;
771  else
772  mode |= AR5K_PHY_MODE_MOD_DYN;
773  }
774  } else if (channel->band == IEEE80211_BAND_5GHZ) {
775  mode |= (AR5K_PHY_MODE_FREQ_5GHZ |
777 
778  /* Different PLL setting for 5413 */
779  if (ah->ah_radio == AR5K_RF5413)
780  clock = AR5K_PHY_PLL_40MHZ_5413;
781  else
782  clock |= AR5K_PHY_PLL_40MHZ;
783  } else {
784  ATH5K_ERR(ah, "invalid radio frequency mode\n");
785  return -EINVAL;
786  }
787 
788  /*XXX: Can bwmode be used with dynamic mode ?
789  * (I don't think it supports 44MHz) */
790  /* On 2425 initvals TURBO_SHORT is not present */
791  if (ah->ah_bwmode == AR5K_BWMODE_40MHZ) {
792  turbo = AR5K_PHY_TURBO_MODE |
793  (ah->ah_radio == AR5K_RF2425) ? 0 :
795  } else if (ah->ah_bwmode != AR5K_BWMODE_DEFAULT) {
796  if (ah->ah_radio == AR5K_RF5413) {
797  mode |= (ah->ah_bwmode == AR5K_BWMODE_10MHZ) ?
800  } else if (ah->ah_version == AR5K_AR5212) {
801  clock |= (ah->ah_bwmode == AR5K_BWMODE_10MHZ) ?
804  }
805  }
806 
807  } else { /* Reset the device */
808 
809  /* ...enable Atheros turbo mode if requested */
810  if (ah->ah_bwmode == AR5K_BWMODE_40MHZ)
811  ath5k_hw_reg_write(ah, AR5K_PHY_TURBO_MODE,
813  }
814 
815  if (ah->ah_version != AR5K_AR5210) {
816 
817  /* ...update PLL if needed */
818  if (ath5k_hw_reg_read(ah, AR5K_PHY_PLL) != clock) {
819  ath5k_hw_reg_write(ah, clock, AR5K_PHY_PLL);
820  usleep_range(300, 350);
821  }
822 
823  /* ...set the PHY operating mode */
824  ath5k_hw_reg_write(ah, mode, AR5K_PHY_MODE);
825  ath5k_hw_reg_write(ah, turbo, AR5K_PHY_TURBO);
826  }
827 
828  return 0;
829 }
830 
831 
832 /**************************************\
833 * Post-initvals register modifications *
834 \**************************************/
835 
847 static void
848 ath5k_hw_tweak_initval_settings(struct ath5k_hw *ah,
849  struct ieee80211_channel *channel)
850 {
851  if (ah->ah_version == AR5K_AR5212 &&
853 
854  /* Setup ADC control */
855  ath5k_hw_reg_write(ah,
856  (AR5K_REG_SM(2,
858  AR5K_REG_SM(2,
863 
864 
865 
866  /* Disable barker RSSI threshold */
869 
872 
873  /* Set the mute mask */
874  ath5k_hw_reg_write(ah, 0x0000000f, AR5K_SEQ_MASK);
875  }
876 
877  /* Clear PHY_BLUETOOTH to allow RX_CLEAR line debug */
879  ath5k_hw_reg_write(ah, 0, AR5K_PHY_BLUETOOTH);
880 
881  /* Enable DCU double buffering */
885 
886  /* Set fast ADC */
887  if ((ah->ah_radio == AR5K_RF5413) ||
888  (ah->ah_radio == AR5K_RF2317) ||
889  (ah->ah_mac_version == (AR5K_SREV_AR2417 >> 4))) {
890  u32 fast_adc = true;
891 
892  if (channel->center_freq == 2462 ||
893  channel->center_freq == 2467)
894  fast_adc = 0;
895 
896  /* Only update if needed */
897  if (ath5k_hw_reg_read(ah, AR5K_PHY_FAST_ADC) != fast_adc)
898  ath5k_hw_reg_write(ah, fast_adc,
900  }
901 
902  /* Fix for first revision of the RF5112 RF chipset */
903  if (ah->ah_radio == AR5K_RF5112 &&
906  u32 data;
907  ath5k_hw_reg_write(ah, AR5K_PHY_CCKTXCTL_WORLD,
909  if (channel->band == IEEE80211_BAND_5GHZ)
910  data = 0xffb81020;
911  else
912  data = 0xffb80d20;
913  ath5k_hw_reg_write(ah, data, AR5K_PHY_FRAME_CTL);
914  }
915 
916  if (ah->ah_mac_srev < AR5K_SREV_AR5211) {
917  /* Clear QCU/DCU clock gating register */
918  ath5k_hw_reg_write(ah, 0, AR5K_QCUDCU_CLKGT);
919  /* Set DAC/ADC delays */
920  ath5k_hw_reg_write(ah, AR5K_PHY_SCAL_32MHZ_5311,
921  AR5K_PHY_SCAL);
922  /* Enable PCU FIFO corruption ECO */
925  }
926 
927  if (ah->ah_bwmode) {
928  /* Increase PHY switch and AGC settling time
929  * on turbo mode (ath5k_hw_commit_eeprom_settings
930  * will override settling time if available) */
931  if (ah->ah_bwmode == AR5K_BWMODE_40MHZ) {
932 
936 
937  /* XXX: Initvals indicate we only increase
938  * switch time on AR5212, 5211 and 5210
939  * only change agc time (bug?) */
940  if (ah->ah_version == AR5K_AR5212)
944 
945  if (ah->ah_version == AR5K_AR5210) {
946  /* Set Frame Control Register */
947  ath5k_hw_reg_write(ah,
950  AR5K_PHY_TURBO_SHORT | 0x2020),
952  }
953  /* On 5413 PHY force window length for half/quarter rate*/
954  } else if ((ah->ah_mac_srev >= AR5K_SREV_AR5424) &&
955  (ah->ah_mac_srev <= AR5K_SREV_AR5414)) {
958  3);
959  }
960  } else if (ah->ah_version == AR5K_AR5210) {
961  /* Set Frame Control Register for normal operation */
962  ath5k_hw_reg_write(ah, (AR5K_PHY_FRAME_CTL_INI | 0x1020),
964  }
965 }
966 
975 static void
976 ath5k_hw_commit_eeprom_settings(struct ath5k_hw *ah,
977  struct ieee80211_channel *channel)
978 {
979  struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
980  s16 cck_ofdm_pwr_delta;
981  u8 ee_mode;
982 
983  /* TODO: Add support for AR5210 EEPROM */
984  if (ah->ah_version == AR5K_AR5210)
985  return;
986 
987  ee_mode = ath5k_eeprom_mode_from_channel(channel);
988 
989  /* Adjust power delta for channel 14 */
990  if (channel->center_freq == 2484)
991  cck_ofdm_pwr_delta =
993  ee->ee_scaled_cck_delta) * 2) / 10;
994  else
995  cck_ofdm_pwr_delta =
996  (ee->ee_cck_ofdm_power_delta * 2) / 10;
997 
998  /* Set CCK to OFDM power delta on tx power
999  * adjustment register */
1000  if (ah->ah_phy_revision >= AR5K_SREV_PHY_5212A) {
1001  if (channel->hw_value == AR5K_MODE_11G)
1002  ath5k_hw_reg_write(ah,
1005  AR5K_REG_SM((cck_ofdm_pwr_delta * -1),
1008  else
1009  ath5k_hw_reg_write(ah, 0, AR5K_PHY_TX_PWR_ADJ);
1010  } else {
1011  /* For older revs we scale power on sw during tx power
1012  * setup */
1013  ah->ah_txpower.txp_cck_ofdm_pwr_delta = cck_ofdm_pwr_delta;
1014  ah->ah_txpower.txp_cck_ofdm_gainf_delta =
1016  }
1017 
1018  /* XXX: necessary here? is called from ath5k_hw_set_antenna_mode()
1019  * too */
1020  ath5k_hw_set_antenna_switch(ah, ee_mode);
1021 
1022  /* Noise floor threshold */
1023  ath5k_hw_reg_write(ah,
1024  AR5K_PHY_NF_SVAL(ee->ee_noise_floor_thr[ee_mode]),
1026 
1027  if ((ah->ah_bwmode == AR5K_BWMODE_40MHZ) &&
1028  (ah->ah_ee_version >= AR5K_EEPROM_VERSION_5_0)) {
1029  /* Switch settling time (Turbo) */
1032  ee->ee_switch_settling_turbo[ee_mode]);
1033 
1034  /* Tx/Rx attenuation (Turbo) */
1037  ee->ee_atn_tx_rx_turbo[ee_mode]);
1038 
1039  /* ADC/PGA desired size (Turbo) */
1042  ee->ee_adc_desired_size_turbo[ee_mode]);
1043 
1046  ee->ee_pga_desired_size_turbo[ee_mode]);
1047 
1048  /* Tx/Rx margin (Turbo) */
1051  ee->ee_margin_tx_rx_turbo[ee_mode]);
1052 
1053  } else {
1054  /* Switch settling time */
1057  ee->ee_switch_settling[ee_mode]);
1058 
1059  /* Tx/Rx attenuation */
1062  ee->ee_atn_tx_rx[ee_mode]);
1063 
1064  /* ADC/PGA desired size */
1067  ee->ee_adc_desired_size[ee_mode]);
1068 
1071  ee->ee_pga_desired_size[ee_mode]);
1072 
1073  /* Tx/Rx margin */
1074  if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_1)
1077  ee->ee_margin_tx_rx[ee_mode]);
1078  }
1079 
1080  /* XPA delays */
1081  ath5k_hw_reg_write(ah,
1082  (ee->ee_tx_end2xpa_disable[ee_mode] << 24) |
1083  (ee->ee_tx_end2xpa_disable[ee_mode] << 16) |
1084  (ee->ee_tx_frm2xpa_enable[ee_mode] << 8) |
1085  (ee->ee_tx_frm2xpa_enable[ee_mode]), AR5K_PHY_RF_CTL4);
1086 
1087  /* XLNA delay */
1090  ee->ee_tx_end2xlna_enable[ee_mode]);
1091 
1092  /* Thresh64 (ANI) */
1095  ee->ee_thr_62[ee_mode]);
1096 
1097  /* False detect backoff for channels
1098  * that have spur noise. Write the new
1099  * cyclic power RSSI threshold. */
1100  if (ath5k_hw_chan_has_spur_noise(ah, channel))
1104  ee->ee_false_detect[ee_mode]);
1105  else
1109 
1110  /* I/Q correction (set enable bit last to match HAL sources) */
1111  /* TODO: Per channel i/q infos ? */
1112  if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_4_0) {
1114  ee->ee_i_cal[ee_mode]);
1116  ee->ee_q_cal[ee_mode]);
1118  }
1119 
1120  /* Heavy clipping -disable for now */
1121  if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_5_1)
1122  ath5k_hw_reg_write(ah, 0, AR5K_PHY_HEAVY_CLIP_ENABLE);
1123 }
1124 
1125 
1126 /*********************\
1127 * Main reset function *
1128 \*********************/
1129 
1145 int
1146 ath5k_hw_reset(struct ath5k_hw *ah, enum nl80211_iftype op_mode,
1147  struct ieee80211_channel *channel, bool fast, bool skip_pcu)
1148 {
1149  u32 s_seq[10], s_led[3], tsf_up, tsf_lo;
1150  u8 mode;
1151  int i, ret;
1152 
1153  tsf_up = 0;
1154  tsf_lo = 0;
1155  mode = 0;
1156 
1157  /*
1158  * Sanity check for fast flag
1159  * Fast channel change only available
1160  * on AR2413/AR5413.
1161  */
1162  if (fast && (ah->ah_radio != AR5K_RF2413) &&
1163  (ah->ah_radio != AR5K_RF5413))
1164  fast = false;
1165 
1166  /* Disable sleep clock operation
1167  * to avoid register access delay on certain
1168  * PHY registers */
1169  if (ah->ah_version == AR5K_AR5212)
1170  ath5k_hw_set_sleep_clock(ah, false);
1171 
1172  /*
1173  * Stop PCU
1174  */
1176 
1177  /*
1178  * Stop DMA
1179  *
1180  * Note: If DMA didn't stop continue
1181  * since only a reset will fix it.
1182  */
1183  ret = ath5k_hw_dma_stop(ah);
1184 
1185  /* RF Bus grant won't work if we have pending
1186  * frames */
1187  if (ret && fast) {
1188  ATH5K_DBG(ah, ATH5K_DEBUG_RESET,
1189  "DMA didn't stop, falling back to normal reset\n");
1190  fast = false;
1191  /* Non fatal, just continue with
1192  * normal reset */
1193  ret = 0;
1194  }
1195 
1196  mode = channel->hw_value;
1197  switch (mode) {
1198  case AR5K_MODE_11A:
1199  break;
1200  case AR5K_MODE_11G:
1201  if (ah->ah_version <= AR5K_AR5211) {
1202  ATH5K_ERR(ah,
1203  "G mode not available on 5210/5211");
1204  return -EINVAL;
1205  }
1206  break;
1207  case AR5K_MODE_11B:
1208  if (ah->ah_version < AR5K_AR5211) {
1209  ATH5K_ERR(ah,
1210  "B mode not available on 5210");
1211  return -EINVAL;
1212  }
1213  break;
1214  default:
1215  ATH5K_ERR(ah,
1216  "invalid channel: %d\n", channel->center_freq);
1217  return -EINVAL;
1218  }
1219 
1220  /*
1221  * If driver requested fast channel change and DMA has stopped
1222  * go on. If it fails continue with a normal reset.
1223  */
1224  if (fast) {
1225  ret = ath5k_hw_phy_init(ah, channel, mode, true);
1226  if (ret) {
1227  ATH5K_DBG(ah, ATH5K_DEBUG_RESET,
1228  "fast chan change failed, falling back to normal reset\n");
1229  /* Non fatal, can happen eg.
1230  * on mode change */
1231  ret = 0;
1232  } else {
1233  ATH5K_DBG(ah, ATH5K_DEBUG_RESET,
1234  "fast chan change successful\n");
1235  return 0;
1236  }
1237  }
1238 
1239  /*
1240  * Save some registers before a reset
1241  */
1242  if (ah->ah_version != AR5K_AR5210) {
1243  /*
1244  * Save frame sequence count
1245  * For revs. after Oahu, only save
1246  * seq num for DCU 0 (Global seq num)
1247  */
1248  if (ah->ah_mac_srev < AR5K_SREV_AR5211) {
1249 
1250  for (i = 0; i < 10; i++)
1251  s_seq[i] = ath5k_hw_reg_read(ah,
1253 
1254  } else {
1255  s_seq[0] = ath5k_hw_reg_read(ah,
1257  }
1258 
1259  /* TSF accelerates on AR5211 during reset
1260  * As a workaround save it here and restore
1261  * it later so that it's back in time after
1262  * reset. This way it'll get re-synced on the
1263  * next beacon without breaking ad-hoc.
1264  *
1265  * On AR5212 TSF is almost preserved across a
1266  * reset so it stays back in time anyway and
1267  * we don't have to save/restore it.
1268  *
1269  * XXX: Since this breaks power saving we have
1270  * to disable power saving until we receive the
1271  * next beacon, so we can resync beacon timers */
1272  if (ah->ah_version == AR5K_AR5211) {
1273  tsf_up = ath5k_hw_reg_read(ah, AR5K_TSF_U32);
1274  tsf_lo = ath5k_hw_reg_read(ah, AR5K_TSF_L32);
1275  }
1276  }
1277 
1278 
1279  /*GPIOs*/
1280  s_led[0] = ath5k_hw_reg_read(ah, AR5K_PCICFG) &
1282  s_led[1] = ath5k_hw_reg_read(ah, AR5K_GPIOCR);
1283  s_led[2] = ath5k_hw_reg_read(ah, AR5K_GPIODO);
1284 
1285 
1286  /*
1287  * Since we are going to write rf buffer
1288  * check if we have any pending gain_F
1289  * optimization settings
1290  */
1291  if (ah->ah_version == AR5K_AR5212 &&
1292  (ah->ah_radio <= AR5K_RF5112)) {
1293  if (!fast && ah->ah_rf_banks != NULL)
1295  }
1296 
1297  /* Wakeup the device */
1298  ret = ath5k_hw_nic_wakeup(ah, channel);
1299  if (ret)
1300  return ret;
1301 
1302  /* PHY access enable */
1303  if (ah->ah_mac_srev >= AR5K_SREV_AR5211)
1304  ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_5GHZ, AR5K_PHY(0));
1305  else
1306  ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_5GHZ | 0x40,
1307  AR5K_PHY(0));
1308 
1309  /* Write initial settings */
1310  ret = ath5k_hw_write_initvals(ah, mode, skip_pcu);
1311  if (ret)
1312  return ret;
1313 
1314  /* Initialize core clock settings */
1315  ath5k_hw_init_core_clock(ah);
1316 
1317  /*
1318  * Tweak initval settings for revised
1319  * chipsets and add some more config
1320  * bits
1321  */
1322  ath5k_hw_tweak_initval_settings(ah, channel);
1323 
1324  /* Commit values from EEPROM */
1325  ath5k_hw_commit_eeprom_settings(ah, channel);
1326 
1327 
1328  /*
1329  * Restore saved values
1330  */
1331 
1332  /* Seqnum, TSF */
1333  if (ah->ah_version != AR5K_AR5210) {
1334  if (ah->ah_mac_srev < AR5K_SREV_AR5211) {
1335  for (i = 0; i < 10; i++)
1336  ath5k_hw_reg_write(ah, s_seq[i],
1338  } else {
1339  ath5k_hw_reg_write(ah, s_seq[0],
1341  }
1342 
1343  if (ah->ah_version == AR5K_AR5211) {
1344  ath5k_hw_reg_write(ah, tsf_up, AR5K_TSF_U32);
1345  ath5k_hw_reg_write(ah, tsf_lo, AR5K_TSF_L32);
1346  }
1347  }
1348 
1349  /* Ledstate */
1350  AR5K_REG_ENABLE_BITS(ah, AR5K_PCICFG, s_led[0]);
1351 
1352  /* Gpio settings */
1353  ath5k_hw_reg_write(ah, s_led[1], AR5K_GPIOCR);
1354  ath5k_hw_reg_write(ah, s_led[2], AR5K_GPIODO);
1355 
1356  /*
1357  * Initialize PCU
1358  */
1359  ath5k_hw_pcu_init(ah, op_mode);
1360 
1361  /*
1362  * Initialize PHY
1363  */
1364  ret = ath5k_hw_phy_init(ah, channel, mode, false);
1365  if (ret) {
1366  ATH5K_ERR(ah,
1367  "failed to initialize PHY (%i) !\n", ret);
1368  return ret;
1369  }
1370 
1371  /*
1372  * Configure QCUs/DCUs
1373  */
1374  ret = ath5k_hw_init_queues(ah);
1375  if (ret)
1376  return ret;
1377 
1378 
1379  /*
1380  * Initialize DMA/Interrupts
1381  */
1382  ath5k_hw_dma_init(ah);
1383 
1384 
1385  /*
1386  * Enable 32KHz clock function for AR5212+ chips
1387  * Set clocks to 32KHz operation and use an
1388  * external 32KHz crystal when sleeping if one
1389  * exists.
1390  * Disabled by default because it is also disabled in
1391  * other drivers and it is known to cause stability
1392  * issues on some devices
1393  */
1394  if (ah->ah_use_32khz_clock && ah->ah_version == AR5K_AR5212 &&
1395  op_mode != NL80211_IFTYPE_AP)
1396  ath5k_hw_set_sleep_clock(ah, true);
1397 
1398  /*
1399  * Disable beacons and reset the TSF
1400  */
1402  ath5k_hw_reset_tsf(ah);
1403  return 0;
1404 }