/drivers/net/wireless/b43/phy_lp.c

http://github.com/mirrors/linux · C · 2730 lines · 2387 code · 275 blank · 68 comment · 315 complexity · 874fdd9736822fec1f659a38550afe91 MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. Broadcom B43 wireless driver
  3. IEEE 802.11a/g LP-PHY driver
  4. Copyright (c) 2008-2009 Michael Buesch <m@bues.ch>
  5. Copyright (c) 2009 G??bor Stefanik <netrolller.3d@gmail.com>
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program; see the file COPYING. If not, write to
  16. the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
  17. Boston, MA 02110-1301, USA.
  18. */
  19. #include <linux/slab.h>
  20. #include "b43.h"
  21. #include "main.h"
  22. #include "phy_lp.h"
  23. #include "phy_common.h"
  24. #include "tables_lpphy.h"
  25. static inline u16 channel2freq_lp(u8 channel)
  26. {
  27. if (channel < 14)
  28. return (2407 + 5 * channel);
  29. else if (channel == 14)
  30. return 2484;
  31. else if (channel < 184)
  32. return (5000 + 5 * channel);
  33. else
  34. return (4000 + 5 * channel);
  35. }
  36. static unsigned int b43_lpphy_op_get_default_chan(struct b43_wldev *dev)
  37. {
  38. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
  39. return 1;
  40. return 36;
  41. }
  42. static int b43_lpphy_op_allocate(struct b43_wldev *dev)
  43. {
  44. struct b43_phy_lp *lpphy;
  45. lpphy = kzalloc(sizeof(*lpphy), GFP_KERNEL);
  46. if (!lpphy)
  47. return -ENOMEM;
  48. dev->phy.lp = lpphy;
  49. return 0;
  50. }
  51. static void b43_lpphy_op_prepare_structs(struct b43_wldev *dev)
  52. {
  53. struct b43_phy *phy = &dev->phy;
  54. struct b43_phy_lp *lpphy = phy->lp;
  55. memset(lpphy, 0, sizeof(*lpphy));
  56. lpphy->antenna = B43_ANTENNA_DEFAULT;
  57. //TODO
  58. }
  59. static void b43_lpphy_op_free(struct b43_wldev *dev)
  60. {
  61. struct b43_phy_lp *lpphy = dev->phy.lp;
  62. kfree(lpphy);
  63. dev->phy.lp = NULL;
  64. }
  65. /* http://bcm-v4.sipsolutions.net/802.11/PHY/LP/ReadBandSrom */
  66. static void lpphy_read_band_sprom(struct b43_wldev *dev)
  67. {
  68. struct ssb_sprom *sprom = dev->dev->bus_sprom;
  69. struct b43_phy_lp *lpphy = dev->phy.lp;
  70. u16 cckpo, maxpwr;
  71. u32 ofdmpo;
  72. int i;
  73. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
  74. lpphy->tx_isolation_med_band = sprom->tri2g;
  75. lpphy->bx_arch = sprom->bxa2g;
  76. lpphy->rx_pwr_offset = sprom->rxpo2g;
  77. lpphy->rssi_vf = sprom->rssismf2g;
  78. lpphy->rssi_vc = sprom->rssismc2g;
  79. lpphy->rssi_gs = sprom->rssisav2g;
  80. lpphy->txpa[0] = sprom->pa0b0;
  81. lpphy->txpa[1] = sprom->pa0b1;
  82. lpphy->txpa[2] = sprom->pa0b2;
  83. maxpwr = sprom->maxpwr_bg;
  84. lpphy->max_tx_pwr_med_band = maxpwr;
  85. cckpo = sprom->cck2gpo;
  86. if (cckpo) {
  87. ofdmpo = sprom->ofdm2gpo;
  88. for (i = 0; i < 4; i++) {
  89. lpphy->tx_max_rate[i] =
  90. maxpwr - (ofdmpo & 0xF) * 2;
  91. ofdmpo >>= 4;
  92. }
  93. ofdmpo = sprom->ofdm2gpo;
  94. for (i = 4; i < 15; i++) {
  95. lpphy->tx_max_rate[i] =
  96. maxpwr - (ofdmpo & 0xF) * 2;
  97. ofdmpo >>= 4;
  98. }
  99. } else {
  100. u8 opo = sprom->opo;
  101. for (i = 0; i < 4; i++)
  102. lpphy->tx_max_rate[i] = maxpwr;
  103. for (i = 4; i < 15; i++)
  104. lpphy->tx_max_rate[i] = maxpwr - opo;
  105. }
  106. } else { /* 5GHz */
  107. lpphy->tx_isolation_low_band = sprom->tri5gl;
  108. lpphy->tx_isolation_med_band = sprom->tri5g;
  109. lpphy->tx_isolation_hi_band = sprom->tri5gh;
  110. lpphy->bx_arch = sprom->bxa5g;
  111. lpphy->rx_pwr_offset = sprom->rxpo5g;
  112. lpphy->rssi_vf = sprom->rssismf5g;
  113. lpphy->rssi_vc = sprom->rssismc5g;
  114. lpphy->rssi_gs = sprom->rssisav5g;
  115. lpphy->txpa[0] = sprom->pa1b0;
  116. lpphy->txpa[1] = sprom->pa1b1;
  117. lpphy->txpa[2] = sprom->pa1b2;
  118. lpphy->txpal[0] = sprom->pa1lob0;
  119. lpphy->txpal[1] = sprom->pa1lob1;
  120. lpphy->txpal[2] = sprom->pa1lob2;
  121. lpphy->txpah[0] = sprom->pa1hib0;
  122. lpphy->txpah[1] = sprom->pa1hib1;
  123. lpphy->txpah[2] = sprom->pa1hib2;
  124. maxpwr = sprom->maxpwr_al;
  125. ofdmpo = sprom->ofdm5glpo;
  126. lpphy->max_tx_pwr_low_band = maxpwr;
  127. for (i = 4; i < 12; i++) {
  128. lpphy->tx_max_ratel[i] = maxpwr - (ofdmpo & 0xF) * 2;
  129. ofdmpo >>= 4;
  130. }
  131. maxpwr = sprom->maxpwr_a;
  132. ofdmpo = sprom->ofdm5gpo;
  133. lpphy->max_tx_pwr_med_band = maxpwr;
  134. for (i = 4; i < 12; i++) {
  135. lpphy->tx_max_rate[i] = maxpwr - (ofdmpo & 0xF) * 2;
  136. ofdmpo >>= 4;
  137. }
  138. maxpwr = sprom->maxpwr_ah;
  139. ofdmpo = sprom->ofdm5ghpo;
  140. lpphy->max_tx_pwr_hi_band = maxpwr;
  141. for (i = 4; i < 12; i++) {
  142. lpphy->tx_max_rateh[i] = maxpwr - (ofdmpo & 0xF) * 2;
  143. ofdmpo >>= 4;
  144. }
  145. }
  146. }
  147. static void lpphy_adjust_gain_table(struct b43_wldev *dev, u32 freq)
  148. {
  149. struct b43_phy_lp *lpphy = dev->phy.lp;
  150. u16 temp[3];
  151. u16 isolation;
  152. B43_WARN_ON(dev->phy.rev >= 2);
  153. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
  154. isolation = lpphy->tx_isolation_med_band;
  155. else if (freq <= 5320)
  156. isolation = lpphy->tx_isolation_low_band;
  157. else if (freq <= 5700)
  158. isolation = lpphy->tx_isolation_med_band;
  159. else
  160. isolation = lpphy->tx_isolation_hi_band;
  161. temp[0] = ((isolation - 26) / 12) << 12;
  162. temp[1] = temp[0] + 0x1000;
  163. temp[2] = temp[0] + 0x2000;
  164. b43_lptab_write_bulk(dev, B43_LPTAB16(13, 0), 3, temp);
  165. b43_lptab_write_bulk(dev, B43_LPTAB16(12, 0), 3, temp);
  166. }
  167. static void lpphy_table_init(struct b43_wldev *dev)
  168. {
  169. u32 freq = channel2freq_lp(b43_lpphy_op_get_default_chan(dev));
  170. if (dev->phy.rev < 2)
  171. lpphy_rev0_1_table_init(dev);
  172. else
  173. lpphy_rev2plus_table_init(dev);
  174. lpphy_init_tx_gain_table(dev);
  175. if (dev->phy.rev < 2)
  176. lpphy_adjust_gain_table(dev, freq);
  177. }
  178. static void lpphy_baseband_rev0_1_init(struct b43_wldev *dev)
  179. {
  180. struct ssb_bus *bus = dev->dev->sdev->bus;
  181. struct ssb_sprom *sprom = dev->dev->bus_sprom;
  182. struct b43_phy_lp *lpphy = dev->phy.lp;
  183. u16 tmp, tmp2;
  184. b43_phy_mask(dev, B43_LPPHY_AFE_DAC_CTL, 0xF7FF);
  185. b43_phy_write(dev, B43_LPPHY_AFE_CTL, 0);
  186. b43_phy_write(dev, B43_LPPHY_AFE_CTL_OVR, 0);
  187. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_0, 0);
  188. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_2, 0);
  189. b43_phy_set(dev, B43_LPPHY_AFE_DAC_CTL, 0x0004);
  190. b43_phy_maskset(dev, B43_LPPHY_OFDMSYNCTHRESH0, 0xFF00, 0x0078);
  191. b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0x83FF, 0x5800);
  192. b43_phy_write(dev, B43_LPPHY_ADC_COMPENSATION_CTL, 0x0016);
  193. b43_phy_maskset(dev, B43_LPPHY_AFE_ADC_CTL_0, 0xFFF8, 0x0004);
  194. b43_phy_maskset(dev, B43_LPPHY_VERYLOWGAINDB, 0x00FF, 0x5400);
  195. b43_phy_maskset(dev, B43_LPPHY_HIGAINDB, 0x00FF, 0x2400);
  196. b43_phy_maskset(dev, B43_LPPHY_LOWGAINDB, 0x00FF, 0x2100);
  197. b43_phy_maskset(dev, B43_LPPHY_VERYLOWGAINDB, 0xFF00, 0x0006);
  198. b43_phy_mask(dev, B43_LPPHY_RX_RADIO_CTL, 0xFFFE);
  199. b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0xFFE0, 0x0005);
  200. b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0xFC1F, 0x0180);
  201. b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0x83FF, 0x3C00);
  202. b43_phy_maskset(dev, B43_LPPHY_GAINDIRECTMISMATCH, 0xFFF0, 0x0005);
  203. b43_phy_maskset(dev, B43_LPPHY_GAIN_MISMATCH_LIMIT, 0xFFC0, 0x001A);
  204. b43_phy_maskset(dev, B43_LPPHY_CRS_ED_THRESH, 0xFF00, 0x00B3);
  205. b43_phy_maskset(dev, B43_LPPHY_CRS_ED_THRESH, 0x00FF, 0xAD00);
  206. b43_phy_maskset(dev, B43_LPPHY_INPUT_PWRDB,
  207. 0xFF00, lpphy->rx_pwr_offset);
  208. if ((sprom->boardflags_lo & B43_BFL_FEM) &&
  209. ((b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) ||
  210. (sprom->boardflags_hi & B43_BFH_PAREF))) {
  211. ssb_pmu_set_ldo_voltage(&bus->chipco, LDO_PAREF, 0x28);
  212. ssb_pmu_set_ldo_paref(&bus->chipco, true);
  213. if (dev->phy.rev == 0) {
  214. b43_phy_maskset(dev, B43_LPPHY_LP_RF_SIGNAL_LUT,
  215. 0xFFCF, 0x0010);
  216. }
  217. b43_lptab_write(dev, B43_LPTAB16(11, 7), 60);
  218. } else {
  219. ssb_pmu_set_ldo_paref(&bus->chipco, false);
  220. b43_phy_maskset(dev, B43_LPPHY_LP_RF_SIGNAL_LUT,
  221. 0xFFCF, 0x0020);
  222. b43_lptab_write(dev, B43_LPTAB16(11, 7), 100);
  223. }
  224. tmp = lpphy->rssi_vf | lpphy->rssi_vc << 4 | 0xA000;
  225. b43_phy_write(dev, B43_LPPHY_AFE_RSSI_CTL_0, tmp);
  226. if (sprom->boardflags_hi & B43_BFH_RSSIINV)
  227. b43_phy_maskset(dev, B43_LPPHY_AFE_RSSI_CTL_1, 0xF000, 0x0AAA);
  228. else
  229. b43_phy_maskset(dev, B43_LPPHY_AFE_RSSI_CTL_1, 0xF000, 0x02AA);
  230. b43_lptab_write(dev, B43_LPTAB16(11, 1), 24);
  231. b43_phy_maskset(dev, B43_LPPHY_RX_RADIO_CTL,
  232. 0xFFF9, (lpphy->bx_arch << 1));
  233. if (dev->phy.rev == 1 &&
  234. (sprom->boardflags_hi & B43_BFH_FEM_BT)) {
  235. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0xFFC0, 0x000A);
  236. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0x3F00, 0x0900);
  237. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_2, 0xFFC0, 0x000A);
  238. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_2, 0xC0FF, 0x0B00);
  239. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_3, 0xFFC0, 0x000A);
  240. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_3, 0xC0FF, 0x0400);
  241. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_4, 0xFFC0, 0x000A);
  242. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_4, 0xC0FF, 0x0B00);
  243. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_5, 0xFFC0, 0x000A);
  244. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_5, 0xC0FF, 0x0900);
  245. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_6, 0xFFC0, 0x000A);
  246. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_6, 0xC0FF, 0x0B00);
  247. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_7, 0xFFC0, 0x000A);
  248. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_7, 0xC0FF, 0x0900);
  249. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_8, 0xFFC0, 0x000A);
  250. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_8, 0xC0FF, 0x0B00);
  251. } else if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ ||
  252. (dev->dev->board_type == SSB_BOARD_BU4312) ||
  253. (dev->phy.rev == 0 && (sprom->boardflags_lo & B43_BFL_FEM))) {
  254. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0xFFC0, 0x0001);
  255. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0xC0FF, 0x0400);
  256. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_2, 0xFFC0, 0x0001);
  257. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_2, 0xC0FF, 0x0500);
  258. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_3, 0xFFC0, 0x0002);
  259. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_3, 0xC0FF, 0x0800);
  260. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_4, 0xFFC0, 0x0002);
  261. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_4, 0xC0FF, 0x0A00);
  262. } else if (dev->phy.rev == 1 ||
  263. (sprom->boardflags_lo & B43_BFL_FEM)) {
  264. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0xFFC0, 0x0004);
  265. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0xC0FF, 0x0800);
  266. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_2, 0xFFC0, 0x0004);
  267. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_2, 0xC0FF, 0x0C00);
  268. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_3, 0xFFC0, 0x0002);
  269. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_3, 0xC0FF, 0x0100);
  270. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_4, 0xFFC0, 0x0002);
  271. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_4, 0xC0FF, 0x0300);
  272. } else {
  273. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0xFFC0, 0x000A);
  274. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0xC0FF, 0x0900);
  275. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_2, 0xFFC0, 0x000A);
  276. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_2, 0xC0FF, 0x0B00);
  277. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_3, 0xFFC0, 0x0006);
  278. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_3, 0xC0FF, 0x0500);
  279. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_4, 0xFFC0, 0x0006);
  280. b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_4, 0xC0FF, 0x0700);
  281. }
  282. if (dev->phy.rev == 1 && (sprom->boardflags_hi & B43_BFH_PAREF)) {
  283. b43_phy_copy(dev, B43_LPPHY_TR_LOOKUP_5, B43_LPPHY_TR_LOOKUP_1);
  284. b43_phy_copy(dev, B43_LPPHY_TR_LOOKUP_6, B43_LPPHY_TR_LOOKUP_2);
  285. b43_phy_copy(dev, B43_LPPHY_TR_LOOKUP_7, B43_LPPHY_TR_LOOKUP_3);
  286. b43_phy_copy(dev, B43_LPPHY_TR_LOOKUP_8, B43_LPPHY_TR_LOOKUP_4);
  287. }
  288. if ((sprom->boardflags_hi & B43_BFH_FEM_BT) &&
  289. (dev->dev->chip_id == 0x5354) &&
  290. (dev->dev->chip_pkg == SSB_CHIPPACK_BCM4712S)) {
  291. b43_phy_set(dev, B43_LPPHY_CRSGAIN_CTL, 0x0006);
  292. b43_phy_write(dev, B43_LPPHY_GPIO_SELECT, 0x0005);
  293. b43_phy_write(dev, B43_LPPHY_GPIO_OUTEN, 0xFFFF);
  294. //FIXME the Broadcom driver caches & delays this HF write!
  295. b43_hf_write(dev, b43_hf_read(dev) | B43_HF_PR45960W);
  296. }
  297. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
  298. b43_phy_set(dev, B43_LPPHY_LP_PHY_CTL, 0x8000);
  299. b43_phy_set(dev, B43_LPPHY_CRSGAIN_CTL, 0x0040);
  300. b43_phy_maskset(dev, B43_LPPHY_MINPWR_LEVEL, 0x00FF, 0xA400);
  301. b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL, 0xF0FF, 0x0B00);
  302. b43_phy_maskset(dev, B43_LPPHY_SYNCPEAKCNT, 0xFFF8, 0x0007);
  303. b43_phy_maskset(dev, B43_LPPHY_DSSS_CONFIRM_CNT, 0xFFF8, 0x0003);
  304. b43_phy_maskset(dev, B43_LPPHY_DSSS_CONFIRM_CNT, 0xFFC7, 0x0020);
  305. b43_phy_mask(dev, B43_LPPHY_IDLEAFTERPKTRXTO, 0x00FF);
  306. } else { /* 5GHz */
  307. b43_phy_mask(dev, B43_LPPHY_LP_PHY_CTL, 0x7FFF);
  308. b43_phy_mask(dev, B43_LPPHY_CRSGAIN_CTL, 0xFFBF);
  309. }
  310. if (dev->phy.rev == 1) {
  311. tmp = b43_phy_read(dev, B43_LPPHY_CLIPCTRTHRESH);
  312. tmp2 = (tmp & 0x03E0) >> 5;
  313. tmp2 |= tmp2 << 5;
  314. b43_phy_write(dev, B43_LPPHY_4C3, tmp2);
  315. tmp = b43_phy_read(dev, B43_LPPHY_GAINDIRECTMISMATCH);
  316. tmp2 = (tmp & 0x1F00) >> 8;
  317. tmp2 |= tmp2 << 5;
  318. b43_phy_write(dev, B43_LPPHY_4C4, tmp2);
  319. tmp = b43_phy_read(dev, B43_LPPHY_VERYLOWGAINDB);
  320. tmp2 = tmp & 0x00FF;
  321. tmp2 |= tmp << 8;
  322. b43_phy_write(dev, B43_LPPHY_4C5, tmp2);
  323. }
  324. }
  325. static void lpphy_save_dig_flt_state(struct b43_wldev *dev)
  326. {
  327. static const u16 addr[] = {
  328. B43_PHY_OFDM(0xC1),
  329. B43_PHY_OFDM(0xC2),
  330. B43_PHY_OFDM(0xC3),
  331. B43_PHY_OFDM(0xC4),
  332. B43_PHY_OFDM(0xC5),
  333. B43_PHY_OFDM(0xC6),
  334. B43_PHY_OFDM(0xC7),
  335. B43_PHY_OFDM(0xC8),
  336. B43_PHY_OFDM(0xCF),
  337. };
  338. static const u16 coefs[] = {
  339. 0xDE5E, 0xE832, 0xE331, 0x4D26,
  340. 0x0026, 0x1420, 0x0020, 0xFE08,
  341. 0x0008,
  342. };
  343. struct b43_phy_lp *lpphy = dev->phy.lp;
  344. int i;
  345. for (i = 0; i < ARRAY_SIZE(addr); i++) {
  346. lpphy->dig_flt_state[i] = b43_phy_read(dev, addr[i]);
  347. b43_phy_write(dev, addr[i], coefs[i]);
  348. }
  349. }
  350. static void lpphy_restore_dig_flt_state(struct b43_wldev *dev)
  351. {
  352. static const u16 addr[] = {
  353. B43_PHY_OFDM(0xC1),
  354. B43_PHY_OFDM(0xC2),
  355. B43_PHY_OFDM(0xC3),
  356. B43_PHY_OFDM(0xC4),
  357. B43_PHY_OFDM(0xC5),
  358. B43_PHY_OFDM(0xC6),
  359. B43_PHY_OFDM(0xC7),
  360. B43_PHY_OFDM(0xC8),
  361. B43_PHY_OFDM(0xCF),
  362. };
  363. struct b43_phy_lp *lpphy = dev->phy.lp;
  364. int i;
  365. for (i = 0; i < ARRAY_SIZE(addr); i++)
  366. b43_phy_write(dev, addr[i], lpphy->dig_flt_state[i]);
  367. }
  368. static void lpphy_baseband_rev2plus_init(struct b43_wldev *dev)
  369. {
  370. struct b43_phy_lp *lpphy = dev->phy.lp;
  371. b43_phy_write(dev, B43_LPPHY_AFE_DAC_CTL, 0x50);
  372. b43_phy_write(dev, B43_LPPHY_AFE_CTL, 0x8800);
  373. b43_phy_write(dev, B43_LPPHY_AFE_CTL_OVR, 0);
  374. b43_phy_write(dev, B43_LPPHY_AFE_CTL_OVRVAL, 0);
  375. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_0, 0);
  376. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_2, 0);
  377. b43_phy_write(dev, B43_PHY_OFDM(0xF9), 0);
  378. b43_phy_write(dev, B43_LPPHY_TR_LOOKUP_1, 0);
  379. b43_phy_set(dev, B43_LPPHY_ADC_COMPENSATION_CTL, 0x10);
  380. b43_phy_maskset(dev, B43_LPPHY_OFDMSYNCTHRESH0, 0xFF00, 0xB4);
  381. b43_phy_maskset(dev, B43_LPPHY_DCOFFSETTRANSIENT, 0xF8FF, 0x200);
  382. b43_phy_maskset(dev, B43_LPPHY_DCOFFSETTRANSIENT, 0xFF00, 0x7F);
  383. b43_phy_maskset(dev, B43_LPPHY_GAINDIRECTMISMATCH, 0xFF0F, 0x40);
  384. b43_phy_maskset(dev, B43_LPPHY_PREAMBLECONFIRMTO, 0xFF00, 0x2);
  385. b43_phy_mask(dev, B43_LPPHY_CRSGAIN_CTL, ~0x4000);
  386. b43_phy_mask(dev, B43_LPPHY_CRSGAIN_CTL, ~0x2000);
  387. b43_phy_set(dev, B43_PHY_OFDM(0x10A), 0x1);
  388. if (dev->dev->board_rev >= 0x18) {
  389. b43_lptab_write(dev, B43_LPTAB32(17, 65), 0xEC);
  390. b43_phy_maskset(dev, B43_PHY_OFDM(0x10A), 0xFF01, 0x14);
  391. } else {
  392. b43_phy_maskset(dev, B43_PHY_OFDM(0x10A), 0xFF01, 0x10);
  393. }
  394. b43_phy_maskset(dev, B43_PHY_OFDM(0xDF), 0xFF00, 0xF4);
  395. b43_phy_maskset(dev, B43_PHY_OFDM(0xDF), 0x00FF, 0xF100);
  396. b43_phy_write(dev, B43_LPPHY_CLIPTHRESH, 0x48);
  397. b43_phy_maskset(dev, B43_LPPHY_HIGAINDB, 0xFF00, 0x46);
  398. b43_phy_maskset(dev, B43_PHY_OFDM(0xE4), 0xFF00, 0x10);
  399. b43_phy_maskset(dev, B43_LPPHY_PWR_THRESH1, 0xFFF0, 0x9);
  400. b43_phy_mask(dev, B43_LPPHY_GAINDIRECTMISMATCH, ~0xF);
  401. b43_phy_maskset(dev, B43_LPPHY_VERYLOWGAINDB, 0x00FF, 0x5500);
  402. b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0xFC1F, 0xA0);
  403. b43_phy_maskset(dev, B43_LPPHY_GAINDIRECTMISMATCH, 0xE0FF, 0x300);
  404. b43_phy_maskset(dev, B43_LPPHY_HIGAINDB, 0x00FF, 0x2A00);
  405. if ((dev->dev->chip_id == 0x4325) && (dev->dev->chip_rev == 0)) {
  406. b43_phy_maskset(dev, B43_LPPHY_LOWGAINDB, 0x00FF, 0x2100);
  407. b43_phy_maskset(dev, B43_LPPHY_VERYLOWGAINDB, 0xFF00, 0xA);
  408. } else {
  409. b43_phy_maskset(dev, B43_LPPHY_LOWGAINDB, 0x00FF, 0x1E00);
  410. b43_phy_maskset(dev, B43_LPPHY_VERYLOWGAINDB, 0xFF00, 0xD);
  411. }
  412. b43_phy_maskset(dev, B43_PHY_OFDM(0xFE), 0xFFE0, 0x1F);
  413. b43_phy_maskset(dev, B43_PHY_OFDM(0xFF), 0xFFE0, 0xC);
  414. b43_phy_maskset(dev, B43_PHY_OFDM(0x100), 0xFF00, 0x19);
  415. b43_phy_maskset(dev, B43_PHY_OFDM(0xFF), 0x03FF, 0x3C00);
  416. b43_phy_maskset(dev, B43_PHY_OFDM(0xFE), 0xFC1F, 0x3E0);
  417. b43_phy_maskset(dev, B43_PHY_OFDM(0xFF), 0xFFE0, 0xC);
  418. b43_phy_maskset(dev, B43_PHY_OFDM(0x100), 0x00FF, 0x1900);
  419. b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0x83FF, 0x5800);
  420. b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0xFFE0, 0x12);
  421. b43_phy_maskset(dev, B43_LPPHY_GAINMISMATCH, 0x0FFF, 0x9000);
  422. if ((dev->dev->chip_id == 0x4325) && (dev->dev->chip_rev == 0)) {
  423. b43_lptab_write(dev, B43_LPTAB16(0x08, 0x14), 0);
  424. b43_lptab_write(dev, B43_LPTAB16(0x08, 0x12), 0x40);
  425. }
  426. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
  427. b43_phy_set(dev, B43_LPPHY_CRSGAIN_CTL, 0x40);
  428. b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL, 0xF0FF, 0xB00);
  429. b43_phy_maskset(dev, B43_LPPHY_SYNCPEAKCNT, 0xFFF8, 0x6);
  430. b43_phy_maskset(dev, B43_LPPHY_MINPWR_LEVEL, 0x00FF, 0x9D00);
  431. b43_phy_maskset(dev, B43_LPPHY_MINPWR_LEVEL, 0xFF00, 0xA1);
  432. b43_phy_mask(dev, B43_LPPHY_IDLEAFTERPKTRXTO, 0x00FF);
  433. } else /* 5GHz */
  434. b43_phy_mask(dev, B43_LPPHY_CRSGAIN_CTL, ~0x40);
  435. b43_phy_maskset(dev, B43_LPPHY_CRS_ED_THRESH, 0xFF00, 0xB3);
  436. b43_phy_maskset(dev, B43_LPPHY_CRS_ED_THRESH, 0x00FF, 0xAD00);
  437. b43_phy_maskset(dev, B43_LPPHY_INPUT_PWRDB, 0xFF00, lpphy->rx_pwr_offset);
  438. b43_phy_set(dev, B43_LPPHY_RESET_CTL, 0x44);
  439. b43_phy_write(dev, B43_LPPHY_RESET_CTL, 0x80);
  440. b43_phy_write(dev, B43_LPPHY_AFE_RSSI_CTL_0, 0xA954);
  441. b43_phy_write(dev, B43_LPPHY_AFE_RSSI_CTL_1,
  442. 0x2000 | ((u16)lpphy->rssi_gs << 10) |
  443. ((u16)lpphy->rssi_vc << 4) | lpphy->rssi_vf);
  444. if ((dev->dev->chip_id == 0x4325) && (dev->dev->chip_rev == 0)) {
  445. b43_phy_set(dev, B43_LPPHY_AFE_ADC_CTL_0, 0x1C);
  446. b43_phy_maskset(dev, B43_LPPHY_AFE_CTL, 0x00FF, 0x8800);
  447. b43_phy_maskset(dev, B43_LPPHY_AFE_ADC_CTL_1, 0xFC3C, 0x0400);
  448. }
  449. lpphy_save_dig_flt_state(dev);
  450. }
  451. static void lpphy_baseband_init(struct b43_wldev *dev)
  452. {
  453. lpphy_table_init(dev);
  454. if (dev->phy.rev >= 2)
  455. lpphy_baseband_rev2plus_init(dev);
  456. else
  457. lpphy_baseband_rev0_1_init(dev);
  458. }
  459. struct b2062_freqdata {
  460. u16 freq;
  461. u8 data[6];
  462. };
  463. /* Initialize the 2062 radio. */
  464. static void lpphy_2062_init(struct b43_wldev *dev)
  465. {
  466. struct b43_phy_lp *lpphy = dev->phy.lp;
  467. struct ssb_bus *bus = dev->dev->sdev->bus;
  468. u32 crystalfreq, tmp, ref;
  469. unsigned int i;
  470. const struct b2062_freqdata *fd = NULL;
  471. static const struct b2062_freqdata freqdata_tab[] = {
  472. { .freq = 12000, .data[0] = 6, .data[1] = 6, .data[2] = 6,
  473. .data[3] = 6, .data[4] = 10, .data[5] = 6, },
  474. { .freq = 13000, .data[0] = 4, .data[1] = 4, .data[2] = 4,
  475. .data[3] = 4, .data[4] = 11, .data[5] = 7, },
  476. { .freq = 14400, .data[0] = 3, .data[1] = 3, .data[2] = 3,
  477. .data[3] = 3, .data[4] = 12, .data[5] = 7, },
  478. { .freq = 16200, .data[0] = 3, .data[1] = 3, .data[2] = 3,
  479. .data[3] = 3, .data[4] = 13, .data[5] = 8, },
  480. { .freq = 18000, .data[0] = 2, .data[1] = 2, .data[2] = 2,
  481. .data[3] = 2, .data[4] = 14, .data[5] = 8, },
  482. { .freq = 19200, .data[0] = 1, .data[1] = 1, .data[2] = 1,
  483. .data[3] = 1, .data[4] = 14, .data[5] = 9, },
  484. };
  485. b2062_upload_init_table(dev);
  486. b43_radio_write(dev, B2062_N_TX_CTL3, 0);
  487. b43_radio_write(dev, B2062_N_TX_CTL4, 0);
  488. b43_radio_write(dev, B2062_N_TX_CTL5, 0);
  489. b43_radio_write(dev, B2062_N_TX_CTL6, 0);
  490. b43_radio_write(dev, B2062_N_PDN_CTL0, 0x40);
  491. b43_radio_write(dev, B2062_N_PDN_CTL0, 0);
  492. b43_radio_write(dev, B2062_N_CALIB_TS, 0x10);
  493. b43_radio_write(dev, B2062_N_CALIB_TS, 0);
  494. if (dev->phy.rev > 0) {
  495. b43_radio_write(dev, B2062_S_BG_CTL1,
  496. (b43_radio_read(dev, B2062_N_COMM2) >> 1) | 0x80);
  497. }
  498. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
  499. b43_radio_set(dev, B2062_N_TSSI_CTL0, 0x1);
  500. else
  501. b43_radio_mask(dev, B2062_N_TSSI_CTL0, ~0x1);
  502. /* Get the crystal freq, in Hz. */
  503. crystalfreq = bus->chipco.pmu.crystalfreq * 1000;
  504. B43_WARN_ON(!(bus->chipco.capabilities & SSB_CHIPCO_CAP_PMU));
  505. B43_WARN_ON(crystalfreq == 0);
  506. if (crystalfreq <= 30000000) {
  507. lpphy->pdiv = 1;
  508. b43_radio_mask(dev, B2062_S_RFPLL_CTL1, 0xFFFB);
  509. } else {
  510. lpphy->pdiv = 2;
  511. b43_radio_set(dev, B2062_S_RFPLL_CTL1, 0x4);
  512. }
  513. tmp = (((800000000 * lpphy->pdiv + crystalfreq) /
  514. (2 * crystalfreq)) - 8) & 0xFF;
  515. b43_radio_write(dev, B2062_S_RFPLL_CTL7, tmp);
  516. tmp = (((100 * crystalfreq + 16000000 * lpphy->pdiv) /
  517. (32000000 * lpphy->pdiv)) - 1) & 0xFF;
  518. b43_radio_write(dev, B2062_S_RFPLL_CTL18, tmp);
  519. tmp = (((2 * crystalfreq + 1000000 * lpphy->pdiv) /
  520. (2000000 * lpphy->pdiv)) - 1) & 0xFF;
  521. b43_radio_write(dev, B2062_S_RFPLL_CTL19, tmp);
  522. ref = (1000 * lpphy->pdiv + 2 * crystalfreq) / (2000 * lpphy->pdiv);
  523. ref &= 0xFFFF;
  524. for (i = 0; i < ARRAY_SIZE(freqdata_tab); i++) {
  525. if (ref < freqdata_tab[i].freq) {
  526. fd = &freqdata_tab[i];
  527. break;
  528. }
  529. }
  530. if (!fd)
  531. fd = &freqdata_tab[ARRAY_SIZE(freqdata_tab) - 1];
  532. b43dbg(dev->wl, "b2062: Using crystal tab entry %u kHz.\n",
  533. fd->freq); /* FIXME: Keep this printk until the code is fully debugged. */
  534. b43_radio_write(dev, B2062_S_RFPLL_CTL8,
  535. ((u16)(fd->data[1]) << 4) | fd->data[0]);
  536. b43_radio_write(dev, B2062_S_RFPLL_CTL9,
  537. ((u16)(fd->data[3]) << 4) | fd->data[2]);
  538. b43_radio_write(dev, B2062_S_RFPLL_CTL10, fd->data[4]);
  539. b43_radio_write(dev, B2062_S_RFPLL_CTL11, fd->data[5]);
  540. }
  541. /* Initialize the 2063 radio. */
  542. static void lpphy_2063_init(struct b43_wldev *dev)
  543. {
  544. b2063_upload_init_table(dev);
  545. b43_radio_write(dev, B2063_LOGEN_SP5, 0);
  546. b43_radio_set(dev, B2063_COMM8, 0x38);
  547. b43_radio_write(dev, B2063_REG_SP1, 0x56);
  548. b43_radio_mask(dev, B2063_RX_BB_CTL2, ~0x2);
  549. b43_radio_write(dev, B2063_PA_SP7, 0);
  550. b43_radio_write(dev, B2063_TX_RF_SP6, 0x20);
  551. b43_radio_write(dev, B2063_TX_RF_SP9, 0x40);
  552. if (dev->phy.rev == 2) {
  553. b43_radio_write(dev, B2063_PA_SP3, 0xa0);
  554. b43_radio_write(dev, B2063_PA_SP4, 0xa0);
  555. b43_radio_write(dev, B2063_PA_SP2, 0x18);
  556. } else {
  557. b43_radio_write(dev, B2063_PA_SP3, 0x20);
  558. b43_radio_write(dev, B2063_PA_SP2, 0x20);
  559. }
  560. }
  561. struct lpphy_stx_table_entry {
  562. u16 phy_offset;
  563. u16 phy_shift;
  564. u16 rf_addr;
  565. u16 rf_shift;
  566. u16 mask;
  567. };
  568. static const struct lpphy_stx_table_entry lpphy_stx_table[] = {
  569. { .phy_offset = 2, .phy_shift = 6, .rf_addr = 0x3d, .rf_shift = 3, .mask = 0x01, },
  570. { .phy_offset = 1, .phy_shift = 12, .rf_addr = 0x4c, .rf_shift = 1, .mask = 0x01, },
  571. { .phy_offset = 1, .phy_shift = 8, .rf_addr = 0x50, .rf_shift = 0, .mask = 0x7f, },
  572. { .phy_offset = 0, .phy_shift = 8, .rf_addr = 0x44, .rf_shift = 0, .mask = 0xff, },
  573. { .phy_offset = 1, .phy_shift = 0, .rf_addr = 0x4a, .rf_shift = 0, .mask = 0xff, },
  574. { .phy_offset = 0, .phy_shift = 4, .rf_addr = 0x4d, .rf_shift = 0, .mask = 0xff, },
  575. { .phy_offset = 1, .phy_shift = 4, .rf_addr = 0x4e, .rf_shift = 0, .mask = 0xff, },
  576. { .phy_offset = 0, .phy_shift = 12, .rf_addr = 0x4f, .rf_shift = 0, .mask = 0x0f, },
  577. { .phy_offset = 1, .phy_shift = 0, .rf_addr = 0x4f, .rf_shift = 4, .mask = 0x0f, },
  578. { .phy_offset = 3, .phy_shift = 0, .rf_addr = 0x49, .rf_shift = 0, .mask = 0x0f, },
  579. { .phy_offset = 4, .phy_shift = 3, .rf_addr = 0x46, .rf_shift = 4, .mask = 0x07, },
  580. { .phy_offset = 3, .phy_shift = 15, .rf_addr = 0x46, .rf_shift = 0, .mask = 0x01, },
  581. { .phy_offset = 4, .phy_shift = 0, .rf_addr = 0x46, .rf_shift = 1, .mask = 0x07, },
  582. { .phy_offset = 3, .phy_shift = 8, .rf_addr = 0x48, .rf_shift = 4, .mask = 0x07, },
  583. { .phy_offset = 3, .phy_shift = 11, .rf_addr = 0x48, .rf_shift = 0, .mask = 0x0f, },
  584. { .phy_offset = 3, .phy_shift = 4, .rf_addr = 0x49, .rf_shift = 4, .mask = 0x0f, },
  585. { .phy_offset = 2, .phy_shift = 15, .rf_addr = 0x45, .rf_shift = 0, .mask = 0x01, },
  586. { .phy_offset = 5, .phy_shift = 13, .rf_addr = 0x52, .rf_shift = 4, .mask = 0x07, },
  587. { .phy_offset = 6, .phy_shift = 0, .rf_addr = 0x52, .rf_shift = 7, .mask = 0x01, },
  588. { .phy_offset = 5, .phy_shift = 3, .rf_addr = 0x41, .rf_shift = 5, .mask = 0x07, },
  589. { .phy_offset = 5, .phy_shift = 6, .rf_addr = 0x41, .rf_shift = 0, .mask = 0x0f, },
  590. { .phy_offset = 5, .phy_shift = 10, .rf_addr = 0x42, .rf_shift = 5, .mask = 0x07, },
  591. { .phy_offset = 4, .phy_shift = 15, .rf_addr = 0x42, .rf_shift = 0, .mask = 0x01, },
  592. { .phy_offset = 5, .phy_shift = 0, .rf_addr = 0x42, .rf_shift = 1, .mask = 0x07, },
  593. { .phy_offset = 4, .phy_shift = 11, .rf_addr = 0x43, .rf_shift = 4, .mask = 0x0f, },
  594. { .phy_offset = 4, .phy_shift = 7, .rf_addr = 0x43, .rf_shift = 0, .mask = 0x0f, },
  595. { .phy_offset = 4, .phy_shift = 6, .rf_addr = 0x45, .rf_shift = 1, .mask = 0x01, },
  596. { .phy_offset = 2, .phy_shift = 7, .rf_addr = 0x40, .rf_shift = 4, .mask = 0x0f, },
  597. { .phy_offset = 2, .phy_shift = 11, .rf_addr = 0x40, .rf_shift = 0, .mask = 0x0f, },
  598. };
  599. static void lpphy_sync_stx(struct b43_wldev *dev)
  600. {
  601. const struct lpphy_stx_table_entry *e;
  602. unsigned int i;
  603. u16 tmp;
  604. for (i = 0; i < ARRAY_SIZE(lpphy_stx_table); i++) {
  605. e = &lpphy_stx_table[i];
  606. tmp = b43_radio_read(dev, e->rf_addr);
  607. tmp >>= e->rf_shift;
  608. tmp <<= e->phy_shift;
  609. b43_phy_maskset(dev, B43_PHY_OFDM(0xF2 + e->phy_offset),
  610. ~(e->mask << e->phy_shift), tmp);
  611. }
  612. }
  613. static void lpphy_radio_init(struct b43_wldev *dev)
  614. {
  615. /* The radio is attached through the 4wire bus. */
  616. b43_phy_set(dev, B43_LPPHY_FOURWIRE_CTL, 0x2);
  617. udelay(1);
  618. b43_phy_mask(dev, B43_LPPHY_FOURWIRE_CTL, 0xFFFD);
  619. udelay(1);
  620. if (dev->phy.radio_ver == 0x2062) {
  621. lpphy_2062_init(dev);
  622. } else {
  623. lpphy_2063_init(dev);
  624. lpphy_sync_stx(dev);
  625. b43_phy_write(dev, B43_PHY_OFDM(0xF0), 0x5F80);
  626. b43_phy_write(dev, B43_PHY_OFDM(0xF1), 0);
  627. if (dev->dev->chip_id == 0x4325) {
  628. // TODO SSB PMU recalibration
  629. }
  630. }
  631. }
  632. struct lpphy_iq_est { u32 iq_prod, i_pwr, q_pwr; };
  633. static void lpphy_set_rc_cap(struct b43_wldev *dev)
  634. {
  635. struct b43_phy_lp *lpphy = dev->phy.lp;
  636. u8 rc_cap = (lpphy->rc_cap & 0x1F) >> 1;
  637. if (dev->phy.rev == 1) //FIXME check channel 14!
  638. rc_cap = min_t(u8, rc_cap + 5, 15);
  639. b43_radio_write(dev, B2062_N_RXBB_CALIB2,
  640. max_t(u8, lpphy->rc_cap - 4, 0x80));
  641. b43_radio_write(dev, B2062_N_TX_CTL_A, rc_cap | 0x80);
  642. b43_radio_write(dev, B2062_S_RXG_CNT16,
  643. ((lpphy->rc_cap & 0x1F) >> 2) | 0x80);
  644. }
  645. static u8 lpphy_get_bb_mult(struct b43_wldev *dev)
  646. {
  647. return (b43_lptab_read(dev, B43_LPTAB16(0, 87)) & 0xFF00) >> 8;
  648. }
  649. static void lpphy_set_bb_mult(struct b43_wldev *dev, u8 bb_mult)
  650. {
  651. b43_lptab_write(dev, B43_LPTAB16(0, 87), (u16)bb_mult << 8);
  652. }
  653. static void lpphy_set_deaf(struct b43_wldev *dev, bool user)
  654. {
  655. struct b43_phy_lp *lpphy = dev->phy.lp;
  656. if (user)
  657. lpphy->crs_usr_disable = true;
  658. else
  659. lpphy->crs_sys_disable = true;
  660. b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL, 0xFF1F, 0x80);
  661. }
  662. static void lpphy_clear_deaf(struct b43_wldev *dev, bool user)
  663. {
  664. struct b43_phy_lp *lpphy = dev->phy.lp;
  665. if (user)
  666. lpphy->crs_usr_disable = false;
  667. else
  668. lpphy->crs_sys_disable = false;
  669. if (!lpphy->crs_usr_disable && !lpphy->crs_sys_disable) {
  670. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
  671. b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL,
  672. 0xFF1F, 0x60);
  673. else
  674. b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL,
  675. 0xFF1F, 0x20);
  676. }
  677. }
  678. static void lpphy_set_trsw_over(struct b43_wldev *dev, bool tx, bool rx)
  679. {
  680. u16 trsw = (tx << 1) | rx;
  681. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0xFFFC, trsw);
  682. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x3);
  683. }
  684. static void lpphy_disable_crs(struct b43_wldev *dev, bool user)
  685. {
  686. lpphy_set_deaf(dev, user);
  687. lpphy_set_trsw_over(dev, false, true);
  688. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0xFFFB);
  689. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x4);
  690. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0xFFF7);
  691. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x8);
  692. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0x10);
  693. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x10);
  694. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0xFFDF);
  695. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x20);
  696. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0xFFBF);
  697. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x40);
  698. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0x7);
  699. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0x38);
  700. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xFF3F);
  701. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0x100);
  702. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xFDFF);
  703. b43_phy_write(dev, B43_LPPHY_PS_CTL_OVERRIDE_VAL0, 0);
  704. b43_phy_write(dev, B43_LPPHY_PS_CTL_OVERRIDE_VAL1, 1);
  705. b43_phy_write(dev, B43_LPPHY_PS_CTL_OVERRIDE_VAL2, 0x20);
  706. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xFBFF);
  707. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xF7FF);
  708. b43_phy_write(dev, B43_LPPHY_TX_GAIN_CTL_OVERRIDE_VAL, 0);
  709. b43_phy_write(dev, B43_LPPHY_RX_GAIN_CTL_OVERRIDE_VAL, 0x45AF);
  710. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_2, 0x3FF);
  711. }
  712. static void lpphy_restore_crs(struct b43_wldev *dev, bool user)
  713. {
  714. lpphy_clear_deaf(dev, user);
  715. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_0, 0xFF80);
  716. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFC00);
  717. }
  718. struct lpphy_tx_gains { u16 gm, pga, pad, dac; };
  719. static void lpphy_disable_rx_gain_override(struct b43_wldev *dev)
  720. {
  721. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_0, 0xFFFE);
  722. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_0, 0xFFEF);
  723. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_0, 0xFFBF);
  724. if (dev->phy.rev >= 2) {
  725. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFEFF);
  726. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
  727. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFBFF);
  728. b43_phy_mask(dev, B43_PHY_OFDM(0xE5), 0xFFF7);
  729. }
  730. } else {
  731. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFDFF);
  732. }
  733. }
  734. static void lpphy_enable_rx_gain_override(struct b43_wldev *dev)
  735. {
  736. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x1);
  737. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x10);
  738. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x40);
  739. if (dev->phy.rev >= 2) {
  740. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x100);
  741. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
  742. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x400);
  743. b43_phy_set(dev, B43_PHY_OFDM(0xE5), 0x8);
  744. }
  745. } else {
  746. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x200);
  747. }
  748. }
  749. static void lpphy_disable_tx_gain_override(struct b43_wldev *dev)
  750. {
  751. if (dev->phy.rev < 2)
  752. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFEFF);
  753. else {
  754. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFF7F);
  755. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xBFFF);
  756. }
  757. b43_phy_mask(dev, B43_LPPHY_AFE_CTL_OVR, 0xFFBF);
  758. }
  759. static void lpphy_enable_tx_gain_override(struct b43_wldev *dev)
  760. {
  761. if (dev->phy.rev < 2)
  762. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x100);
  763. else {
  764. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x80);
  765. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x4000);
  766. }
  767. b43_phy_set(dev, B43_LPPHY_AFE_CTL_OVR, 0x40);
  768. }
  769. static struct lpphy_tx_gains lpphy_get_tx_gains(struct b43_wldev *dev)
  770. {
  771. struct lpphy_tx_gains gains;
  772. u16 tmp;
  773. gains.dac = (b43_phy_read(dev, B43_LPPHY_AFE_DAC_CTL) & 0x380) >> 7;
  774. if (dev->phy.rev < 2) {
  775. tmp = b43_phy_read(dev,
  776. B43_LPPHY_TX_GAIN_CTL_OVERRIDE_VAL) & 0x7FF;
  777. gains.gm = tmp & 0x0007;
  778. gains.pga = (tmp & 0x0078) >> 3;
  779. gains.pad = (tmp & 0x780) >> 7;
  780. } else {
  781. tmp = b43_phy_read(dev, B43_LPPHY_TX_GAIN_CTL_OVERRIDE_VAL);
  782. gains.pad = b43_phy_read(dev, B43_PHY_OFDM(0xFB)) & 0xFF;
  783. gains.gm = tmp & 0xFF;
  784. gains.pga = (tmp >> 8) & 0xFF;
  785. }
  786. return gains;
  787. }
  788. static void lpphy_set_dac_gain(struct b43_wldev *dev, u16 dac)
  789. {
  790. u16 ctl = b43_phy_read(dev, B43_LPPHY_AFE_DAC_CTL) & 0xC7F;
  791. ctl |= dac << 7;
  792. b43_phy_maskset(dev, B43_LPPHY_AFE_DAC_CTL, 0xF000, ctl);
  793. }
  794. static u16 lpphy_get_pa_gain(struct b43_wldev *dev)
  795. {
  796. return b43_phy_read(dev, B43_PHY_OFDM(0xFB)) & 0x7F;
  797. }
  798. static void lpphy_set_pa_gain(struct b43_wldev *dev, u16 gain)
  799. {
  800. b43_phy_maskset(dev, B43_PHY_OFDM(0xFB), 0xE03F, gain << 6);
  801. b43_phy_maskset(dev, B43_PHY_OFDM(0xFD), 0x80FF, gain << 8);
  802. }
  803. static void lpphy_set_tx_gains(struct b43_wldev *dev,
  804. struct lpphy_tx_gains gains)
  805. {
  806. u16 rf_gain, pa_gain;
  807. if (dev->phy.rev < 2) {
  808. rf_gain = (gains.pad << 7) | (gains.pga << 3) | gains.gm;
  809. b43_phy_maskset(dev, B43_LPPHY_TX_GAIN_CTL_OVERRIDE_VAL,
  810. 0xF800, rf_gain);
  811. } else {
  812. pa_gain = lpphy_get_pa_gain(dev);
  813. b43_phy_write(dev, B43_LPPHY_TX_GAIN_CTL_OVERRIDE_VAL,
  814. (gains.pga << 8) | gains.gm);
  815. /*
  816. * SPEC FIXME The spec calls for (pa_gain << 8) here, but that
  817. * conflicts with the spec for set_pa_gain! Vendor driver bug?
  818. */
  819. b43_phy_maskset(dev, B43_PHY_OFDM(0xFB),
  820. 0x8000, gains.pad | (pa_gain << 6));
  821. b43_phy_write(dev, B43_PHY_OFDM(0xFC),
  822. (gains.pga << 8) | gains.gm);
  823. b43_phy_maskset(dev, B43_PHY_OFDM(0xFD),
  824. 0x8000, gains.pad | (pa_gain << 8));
  825. }
  826. lpphy_set_dac_gain(dev, gains.dac);
  827. lpphy_enable_tx_gain_override(dev);
  828. }
  829. static void lpphy_rev0_1_set_rx_gain(struct b43_wldev *dev, u32 gain)
  830. {
  831. u16 trsw = gain & 0x1;
  832. u16 lna = (gain & 0xFFFC) | ((gain & 0xC) >> 2);
  833. u16 ext_lna = (gain & 2) >> 1;
  834. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0xFFFE, trsw);
  835. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL,
  836. 0xFBFF, ext_lna << 10);
  837. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL,
  838. 0xF7FF, ext_lna << 11);
  839. b43_phy_write(dev, B43_LPPHY_RX_GAIN_CTL_OVERRIDE_VAL, lna);
  840. }
  841. static void lpphy_rev2plus_set_rx_gain(struct b43_wldev *dev, u32 gain)
  842. {
  843. u16 low_gain = gain & 0xFFFF;
  844. u16 high_gain = (gain >> 16) & 0xF;
  845. u16 ext_lna = (gain >> 21) & 0x1;
  846. u16 trsw = ~(gain >> 20) & 0x1;
  847. u16 tmp;
  848. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0xFFFE, trsw);
  849. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL,
  850. 0xFDFF, ext_lna << 9);
  851. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL,
  852. 0xFBFF, ext_lna << 10);
  853. b43_phy_write(dev, B43_LPPHY_RX_GAIN_CTL_OVERRIDE_VAL, low_gain);
  854. b43_phy_maskset(dev, B43_LPPHY_AFE_DDFS, 0xFFF0, high_gain);
  855. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
  856. tmp = (gain >> 2) & 0x3;
  857. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL,
  858. 0xE7FF, tmp<<11);
  859. b43_phy_maskset(dev, B43_PHY_OFDM(0xE6), 0xFFE7, tmp << 3);
  860. }
  861. }
  862. static void lpphy_set_rx_gain(struct b43_wldev *dev, u32 gain)
  863. {
  864. if (dev->phy.rev < 2)
  865. lpphy_rev0_1_set_rx_gain(dev, gain);
  866. else
  867. lpphy_rev2plus_set_rx_gain(dev, gain);
  868. lpphy_enable_rx_gain_override(dev);
  869. }
  870. static void lpphy_set_rx_gain_by_index(struct b43_wldev *dev, u16 idx)
  871. {
  872. u32 gain = b43_lptab_read(dev, B43_LPTAB16(12, idx));
  873. lpphy_set_rx_gain(dev, gain);
  874. }
  875. static void lpphy_stop_ddfs(struct b43_wldev *dev)
  876. {
  877. b43_phy_mask(dev, B43_LPPHY_AFE_DDFS, 0xFFFD);
  878. b43_phy_mask(dev, B43_LPPHY_LP_PHY_CTL, 0xFFDF);
  879. }
  880. static void lpphy_run_ddfs(struct b43_wldev *dev, int i_on, int q_on,
  881. int incr1, int incr2, int scale_idx)
  882. {
  883. lpphy_stop_ddfs(dev);
  884. b43_phy_mask(dev, B43_LPPHY_AFE_DDFS_POINTER_INIT, 0xFF80);
  885. b43_phy_mask(dev, B43_LPPHY_AFE_DDFS_POINTER_INIT, 0x80FF);
  886. b43_phy_maskset(dev, B43_LPPHY_AFE_DDFS_INCR_INIT, 0xFF80, incr1);
  887. b43_phy_maskset(dev, B43_LPPHY_AFE_DDFS_INCR_INIT, 0x80FF, incr2 << 8);
  888. b43_phy_maskset(dev, B43_LPPHY_AFE_DDFS, 0xFFF7, i_on << 3);
  889. b43_phy_maskset(dev, B43_LPPHY_AFE_DDFS, 0xFFEF, q_on << 4);
  890. b43_phy_maskset(dev, B43_LPPHY_AFE_DDFS, 0xFF9F, scale_idx << 5);
  891. b43_phy_mask(dev, B43_LPPHY_AFE_DDFS, 0xFFFB);
  892. b43_phy_set(dev, B43_LPPHY_AFE_DDFS, 0x2);
  893. b43_phy_set(dev, B43_LPPHY_LP_PHY_CTL, 0x20);
  894. }
  895. static bool lpphy_rx_iq_est(struct b43_wldev *dev, u16 samples, u8 time,
  896. struct lpphy_iq_est *iq_est)
  897. {
  898. int i;
  899. b43_phy_mask(dev, B43_LPPHY_CRSGAIN_CTL, 0xFFF7);
  900. b43_phy_write(dev, B43_LPPHY_IQ_NUM_SMPLS_ADDR, samples);
  901. b43_phy_maskset(dev, B43_LPPHY_IQ_ENABLE_WAIT_TIME_ADDR, 0xFF00, time);
  902. b43_phy_mask(dev, B43_LPPHY_IQ_ENABLE_WAIT_TIME_ADDR, 0xFEFF);
  903. b43_phy_set(dev, B43_LPPHY_IQ_ENABLE_WAIT_TIME_ADDR, 0x200);
  904. for (i = 0; i < 500; i++) {
  905. if (!(b43_phy_read(dev,
  906. B43_LPPHY_IQ_ENABLE_WAIT_TIME_ADDR) & 0x200))
  907. break;
  908. msleep(1);
  909. }
  910. if ((b43_phy_read(dev, B43_LPPHY_IQ_ENABLE_WAIT_TIME_ADDR) & 0x200)) {
  911. b43_phy_set(dev, B43_LPPHY_CRSGAIN_CTL, 0x8);
  912. return false;
  913. }
  914. iq_est->iq_prod = b43_phy_read(dev, B43_LPPHY_IQ_ACC_HI_ADDR);
  915. iq_est->iq_prod <<= 16;
  916. iq_est->iq_prod |= b43_phy_read(dev, B43_LPPHY_IQ_ACC_LO_ADDR);
  917. iq_est->i_pwr = b43_phy_read(dev, B43_LPPHY_IQ_I_PWR_ACC_HI_ADDR);
  918. iq_est->i_pwr <<= 16;
  919. iq_est->i_pwr |= b43_phy_read(dev, B43_LPPHY_IQ_I_PWR_ACC_LO_ADDR);
  920. iq_est->q_pwr = b43_phy_read(dev, B43_LPPHY_IQ_Q_PWR_ACC_HI_ADDR);
  921. iq_est->q_pwr <<= 16;
  922. iq_est->q_pwr |= b43_phy_read(dev, B43_LPPHY_IQ_Q_PWR_ACC_LO_ADDR);
  923. b43_phy_set(dev, B43_LPPHY_CRSGAIN_CTL, 0x8);
  924. return true;
  925. }
  926. static int lpphy_loopback(struct b43_wldev *dev)
  927. {
  928. struct lpphy_iq_est iq_est;
  929. int i, index = -1;
  930. u32 tmp;
  931. memset(&iq_est, 0, sizeof(iq_est));
  932. lpphy_set_trsw_over(dev, true, true);
  933. b43_phy_set(dev, B43_LPPHY_AFE_CTL_OVR, 1);
  934. b43_phy_mask(dev, B43_LPPHY_AFE_CTL_OVRVAL, 0xFFFE);
  935. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x800);
  936. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0x800);
  937. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x8);
  938. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0x8);
  939. b43_radio_write(dev, B2062_N_TX_CTL_A, 0x80);
  940. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x80);
  941. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0x80);
  942. for (i = 0; i < 32; i++) {
  943. lpphy_set_rx_gain_by_index(dev, i);
  944. lpphy_run_ddfs(dev, 1, 1, 5, 5, 0);
  945. if (!(lpphy_rx_iq_est(dev, 1000, 32, &iq_est)))
  946. continue;
  947. tmp = (iq_est.i_pwr + iq_est.q_pwr) / 1000;
  948. if ((tmp > 4000) && (tmp < 10000)) {
  949. index = i;
  950. break;
  951. }
  952. }
  953. lpphy_stop_ddfs(dev);
  954. return index;
  955. }
  956. /* Fixed-point division algorithm using only integer math. */
  957. static u32 lpphy_qdiv_roundup(u32 dividend, u32 divisor, u8 precision)
  958. {
  959. u32 quotient, remainder;
  960. if (divisor == 0)
  961. return 0;
  962. quotient = dividend / divisor;
  963. remainder = dividend % divisor;
  964. while (precision > 0) {
  965. quotient <<= 1;
  966. if (remainder << 1 >= divisor) {
  967. quotient++;
  968. remainder = (remainder << 1) - divisor;
  969. }
  970. precision--;
  971. }
  972. if (remainder << 1 >= divisor)
  973. quotient++;
  974. return quotient;
  975. }
  976. /* Read the TX power control mode from hardware. */
  977. static void lpphy_read_tx_pctl_mode_from_hardware(struct b43_wldev *dev)
  978. {
  979. struct b43_phy_lp *lpphy = dev->phy.lp;
  980. u16 ctl;
  981. ctl = b43_phy_read(dev, B43_LPPHY_TX_PWR_CTL_CMD);
  982. switch (ctl & B43_LPPHY_TX_PWR_CTL_CMD_MODE) {
  983. case B43_LPPHY_TX_PWR_CTL_CMD_MODE_OFF:
  984. lpphy->txpctl_mode = B43_LPPHY_TXPCTL_OFF;
  985. break;
  986. case B43_LPPHY_TX_PWR_CTL_CMD_MODE_SW:
  987. lpphy->txpctl_mode = B43_LPPHY_TXPCTL_SW;
  988. break;
  989. case B43_LPPHY_TX_PWR_CTL_CMD_MODE_HW:
  990. lpphy->txpctl_mode = B43_LPPHY_TXPCTL_HW;
  991. break;
  992. default:
  993. lpphy->txpctl_mode = B43_LPPHY_TXPCTL_UNKNOWN;
  994. B43_WARN_ON(1);
  995. break;
  996. }
  997. }
  998. /* Set the TX power control mode in hardware. */
  999. static void lpphy_write_tx_pctl_mode_to_hardware(struct b43_wldev *dev)
  1000. {
  1001. struct b43_phy_lp *lpphy = dev->phy.lp;
  1002. u16 ctl;
  1003. switch (lpphy->txpctl_mode) {
  1004. case B43_LPPHY_TXPCTL_OFF:
  1005. ctl = B43_LPPHY_TX_PWR_CTL_CMD_MODE_OFF;
  1006. break;
  1007. case B43_LPPHY_TXPCTL_HW:
  1008. ctl = B43_LPPHY_TX_PWR_CTL_CMD_MODE_HW;
  1009. break;
  1010. case B43_LPPHY_TXPCTL_SW:
  1011. ctl = B43_LPPHY_TX_PWR_CTL_CMD_MODE_SW;
  1012. break;
  1013. default:
  1014. ctl = 0;
  1015. B43_WARN_ON(1);
  1016. }
  1017. b43_phy_maskset(dev, B43_LPPHY_TX_PWR_CTL_CMD,
  1018. ~B43_LPPHY_TX_PWR_CTL_CMD_MODE & 0xFFFF, ctl);
  1019. }
  1020. static void lpphy_set_tx_power_control(struct b43_wldev *dev,
  1021. enum b43_lpphy_txpctl_mode mode)
  1022. {
  1023. struct b43_phy_lp *lpphy = dev->phy.lp;
  1024. enum b43_lpphy_txpctl_mode oldmode;
  1025. lpphy_read_tx_pctl_mode_from_hardware(dev);
  1026. oldmode = lpphy->txpctl_mode;
  1027. if (oldmode == mode)
  1028. return;
  1029. lpphy->txpctl_mode = mode;
  1030. if (oldmode == B43_LPPHY_TXPCTL_HW) {
  1031. //TODO Update TX Power NPT
  1032. //TODO Clear all TX Power offsets
  1033. } else {
  1034. if (mode == B43_LPPHY_TXPCTL_HW) {
  1035. //TODO Recalculate target TX power
  1036. b43_phy_maskset(dev, B43_LPPHY_TX_PWR_CTL_CMD,
  1037. 0xFF80, lpphy->tssi_idx);
  1038. b43_phy_maskset(dev, B43_LPPHY_TX_PWR_CTL_NNUM,
  1039. 0x8FFF, ((u16)lpphy->tssi_npt << 16));
  1040. //TODO Set "TSSI Transmit Count" variable to total transmitted frame count
  1041. lpphy_disable_tx_gain_override(dev);
  1042. lpphy->tx_pwr_idx_over = -1;
  1043. }
  1044. }
  1045. if (dev->phy.rev >= 2) {
  1046. if (mode == B43_LPPHY_TXPCTL_HW)
  1047. b43_phy_set(dev, B43_PHY_OFDM(0xD0), 0x2);
  1048. else
  1049. b43_phy_mask(dev, B43_PHY_OFDM(0xD0), 0xFFFD);
  1050. }
  1051. lpphy_write_tx_pctl_mode_to_hardware(dev);
  1052. }
  1053. static int b43_lpphy_op_switch_channel(struct b43_wldev *dev,
  1054. unsigned int new_channel);
  1055. static void lpphy_rev0_1_rc_calib(struct b43_wldev *dev)
  1056. {
  1057. struct b43_phy_lp *lpphy = dev->phy.lp;
  1058. struct lpphy_iq_est iq_est;
  1059. struct lpphy_tx_gains tx_gains;
  1060. static const u32 ideal_pwr_table[21] = {
  1061. 0x10000, 0x10557, 0x10e2d, 0x113e0, 0x10f22, 0x0ff64,
  1062. 0x0eda2, 0x0e5d4, 0x0efd1, 0x0fbe8, 0x0b7b8, 0x04b35,
  1063. 0x01a5e, 0x00a0b, 0x00444, 0x001fd, 0x000ff, 0x00088,
  1064. 0x0004c, 0x0002c, 0x0001a,
  1065. };
  1066. bool old_txg_ovr;
  1067. u8 old_bbmult;
  1068. u16 old_rf_ovr, old_rf_ovrval, old_afe_ovr, old_afe_ovrval,
  1069. old_rf2_ovr, old_rf2_ovrval, old_phy_ctl;
  1070. enum b43_lpphy_txpctl_mode old_txpctl;
  1071. u32 normal_pwr, ideal_pwr, mean_sq_pwr, tmp = 0, mean_sq_pwr_min = 0;
  1072. int loopback, i, j, inner_sum, err;
  1073. memset(&iq_est, 0, sizeof(iq_est));
  1074. err = b43_lpphy_op_switch_channel(dev, 7);
  1075. if (err) {
  1076. b43dbg(dev->wl,
  1077. "RC calib: Failed to switch to channel 7, error = %d\n",
  1078. err);
  1079. }
  1080. old_txg_ovr = !!(b43_phy_read(dev, B43_LPPHY_AFE_CTL_OVR) & 0x40);
  1081. old_bbmult = lpphy_get_bb_mult(dev);
  1082. if (old_txg_ovr)
  1083. tx_gains = lpphy_get_tx_gains(dev);
  1084. old_rf_ovr = b43_phy_read(dev, B43_LPPHY_RF_OVERRIDE_0);
  1085. old_rf_ovrval = b43_phy_read(dev, B43_LPPHY_RF_OVERRIDE_VAL_0);
  1086. old_afe_ovr = b43_phy_read(dev, B43_LPPHY_AFE_CTL_OVR);
  1087. old_afe_ovrval = b43_phy_read(dev, B43_LPPHY_AFE_CTL_OVRVAL);
  1088. old_rf2_ovr = b43_phy_read(dev, B43_LPPHY_RF_OVERRIDE_2);
  1089. old_rf2_ovrval = b43_phy_read(dev, B43_LPPHY_RF_OVERRIDE_2_VAL);
  1090. old_phy_ctl = b43_phy_read(dev, B43_LPPHY_LP_PHY_CTL);
  1091. lpphy_read_tx_pctl_mode_from_hardware(dev);
  1092. old_txpctl = lpphy->txpctl_mode;
  1093. lpphy_set_tx_power_control(dev, B43_LPPHY_TXPCTL_OFF);
  1094. lpphy_disable_crs(dev, true);
  1095. loopback = lpphy_loopback(dev);
  1096. if (loopback == -1)
  1097. goto finish;
  1098. lpphy_set_rx_gain_by_index(dev, loopback);
  1099. b43_phy_maskset(dev, B43_LPPHY_LP_PHY_CTL, 0xFFBF, 0x40);
  1100. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xFFF8, 0x1);
  1101. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xFFC7, 0x8);
  1102. b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xFF3F, 0xC0);
  1103. for (i = 128; i <= 159; i++) {
  1104. b43_radio_write(dev, B2062_N_RXBB_CALIB2, i);
  1105. inner_sum = 0;
  1106. for (j = 5; j <= 25; j++) {
  1107. lpphy_run_ddfs(dev, 1, 1, j, j, 0);
  1108. if (!(lpphy_rx_iq_est(dev, 1000, 32, &iq_est)))
  1109. goto finish;
  1110. mean_sq_pwr = iq_est.i_pwr + iq_est.q_pwr;
  1111. if (j == 5)
  1112. tmp = mean_sq_pwr;
  1113. ideal_pwr = ((ideal_pwr_table[j-5] >> 3) + 1) >> 1;
  1114. normal_pwr = lpphy_qdiv_roundup(mean_sq_pwr, tmp, 12);
  1115. mean_sq_pwr = ideal_pwr - normal_pwr;
  1116. mean_sq_pwr *= mean_sq_pwr;
  1117. inner_sum += mean_sq_pwr;
  1118. if ((i == 128) || (inner_sum < mean_sq_pwr_min)) {
  1119. lpphy->rc_cap = i;
  1120. mean_sq_pwr_min = inner_sum;
  1121. }
  1122. }
  1123. }
  1124. lpphy_stop_ddfs(dev);
  1125. finish:
  1126. lpphy_restore_crs(dev, true);
  1127. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, old_rf_ovrval);
  1128. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_0, old_rf_ovr);
  1129. b43_phy_write(dev, B43_LPPHY_AFE_CTL_OVRVAL, old_afe_ovrval);
  1130. b43_phy_write(dev, B43_LPPHY_AFE_CTL_OVR, old_afe_ovr);
  1131. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, old_rf2_ovrval);
  1132. b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_2, old_rf2_ovr);
  1133. b43_phy_write(dev, B43_LPPHY_LP_PHY_CTL, old_phy_ctl);
  1134. lpphy_set_bb_mult(dev, old_bbmult);
  1135. if (old_txg_ovr) {
  1136. /*
  1137. * SPEC FIXME: The specs say "get_tx_gains" here, which is
  1138. * illogical. According to lwfinger, vendor driver v4.150.10.5
  1139. * has a Set here, while v4.174.64.19 has a Get - regression in
  1140. * the vendor driver? This should be tested this once the code
  1141. * is testable.
  1142. */
  1143. lpphy_set_tx_gains(dev, tx_gains);
  1144. }
  1145. lpphy_set_tx_power_control(dev, old_txpctl);
  1146. if (lpphy->rc_cap)
  1147. lpphy_set_rc_cap(dev);
  1148. }
  1149. static void lpphy_rev2plus_rc_calib(struct b43_wldev *dev)
  1150. {
  1151. struct ssb_bus *bus = dev->dev->sdev->bus;
  1152. u32 crystal_freq = bus->chipco.pmu.crystalfreq * 1000;
  1153. u8 tmp = b43_radio_read(dev, B2063_RX_BB_SP8) & 0xFF;
  1154. int i;
  1155. b43_radio_write(dev, B2063_RX_BB_SP8, 0x0);
  1156. b43_radio_write(dev, B2063_RC_CALIB_CTL1, 0x7E);
  1157. b43_radio_mask(dev, B2063_PLL_SP1, 0xF7);
  1158. b43_radio_write(dev, B2063_RC_CALIB_CTL1, 0x7C);
  1159. b43_radio_write(dev, B2063_RC_CALIB_CTL2, 0x15);
  1160. b43_radio_write(dev, B2063_RC_CALIB_CTL3, 0x70);
  1161. b43_radio_write(dev, B2063_RC_CALIB_CTL4, 0x52);
  1162. b43_radio_write(dev, B2063_RC_CALIB_CTL5, 0x1);
  1163. b43_radio_write(dev, B2063_RC_CALIB_CTL1, 0x7D);
  1164. for (i = 0; i < 10000; i++) {
  1165. if (b43_radio_read(dev, B2063_RC_CALIB_CTL6) & 0x2)
  1166. break;
  1167. msleep(1);
  1168. }
  1169. if (!(b43_radio_read(dev, B2063_RC_CALIB_CTL6) & 0x2))
  1170. b43_radio_write(dev, B2063_RX_BB_SP8, tmp);
  1171. tmp = b43_radio_read(dev, B2063_TX_BB_SP3) & 0xFF;
  1172. b43_radio_write(dev, B2063_TX_BB_SP3, 0x0);
  1173. b43_radio_write(dev, B2063_RC_CALIB_CTL1, 0x7E);
  1174. b43_radio_write(dev, B2063_RC_CALIB_CTL1, 0x7C);
  1175. b43_radio_write(dev, B2063_RC_CALIB_CTL2, 0x55);
  1176. b43_radio_write(dev, B2063_RC_CALIB_CTL3, 0x76);
  1177. if (crystal_freq == 24000000) {
  1178. b43_radio_write(dev, B2063_RC_CALIB_CTL4, 0xFC);
  1179. b43_radio_write(dev, B2063_RC_CALIB_CTL5, 0x0);
  1180. } else {
  1181. b43_radio_write(dev, B2063_RC_CALIB_CTL4, 0x13);
  1182. b43_radio_write(dev, B2063_RC_CALIB_CTL5, 0x1);
  1183. }
  1184. b43_radio_write(dev, B2063_PA_SP7, 0x7D);
  1185. for (i = 0; i < 10000; i++) {
  1186. if (b43_radio_read(dev, B2063_RC_CALIB_CTL6) & 0x2)
  1187. break;
  1188. msleep(1);
  1189. }
  1190. if (!(b43_radio_read(dev, B2063_RC_CALIB_CTL6) & 0x2))
  1191. b43_radio_write(dev, B2063_TX_BB_SP3, tmp);
  1192. b43_radio_write(dev, B2063_RC_CALIB_CTL1, 0x7E);
  1193. }
  1194. static void lpphy_calibrate_rc(struct b43_wldev *dev)
  1195. {
  1196. struct b43_phy_lp *lpphy = dev->phy.lp;
  1197. if (dev->phy.rev >= 2) {
  1198. lpphy_rev2plus_rc_calib(dev);
  1199. } else if (!lpphy->rc_cap) {
  1200. if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
  1201. lpphy_rev0_1_rc_calib(dev);
  1202. } else {
  1203. lpphy_set_rc_cap(dev);
  1204. }
  1205. }
  1206. static void b43_lpphy_op_set_rx_antenna(struct b43_wldev *dev, int antenna)
  1207. {
  1208. if (dev->phy.rev >= 2)
  1209. return; // rev2+ doesn't support antenna diversity
  1210. if (B43_WARN_ON(antenna > B43_ANTENNA_AUTO1))
  1211. return;
  1212. b43_hf_write(dev, b43_hf_read(dev) & ~B43_HF_ANTDIVHELP);
  1213. b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL, 0xFFFD, antenna & 0x2);
  1214. b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL, 0xFFFE, antenna & 0x1);
  1215. b43_hf_write(dev, b43_hf_read(dev) | B43_HF_ANTDIVHELP);
  1216. dev->phy.lp->antenna = antenna;
  1217. }
  1218. static void lpphy_set_tx_iqcc(struct b43_wldev *dev, u16 a, u16 b)
  1219. {
  1220. u16 tmp[2];
  1221. tmp[0] = a;
  1222. tmp[1] = b;
  1223. b43_lptab_write_bulk(dev, B43_LPTAB16(0, 80), 2, tmp);
  1224. }
  1225. static void lpphy_set_tx_power_by_index(struct b43_wldev *dev, u8 index)
  1226. {
  1227. struct b43_phy_lp *lpphy = dev->phy.lp;
  1228. struct lpphy_tx_gains gains;
  1229. u32 iq_comp, tx_gain, coeff, rf_power;
  1230. lpphy->tx_pwr_idx_over = index;
  1231. lpphy_read_tx_pctl_mode_from_hardware(dev);
  1232. if (lpphy->txpctl_mode != B43_LPPHY_TXPCTL_OFF)
  1233. lpphy_set_tx_power_control(dev, B43_LPPHY_TXPCTL_SW);
  1234. if (dev->phy.rev >= 2) {
  1235. iq_comp = b43_lptab_read(dev, B43_LPTAB32(7, index + 320));
  1236. tx_gain = b43_lptab_read(dev, B43_LPTAB32(7, index + 192));
  1237. gains.pad = (tx_gain >> 16) & 0xFF;
  1238. gains.gm = tx_gain & 0xFF;
  1239. gains.pga = (tx_gain >> 8) & 0xFF;
  1240. gains.dac = (iq_comp >> 28) & 0xFF;
  1241. lpphy_set_tx_gains(dev, gains);
  1242. } else {
  1243. iq_comp = b43_lptab_read(dev, B43_LPTAB32(10, index + 320));
  1244. tx_gain = b43_lptab_read(dev, B43_LPTAB32(10, index + 192));
  1245. b43_phy_maskset(dev, B43_LPPHY_TX_GAIN_CTL_OVERRIDE_VAL,
  1246. 0xF800, (tx_gain >> 4) & 0x7FFF);
  1247. lpphy_set_dac_gain(dev, tx_gain & 0x7);
  1248. lpphy_set_pa_gain(dev, (tx_gain >> 24) & 0x7F);
  1249. }
  1250. lpphy_set_bb_mult(dev, (iq_comp >> 20) & 0xFF);
  1251. lpphy_set_tx_iqcc(dev, (iq_comp >> 10) & 0x3FF, iq_comp & 0x3FF);
  1252. if (dev->phy.rev >= 2) {
  1253. coeff = b43_lptab_read(dev, B43_LPTAB32(7, index + 448));
  1254. } else {
  1255. coeff = b43_lptab_read(dev, B43_LPTAB32(10, index + 448));
  1256. }
  1257. b43_lptab_write(dev, B43_LPTAB16(0, 85), coeff & 0xFFFF);
  1258. if (dev->phy.rev >= 2) {
  1259. rf_power = b43_lptab_read(dev, B43_LPTAB32(7, index + 576));
  1260. b43_phy_maskset(dev, B43_LPPHY_RF_PWR_OVERRIDE, 0xFF00,
  1261. rf_power & 0xFFFF);//SPEC FIXME mask & set != 0
  1262. }
  1263. lpphy_enable_tx_gain_override(dev);
  1264. }
  1265. static void lpphy_btcoex_override(struct b43_wldev *dev)
  1266. {
  1267. b43_write16(dev, B43_MMIO_BTCOEX_CTL, 0x3);
  1268. b43_write16(dev, B43_MMIO_BTCOEX_TXCTL, 0xFF);
  1269. }
  1270. static void b43_lpphy_op_software_rfkill(struct b43_wldev *dev,
  1271. bool blocked)
  1272. {
  1273. //TODO check MAC control register
  1274. if (blocked) {
  1275. if (dev->phy.rev >= 2) {
  1276. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0x83FF);
  1277. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x1F00);
  1278. b43_phy_mask(dev, B43_LPPHY_AFE_DDFS, 0x80FF);
  1279. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xDFFF);
  1280. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x0808);
  1281. } else {
  1282. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_VAL_0, 0xE0FF);
  1283. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x1F00);
  1284. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2_VAL, 0xFCFF);
  1285. b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x0018);
  1286. }
  1287. } else {
  1288. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_0, 0xE0FF);
  1289. if (dev->phy.rev >= 2)
  1290. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xF7F7);
  1291. else
  1292. b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFFE7);
  1293. }
  1294. }
  1295. /* This was previously called lpphy_japan_filter */
  1296. static void lpphy_set_analog_filter(struct b43_wldev *dev, int channel)
  1297. {
  1298. struct b43_phy_lp *lpphy = dev->phy.lp;
  1299. u16 tmp = (channel == 14); //SPEC FIXME check japanwidefilter!
  1300. if (dev->phy.rev < 2) { //SPEC FIXME Isn't this rev0/1-specific?
  1301. b43_phy_maskset(dev, B43_LPPHY_LP_PHY_CTL, 0xFCFF, tmp << 9);
  1302. if ((dev->phy.rev == 1) && (lpphy->rc_cap))
  1303. lpphy_set_rc_cap(dev);
  1304. } else {
  1305. b43_radio_write(dev, B2063_TX_BB_SP3, 0x3F);
  1306. }
  1307. }
  1308. sta