3 Broadcom B43 wireless driver
5 Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>,
6 Copyright (c) 2005, 2006 Stefano Brivio <st3@riseup.net>
7 Copyright (c) 2005, 2006 Michael Buesch <mb@bu3sch.de>
8 Copyright (c) 2005, 2006 Danny van Dyk <kugelfang@gentoo.org>
9 Copyright (c) 2005, 2006 Andreas Jaggi <andreas.jaggi@waterwave.ch>
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; see the file COPYING. If not, write to
23 the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
24 Boston, MA 02110-1301, USA.
28 #include <linux/delay.h>
29 #include <linux/types.h>
37 static const s8 b43_tssi2dbm_b_table
[] = {
38 0x4D, 0x4C, 0x4B, 0x4A,
39 0x4A, 0x49, 0x48, 0x47,
40 0x47, 0x46, 0x45, 0x45,
41 0x44, 0x43, 0x42, 0x42,
42 0x41, 0x40, 0x3F, 0x3E,
43 0x3D, 0x3C, 0x3B, 0x3A,
44 0x39, 0x38, 0x37, 0x36,
45 0x35, 0x34, 0x32, 0x31,
46 0x30, 0x2F, 0x2D, 0x2C,
47 0x2B, 0x29, 0x28, 0x26,
48 0x25, 0x23, 0x21, 0x1F,
49 0x1D, 0x1A, 0x17, 0x14,
50 0x10, 0x0C, 0x06, 0x00,
56 static const s8 b43_tssi2dbm_g_table
[] = {
75 const u8 b43_radio_channel_codes_bg
[] = {
82 static void b43_phy_initg(struct b43_wldev
*dev
);
84 /* Reverse the bits of a 4bit value.
85 * Example: 1101 is flipped 1011
87 static u16
flip_4bit(u16 value
)
91 B43_WARN_ON(value
& ~0x000F);
93 flipped
|= (value
& 0x0001) << 3;
94 flipped
|= (value
& 0x0002) << 1;
95 flipped
|= (value
& 0x0004) >> 1;
96 flipped
|= (value
& 0x0008) >> 3;
101 static void generate_rfatt_list(struct b43_wldev
*dev
,
102 struct b43_rfatt_list
*list
)
104 struct b43_phy
*phy
= &dev
->phy
;
106 /* APHY.rev < 5 || GPHY.rev < 6 */
107 static const struct b43_rfatt rfatt_0
[] = {
108 {.att
= 3,.with_padmix
= 0,},
109 {.att
= 1,.with_padmix
= 0,},
110 {.att
= 5,.with_padmix
= 0,},
111 {.att
= 7,.with_padmix
= 0,},
112 {.att
= 9,.with_padmix
= 0,},
113 {.att
= 2,.with_padmix
= 0,},
114 {.att
= 0,.with_padmix
= 0,},
115 {.att
= 4,.with_padmix
= 0,},
116 {.att
= 6,.with_padmix
= 0,},
117 {.att
= 8,.with_padmix
= 0,},
118 {.att
= 1,.with_padmix
= 1,},
119 {.att
= 2,.with_padmix
= 1,},
120 {.att
= 3,.with_padmix
= 1,},
121 {.att
= 4,.with_padmix
= 1,},
123 /* Radio.rev == 8 && Radio.version == 0x2050 */
124 static const struct b43_rfatt rfatt_1
[] = {
125 {.att
= 2,.with_padmix
= 1,},
126 {.att
= 4,.with_padmix
= 1,},
127 {.att
= 6,.with_padmix
= 1,},
128 {.att
= 8,.with_padmix
= 1,},
129 {.att
= 10,.with_padmix
= 1,},
130 {.att
= 12,.with_padmix
= 1,},
131 {.att
= 14,.with_padmix
= 1,},
134 static const struct b43_rfatt rfatt_2
[] = {
135 {.att
= 0,.with_padmix
= 1,},
136 {.att
= 2,.with_padmix
= 1,},
137 {.att
= 4,.with_padmix
= 1,},
138 {.att
= 6,.with_padmix
= 1,},
139 {.att
= 8,.with_padmix
= 1,},
140 {.att
= 9,.with_padmix
= 1,},
141 {.att
= 9,.with_padmix
= 1,},
144 if ((phy
->type
== B43_PHYTYPE_A
&& phy
->rev
< 5) ||
145 (phy
->type
== B43_PHYTYPE_G
&& phy
->rev
< 6)) {
147 list
->list
= rfatt_0
;
148 list
->len
= ARRAY_SIZE(rfatt_0
);
153 if (phy
->radio_ver
== 0x2050 && phy
->radio_rev
== 8) {
155 list
->list
= rfatt_1
;
156 list
->len
= ARRAY_SIZE(rfatt_1
);
162 list
->list
= rfatt_2
;
163 list
->len
= ARRAY_SIZE(rfatt_2
);
168 static void generate_bbatt_list(struct b43_wldev
*dev
,
169 struct b43_bbatt_list
*list
)
171 static const struct b43_bbatt bbatt_0
[] = {
183 list
->list
= bbatt_0
;
184 list
->len
= ARRAY_SIZE(bbatt_0
);
189 bool b43_has_hardware_pctl(struct b43_phy
*phy
)
191 if (!phy
->hardware_power_control
)
208 static void b43_shm_clear_tssi(struct b43_wldev
*dev
)
210 struct b43_phy
*phy
= &dev
->phy
;
214 b43_shm_write16(dev
, B43_SHM_SHARED
, 0x0068, 0x7F7F);
215 b43_shm_write16(dev
, B43_SHM_SHARED
, 0x006a, 0x7F7F);
219 b43_shm_write16(dev
, B43_SHM_SHARED
, 0x0058, 0x7F7F);
220 b43_shm_write16(dev
, B43_SHM_SHARED
, 0x005a, 0x7F7F);
221 b43_shm_write16(dev
, B43_SHM_SHARED
, 0x0070, 0x7F7F);
222 b43_shm_write16(dev
, B43_SHM_SHARED
, 0x0072, 0x7F7F);
227 void b43_raw_phy_lock(struct b43_wldev
*dev
)
229 struct b43_phy
*phy
= &dev
->phy
;
231 B43_WARN_ON(!irqs_disabled());
233 /* We had a check for MACCTL==0 here, but I think that doesn't
234 * make sense, as MACCTL is never 0 when this is called.
236 B43_WARN_ON(b43_read32(dev
, B43_MMIO_MACCTL
) == 0);
238 if (dev
->dev
->id
.revision
< 3) {
239 b43_mac_suspend(dev
);
240 spin_lock(&phy
->lock
);
242 if (!b43_is_mode(dev
->wl
, IEEE80211_IF_TYPE_AP
))
243 b43_power_saving_ctl_bits(dev
, B43_PS_AWAKE
);
248 void b43_raw_phy_unlock(struct b43_wldev
*dev
)
250 struct b43_phy
*phy
= &dev
->phy
;
252 B43_WARN_ON(!irqs_disabled());
253 if (dev
->dev
->id
.revision
< 3) {
255 spin_unlock(&phy
->lock
);
259 if (!b43_is_mode(dev
->wl
, IEEE80211_IF_TYPE_AP
))
260 b43_power_saving_ctl_bits(dev
, 0);
265 /* Different PHYs require different register routing flags.
266 * This adjusts (and does sanity checks on) the routing flags.
268 static inline u16
adjust_phyreg_for_phytype(struct b43_phy
*phy
,
269 u16 offset
, struct b43_wldev
*dev
)
271 if (phy
->type
== B43_PHYTYPE_A
) {
272 /* OFDM registers are base-registers for the A-PHY. */
273 offset
&= ~B43_PHYROUTE_OFDM_GPHY
;
275 if (offset
& B43_PHYROUTE_EXT_GPHY
) {
276 /* Ext-G registers are only available on G-PHYs */
277 if (phy
->type
!= B43_PHYTYPE_G
) {
278 b43dbg(dev
->wl
, "EXT-G PHY access at "
279 "0x%04X on %u type PHY\n", offset
, phy
->type
);
286 u16
b43_phy_read(struct b43_wldev
* dev
, u16 offset
)
288 struct b43_phy
*phy
= &dev
->phy
;
290 offset
= adjust_phyreg_for_phytype(phy
, offset
, dev
);
291 b43_write16(dev
, B43_MMIO_PHY_CONTROL
, offset
);
292 return b43_read16(dev
, B43_MMIO_PHY_DATA
);
295 void b43_phy_write(struct b43_wldev
*dev
, u16 offset
, u16 val
)
297 struct b43_phy
*phy
= &dev
->phy
;
299 offset
= adjust_phyreg_for_phytype(phy
, offset
, dev
);
300 b43_write16(dev
, B43_MMIO_PHY_CONTROL
, offset
);
302 b43_write16(dev
, B43_MMIO_PHY_DATA
, val
);
305 static void b43_radio_set_txpower_a(struct b43_wldev
*dev
, u16 txpower
);
307 /* Adjust the transmission power output (G-PHY) */
308 void b43_set_txpower_g(struct b43_wldev
*dev
,
309 const struct b43_bbatt
*bbatt
,
310 const struct b43_rfatt
*rfatt
, u8 tx_control
)
312 struct b43_phy
*phy
= &dev
->phy
;
313 struct b43_txpower_lo_control
*lo
= phy
->lo_control
;
315 u16 tx_bias
, tx_magn
;
319 tx_bias
= lo
->tx_bias
;
320 tx_magn
= lo
->tx_magn
;
321 if (unlikely(tx_bias
== 0xFF))
324 /* Save the values for later */
325 phy
->tx_control
= tx_control
;
326 memcpy(&phy
->rfatt
, rfatt
, sizeof(*rfatt
));
327 memcpy(&phy
->bbatt
, bbatt
, sizeof(*bbatt
));
329 if (b43_debug(dev
, B43_DBG_XMITPOWER
)) {
330 b43dbg(dev
->wl
, "Tuning TX-power to bbatt(%u), "
331 "rfatt(%u), tx_control(0x%02X), "
332 "tx_bias(0x%02X), tx_magn(0x%02X)\n",
333 bb
, rf
, tx_control
, tx_bias
, tx_magn
);
336 b43_phy_set_baseband_attenuation(dev
, bb
);
337 b43_shm_write16(dev
, B43_SHM_SHARED
, B43_SHM_SH_RFATT
, rf
);
338 if (phy
->radio_ver
== 0x2050 && phy
->radio_rev
== 8) {
339 b43_radio_write16(dev
, 0x43,
340 (rf
& 0x000F) | (tx_control
& 0x0070));
342 b43_radio_write16(dev
, 0x43, (b43_radio_read16(dev
, 0x43)
343 & 0xFFF0) | (rf
& 0x000F));
344 b43_radio_write16(dev
, 0x52, (b43_radio_read16(dev
, 0x52)
345 & ~0x0070) | (tx_control
&
348 if (has_tx_magnification(phy
)) {
349 b43_radio_write16(dev
, 0x52, tx_magn
| tx_bias
);
351 b43_radio_write16(dev
, 0x52, (b43_radio_read16(dev
, 0x52)
352 & 0xFFF0) | (tx_bias
& 0x000F));
354 if (phy
->type
== B43_PHYTYPE_G
)
355 b43_lo_g_adjust(dev
);
358 static void default_baseband_attenuation(struct b43_wldev
*dev
,
359 struct b43_bbatt
*bb
)
361 struct b43_phy
*phy
= &dev
->phy
;
363 if (phy
->radio_ver
== 0x2050 && phy
->radio_rev
< 6)
369 static void default_radio_attenuation(struct b43_wldev
*dev
,
370 struct b43_rfatt
*rf
)
372 struct ssb_bus
*bus
= dev
->dev
->bus
;
373 struct b43_phy
*phy
= &dev
->phy
;
377 if (bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
&&
378 bus
->boardinfo
.type
== SSB_BOARD_BCM4309G
) {
379 if (bus
->boardinfo
.rev
< 0x43) {
382 } else if (bus
->boardinfo
.rev
< 0x51) {
388 if (phy
->type
== B43_PHYTYPE_A
) {
393 switch (phy
->radio_ver
) {
395 switch (phy
->radio_rev
) {
402 switch (phy
->radio_rev
) {
407 if (phy
->type
== B43_PHYTYPE_G
) {
408 if (bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
409 && bus
->boardinfo
.type
== SSB_BOARD_BCM4309G
410 && bus
->boardinfo
.rev
>= 30)
412 else if (bus
->boardinfo
.vendor
==
414 && bus
->boardinfo
.type
==
420 if (bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
421 && bus
->boardinfo
.type
== SSB_BOARD_BCM4309G
422 && bus
->boardinfo
.rev
>= 30)
429 if (phy
->type
== B43_PHYTYPE_G
) {
430 if (bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
431 && bus
->boardinfo
.type
== SSB_BOARD_BCM4309G
432 && bus
->boardinfo
.rev
>= 30)
434 else if (bus
->boardinfo
.vendor
==
436 && bus
->boardinfo
.type
==
439 else if (bus
->chip_id
== 0x4320)
470 static u16
default_tx_control(struct b43_wldev
*dev
)
472 struct b43_phy
*phy
= &dev
->phy
;
474 if (phy
->radio_ver
!= 0x2050)
476 if (phy
->radio_rev
== 1)
477 return B43_TXCTL_PA2DB
| B43_TXCTL_TXMIX
;
478 if (phy
->radio_rev
< 6)
479 return B43_TXCTL_PA2DB
;
480 if (phy
->radio_rev
== 8)
481 return B43_TXCTL_TXMIX
;
485 /* This func is called "PHY calibrate" in the specs... */
486 void b43_phy_early_init(struct b43_wldev
*dev
)
488 struct b43_phy
*phy
= &dev
->phy
;
489 struct b43_txpower_lo_control
*lo
= phy
->lo_control
;
491 default_baseband_attenuation(dev
, &phy
->bbatt
);
492 default_radio_attenuation(dev
, &phy
->rfatt
);
493 phy
->tx_control
= (default_tx_control(dev
) << 4);
495 /* Commit previous writes */
496 b43_read32(dev
, B43_MMIO_MACCTL
);
498 if (phy
->type
== B43_PHYTYPE_B
|| phy
->type
== B43_PHYTYPE_G
) {
499 generate_rfatt_list(dev
, &lo
->rfatt_list
);
500 generate_bbatt_list(dev
, &lo
->bbatt_list
);
502 if (phy
->type
== B43_PHYTYPE_G
&& phy
->rev
== 1) {
503 /* Workaround: Temporarly disable gmode through the early init
504 * phase, as the gmode stuff is not needed for phy rev 1 */
506 b43_wireless_core_reset(dev
, 0);
509 b43_wireless_core_reset(dev
, B43_TMSLOW_GMODE
);
513 /* GPHY_TSSI_Power_Lookup_Table_Init */
514 static void b43_gphy_tssi_power_lt_init(struct b43_wldev
*dev
)
516 struct b43_phy
*phy
= &dev
->phy
;
520 for (i
= 0; i
< 32; i
++)
521 b43_ofdmtab_write16(dev
, 0x3C20, i
, phy
->tssi2dbm
[i
]);
522 for (i
= 32; i
< 64; i
++)
523 b43_ofdmtab_write16(dev
, 0x3C00, i
- 32, phy
->tssi2dbm
[i
]);
524 for (i
= 0; i
< 64; i
+= 2) {
525 value
= (u16
) phy
->tssi2dbm
[i
];
526 value
|= ((u16
) phy
->tssi2dbm
[i
+ 1]) << 8;
527 b43_phy_write(dev
, 0x380 + (i
/ 2), value
);
531 /* GPHY_Gain_Lookup_Table_Init */
532 static void b43_gphy_gain_lt_init(struct b43_wldev
*dev
)
534 struct b43_phy
*phy
= &dev
->phy
;
535 struct b43_txpower_lo_control
*lo
= phy
->lo_control
;
540 if (!lo
->lo_measured
) {
541 b43_phy_write(dev
, 0x3FF, 0);
545 for (rf
= 0; rf
< lo
->rfatt_list
.len
; rf
++) {
546 for (bb
= 0; bb
< lo
->bbatt_list
.len
; bb
++) {
547 if (nr_written
>= 0x40)
549 tmp
= lo
->bbatt_list
.list
[bb
].att
;
551 if (phy
->radio_rev
== 8)
555 tmp
|= lo
->rfatt_list
.list
[rf
].att
;
556 b43_phy_write(dev
, 0x3C0 + nr_written
, tmp
);
562 /* GPHY_DC_Lookup_Table */
563 void b43_gphy_dc_lt_init(struct b43_wldev
*dev
)
565 struct b43_phy
*phy
= &dev
->phy
;
566 struct b43_txpower_lo_control
*lo
= phy
->lo_control
;
567 struct b43_loctl
*loctl0
;
568 struct b43_loctl
*loctl1
;
570 int rf_offset
, bb_offset
;
573 for (i
= 0; i
< lo
->rfatt_list
.len
+ lo
->bbatt_list
.len
; i
+= 2) {
574 rf_offset
= i
/ lo
->rfatt_list
.len
;
575 bb_offset
= i
% lo
->rfatt_list
.len
;
577 loctl0
= b43_get_lo_g_ctl(dev
, &lo
->rfatt_list
.list
[rf_offset
],
578 &lo
->bbatt_list
.list
[bb_offset
]);
579 if (i
+ 1 < lo
->rfatt_list
.len
* lo
->bbatt_list
.len
) {
580 rf_offset
= (i
+ 1) / lo
->rfatt_list
.len
;
581 bb_offset
= (i
+ 1) % lo
->rfatt_list
.len
;
584 b43_get_lo_g_ctl(dev
,
585 &lo
->rfatt_list
.list
[rf_offset
],
586 &lo
->bbatt_list
.list
[bb_offset
]);
590 tmp
= ((u16
) loctl0
->q
& 0xF);
591 tmp
|= ((u16
) loctl0
->i
& 0xF) << 4;
592 tmp
|= ((u16
) loctl1
->q
& 0xF) << 8;
593 tmp
|= ((u16
) loctl1
->i
& 0xF) << 12; //FIXME?
594 b43_phy_write(dev
, 0x3A0 + (i
/ 2), tmp
);
598 static void hardware_pctl_init_aphy(struct b43_wldev
*dev
)
603 static void hardware_pctl_init_gphy(struct b43_wldev
*dev
)
605 struct b43_phy
*phy
= &dev
->phy
;
607 b43_phy_write(dev
, 0x0036, (b43_phy_read(dev
, 0x0036) & 0xFFC0)
608 | (phy
->tgt_idle_tssi
- phy
->cur_idle_tssi
));
609 b43_phy_write(dev
, 0x0478, (b43_phy_read(dev
, 0x0478) & 0xFF00)
610 | (phy
->tgt_idle_tssi
- phy
->cur_idle_tssi
));
611 b43_gphy_tssi_power_lt_init(dev
);
612 b43_gphy_gain_lt_init(dev
);
613 b43_phy_write(dev
, 0x0060, b43_phy_read(dev
, 0x0060) & 0xFFBF);
614 b43_phy_write(dev
, 0x0014, 0x0000);
616 B43_WARN_ON(phy
->rev
< 6);
617 b43_phy_write(dev
, 0x0478, b43_phy_read(dev
, 0x0478)
619 b43_phy_write(dev
, 0x0478, b43_phy_read(dev
, 0x0478)
621 b43_phy_write(dev
, 0x0801, b43_phy_read(dev
, 0x0801)
624 b43_gphy_dc_lt_init(dev
);
627 /* HardwarePowerControl init for A and G PHY */
628 static void b43_hardware_pctl_init(struct b43_wldev
*dev
)
630 struct b43_phy
*phy
= &dev
->phy
;
632 if (!b43_has_hardware_pctl(phy
)) {
633 /* No hardware power control */
634 b43_hf_write(dev
, b43_hf_read(dev
) & ~B43_HF_HWPCTL
);
637 /* Init the hwpctl related hardware */
640 hardware_pctl_init_aphy(dev
);
643 hardware_pctl_init_gphy(dev
);
648 /* Enable hardware pctl in firmware. */
649 b43_hf_write(dev
, b43_hf_read(dev
) | B43_HF_HWPCTL
);
652 static void b43_hardware_pctl_early_init(struct b43_wldev
*dev
)
654 struct b43_phy
*phy
= &dev
->phy
;
656 if (!b43_has_hardware_pctl(phy
)) {
657 b43_phy_write(dev
, 0x047A, 0xC111);
661 b43_phy_write(dev
, 0x0036, b43_phy_read(dev
, 0x0036) & 0xFEFF);
662 b43_phy_write(dev
, 0x002F, 0x0202);
663 b43_phy_write(dev
, 0x047C, b43_phy_read(dev
, 0x047C) | 0x0002);
664 b43_phy_write(dev
, 0x047A, b43_phy_read(dev
, 0x047A) | 0xF000);
665 if (phy
->radio_ver
== 0x2050 && phy
->radio_rev
== 8) {
666 b43_phy_write(dev
, 0x047A, (b43_phy_read(dev
, 0x047A)
668 b43_phy_write(dev
, 0x005D, b43_phy_read(dev
, 0x005D)
670 b43_phy_write(dev
, 0x004E, (b43_phy_read(dev
, 0x004E)
672 b43_phy_write(dev
, 0x002E, 0xC07F);
673 b43_phy_write(dev
, 0x0036, b43_phy_read(dev
, 0x0036)
676 b43_phy_write(dev
, 0x0036, b43_phy_read(dev
, 0x0036)
678 b43_phy_write(dev
, 0x0036, b43_phy_read(dev
, 0x0036)
680 b43_phy_write(dev
, 0x005D, b43_phy_read(dev
, 0x005D)
682 b43_phy_write(dev
, 0x004F, b43_phy_read(dev
, 0x004F)
684 b43_phy_write(dev
, 0x004E, (b43_phy_read(dev
, 0x004E)
686 b43_phy_write(dev
, 0x002E, 0xC07F);
687 b43_phy_write(dev
, 0x047A, (b43_phy_read(dev
, 0x047A)
692 /* Intialize B/G PHY power control
693 * as described in http://bcm-specs.sipsolutions.net/InitPowerControl
695 static void b43_phy_init_pctl(struct b43_wldev
*dev
)
697 struct ssb_bus
*bus
= dev
->dev
->bus
;
698 struct b43_phy
*phy
= &dev
->phy
;
699 struct b43_rfatt old_rfatt
;
700 struct b43_bbatt old_bbatt
;
701 u8 old_tx_control
= 0;
703 if ((bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
) &&
704 (bus
->boardinfo
.type
== SSB_BOARD_BU4306
))
707 b43_phy_write(dev
, 0x0028, 0x8018);
709 /* This does something with the Analog... */
710 b43_write16(dev
, B43_MMIO_PHY0
, b43_read16(dev
, B43_MMIO_PHY0
)
713 if (phy
->type
== B43_PHYTYPE_G
&& !phy
->gmode
)
715 b43_hardware_pctl_early_init(dev
);
716 if (phy
->cur_idle_tssi
== 0) {
717 if (phy
->radio_ver
== 0x2050 && phy
->analog
== 0) {
718 b43_radio_write16(dev
, 0x0076,
719 (b43_radio_read16(dev
, 0x0076)
722 struct b43_rfatt rfatt
;
723 struct b43_bbatt bbatt
;
725 memcpy(&old_rfatt
, &phy
->rfatt
, sizeof(old_rfatt
));
726 memcpy(&old_bbatt
, &phy
->bbatt
, sizeof(old_bbatt
));
727 old_tx_control
= phy
->tx_control
;
730 if (phy
->radio_rev
== 8) {
732 rfatt
.with_padmix
= 1;
735 rfatt
.with_padmix
= 0;
737 b43_set_txpower_g(dev
, &bbatt
, &rfatt
, 0);
739 b43_dummy_transmission(dev
);
740 phy
->cur_idle_tssi
= b43_phy_read(dev
, B43_PHY_ITSSI
);
742 /* Current-Idle-TSSI sanity check. */
743 if (abs(phy
->cur_idle_tssi
- phy
->tgt_idle_tssi
) >= 20) {
745 "!WARNING! Idle-TSSI phy->cur_idle_tssi "
746 "measuring failed. (cur=%d, tgt=%d). Disabling TX power "
747 "adjustment.\n", phy
->cur_idle_tssi
,
749 phy
->cur_idle_tssi
= 0;
752 if (phy
->radio_ver
== 0x2050 && phy
->analog
== 0) {
753 b43_radio_write16(dev
, 0x0076,
754 b43_radio_read16(dev
, 0x0076)
757 b43_set_txpower_g(dev
, &old_bbatt
,
758 &old_rfatt
, old_tx_control
);
761 b43_hardware_pctl_init(dev
);
762 b43_shm_clear_tssi(dev
);
765 static void b43_phy_agcsetup(struct b43_wldev
*dev
)
767 struct b43_phy
*phy
= &dev
->phy
;
773 b43_ofdmtab_write16(dev
, offset
, 0, 0x00FE);
774 b43_ofdmtab_write16(dev
, offset
, 1, 0x000D);
775 b43_ofdmtab_write16(dev
, offset
, 2, 0x0013);
776 b43_ofdmtab_write16(dev
, offset
, 3, 0x0019);
779 b43_ofdmtab_write16(dev
, 0x1800, 0, 0x2710);
780 b43_ofdmtab_write16(dev
, 0x1801, 0, 0x9B83);
781 b43_ofdmtab_write16(dev
, 0x1802, 0, 0x9B83);
782 b43_ofdmtab_write16(dev
, 0x1803, 0, 0x0F8D);
783 b43_phy_write(dev
, 0x0455, 0x0004);
786 b43_phy_write(dev
, 0x04A5, (b43_phy_read(dev
, 0x04A5)
788 b43_phy_write(dev
, 0x041A, (b43_phy_read(dev
, 0x041A)
790 b43_phy_write(dev
, 0x041A, (b43_phy_read(dev
, 0x041A)
792 b43_phy_write(dev
, 0x048C, (b43_phy_read(dev
, 0x048C)
795 b43_radio_write16(dev
, 0x007A, b43_radio_read16(dev
, 0x007A)
798 b43_phy_write(dev
, 0x04A0, (b43_phy_read(dev
, 0x04A0)
800 b43_phy_write(dev
, 0x04A1, (b43_phy_read(dev
, 0x04A1)
802 b43_phy_write(dev
, 0x04A2, (b43_phy_read(dev
, 0x04A2)
804 b43_phy_write(dev
, 0x04A0, (b43_phy_read(dev
, 0x04A0)
808 b43_phy_write(dev
, 0x04A2, (b43_phy_read(dev
, 0x04A2)
812 b43_phy_write(dev
, 0x0488, (b43_phy_read(dev
, 0x0488)
814 b43_phy_write(dev
, 0x0488, (b43_phy_read(dev
, 0x0488)
816 b43_phy_write(dev
, 0x0496, (b43_phy_read(dev
, 0x0496)
818 b43_phy_write(dev
, 0x0489, (b43_phy_read(dev
, 0x0489)
820 b43_phy_write(dev
, 0x0489, (b43_phy_read(dev
, 0x0489)
822 b43_phy_write(dev
, 0x0482, (b43_phy_read(dev
, 0x0482)
824 b43_phy_write(dev
, 0x0496, (b43_phy_read(dev
, 0x0496)
826 b43_phy_write(dev
, 0x0481, (b43_phy_read(dev
, 0x0481)
828 b43_phy_write(dev
, 0x0481, (b43_phy_read(dev
, 0x0481)
832 b43_phy_write(dev
, 0x0430, 0x092B);
833 b43_phy_write(dev
, 0x041B, (b43_phy_read(dev
, 0x041B)
836 b43_phy_write(dev
, 0x041B, b43_phy_read(dev
, 0x041B)
838 b43_phy_write(dev
, 0x041F, 0x287A);
839 b43_phy_write(dev
, 0x0420, (b43_phy_read(dev
, 0x0420)
844 b43_phy_write(dev
, 0x0422, 0x287A);
845 b43_phy_write(dev
, 0x0420, (b43_phy_read(dev
, 0x0420)
849 b43_phy_write(dev
, 0x04A8, (b43_phy_read(dev
, 0x04A8)
851 b43_phy_write(dev
, 0x048E, 0x1C00);
856 b43_phy_write(dev
, 0x04AB, (b43_phy_read(dev
, 0x04AB)
858 b43_phy_write(dev
, 0x048B, 0x005E);
859 b43_phy_write(dev
, 0x048C, (b43_phy_read(dev
, 0x048C)
861 b43_phy_write(dev
, 0x048D, 0x0002);
863 b43_ofdmtab_write16(dev
, offset
, 0, 0x00);
864 b43_ofdmtab_write16(dev
, offset
, 1, 0x07);
865 b43_ofdmtab_write16(dev
, offset
, 2, 0x10);
866 b43_ofdmtab_write16(dev
, offset
, 3, 0x1C);
869 b43_phy_write(dev
, 0x0426, b43_phy_read(dev
, 0x0426)
871 b43_phy_write(dev
, 0x0426, b43_phy_read(dev
, 0x0426)
876 static void b43_phy_setupg(struct b43_wldev
*dev
)
878 struct ssb_bus
*bus
= dev
->dev
->bus
;
879 struct b43_phy
*phy
= &dev
->phy
;
882 B43_WARN_ON(phy
->type
!= B43_PHYTYPE_G
);
884 b43_phy_write(dev
, 0x0406, 0x4F19);
885 b43_phy_write(dev
, B43_PHY_G_CRS
,
886 (b43_phy_read(dev
, B43_PHY_G_CRS
) & 0xFC3F) |
888 b43_phy_write(dev
, 0x042C, 0x005A);
889 b43_phy_write(dev
, 0x0427, 0x001A);
891 for (i
= 0; i
< B43_TAB_FINEFREQG_SIZE
; i
++)
892 b43_ofdmtab_write16(dev
, 0x5800, i
,
893 b43_tab_finefreqg
[i
]);
894 for (i
= 0; i
< B43_TAB_NOISEG1_SIZE
; i
++)
895 b43_ofdmtab_write16(dev
, 0x1800, i
, b43_tab_noiseg1
[i
]);
896 for (i
= 0; i
< B43_TAB_ROTOR_SIZE
; i
++)
897 b43_ofdmtab_write16(dev
, 0x2000, i
, b43_tab_rotor
[i
]);
899 /* nrssi values are signed 6-bit values. Not sure why we write 0x7654 here... */
900 b43_nrssi_hw_write(dev
, 0xBA98, (s16
) 0x7654);
903 b43_phy_write(dev
, 0x04C0, 0x1861);
904 b43_phy_write(dev
, 0x04C1, 0x0271);
905 } else if (phy
->rev
> 2) {
906 b43_phy_write(dev
, 0x04C0, 0x0098);
907 b43_phy_write(dev
, 0x04C1, 0x0070);
908 b43_phy_write(dev
, 0x04C9, 0x0080);
910 b43_phy_write(dev
, 0x042B, b43_phy_read(dev
, 0x042B) | 0x800);
912 for (i
= 0; i
< 64; i
++)
913 b43_ofdmtab_write16(dev
, 0x4000, i
, i
);
914 for (i
= 0; i
< B43_TAB_NOISEG2_SIZE
; i
++)
915 b43_ofdmtab_write16(dev
, 0x1800, i
, b43_tab_noiseg2
[i
]);
919 for (i
= 0; i
< B43_TAB_NOISESCALEG_SIZE
; i
++)
920 b43_ofdmtab_write16(dev
, 0x1400, i
,
921 b43_tab_noisescaleg1
[i
]);
922 else if ((phy
->rev
>= 7) && (b43_phy_read(dev
, 0x0449) & 0x0200))
923 for (i
= 0; i
< B43_TAB_NOISESCALEG_SIZE
; i
++)
924 b43_ofdmtab_write16(dev
, 0x1400, i
,
925 b43_tab_noisescaleg3
[i
]);
927 for (i
= 0; i
< B43_TAB_NOISESCALEG_SIZE
; i
++)
928 b43_ofdmtab_write16(dev
, 0x1400, i
,
929 b43_tab_noisescaleg2
[i
]);
932 for (i
= 0; i
< B43_TAB_SIGMASQR_SIZE
; i
++)
933 b43_ofdmtab_write16(dev
, 0x5000, i
,
934 b43_tab_sigmasqr1
[i
]);
935 else if ((phy
->rev
> 2) && (phy
->rev
<= 8))
936 for (i
= 0; i
< B43_TAB_SIGMASQR_SIZE
; i
++)
937 b43_ofdmtab_write16(dev
, 0x5000, i
,
938 b43_tab_sigmasqr2
[i
]);
941 for (i
= 0; i
< B43_TAB_RETARD_SIZE
; i
++)
942 b43_ofdmtab_write32(dev
, 0x2400, i
, b43_tab_retard
[i
]);
943 for (i
= 4; i
< 20; i
++)
944 b43_ofdmtab_write16(dev
, 0x5400, i
, 0x0020);
945 b43_phy_agcsetup(dev
);
947 if ((bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
) &&
948 (bus
->boardinfo
.type
== SSB_BOARD_BU4306
) &&
949 (bus
->boardinfo
.rev
== 0x17))
952 b43_ofdmtab_write16(dev
, 0x5001, 0, 0x0002);
953 b43_ofdmtab_write16(dev
, 0x5002, 0, 0x0001);
955 for (i
= 0; i
< 0x20; i
++)
956 b43_ofdmtab_write16(dev
, 0x1000, i
, 0x0820);
957 b43_phy_agcsetup(dev
);
958 b43_phy_read(dev
, 0x0400); /* dummy read */
959 b43_phy_write(dev
, 0x0403, 0x1000);
960 b43_ofdmtab_write16(dev
, 0x3C02, 0, 0x000F);
961 b43_ofdmtab_write16(dev
, 0x3C03, 0, 0x0014);
963 if ((bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
) &&
964 (bus
->boardinfo
.type
== SSB_BOARD_BU4306
) &&
965 (bus
->boardinfo
.rev
== 0x17))
968 b43_ofdmtab_write16(dev
, 0x0401, 0, 0x0002);
969 b43_ofdmtab_write16(dev
, 0x0402, 0, 0x0001);
973 /* Initialize the noisescaletable for APHY */
974 static void b43_phy_init_noisescaletbl(struct b43_wldev
*dev
)
976 struct b43_phy
*phy
= &dev
->phy
;
979 for (i
= 0; i
< 12; i
++) {
981 b43_ofdmtab_write16(dev
, 0x1400, i
, 0x6767);
983 b43_ofdmtab_write16(dev
, 0x1400, i
, 0x2323);
986 b43_ofdmtab_write16(dev
, 0x1400, i
, 0x6700);
988 b43_ofdmtab_write16(dev
, 0x1400, i
, 0x2300);
989 for (i
= 0; i
< 11; i
++) {
991 b43_ofdmtab_write16(dev
, 0x1400, i
, 0x6767);
993 b43_ofdmtab_write16(dev
, 0x1400, i
, 0x2323);
996 b43_ofdmtab_write16(dev
, 0x1400, i
, 0x0067);
998 b43_ofdmtab_write16(dev
, 0x1400, i
, 0x0023);
1001 static void b43_phy_setupa(struct b43_wldev
*dev
)
1003 struct b43_phy
*phy
= &dev
->phy
;
1006 B43_WARN_ON(phy
->type
!= B43_PHYTYPE_A
);
1009 b43_phy_write(dev
, 0x008E, 0x3800);
1010 b43_phy_write(dev
, 0x0035, 0x03FF);
1011 b43_phy_write(dev
, 0x0036, 0x0400);
1013 b43_ofdmtab_write16(dev
, 0x3807, 0, 0x0051);
1015 b43_phy_write(dev
, 0x001C, 0x0FF9);
1016 b43_phy_write(dev
, 0x0020, b43_phy_read(dev
, 0x0020) & 0xFF0F);
1017 b43_ofdmtab_write16(dev
, 0x3C0C, 0, 0x07BF);
1018 b43_radio_write16(dev
, 0x0002, 0x07BF);
1020 b43_phy_write(dev
, 0x0024, 0x4680);
1021 b43_phy_write(dev
, 0x0020, 0x0003);
1022 b43_phy_write(dev
, 0x001D, 0x0F40);
1023 b43_phy_write(dev
, 0x001F, 0x1C00);
1025 b43_phy_write(dev
, 0x002A, (b43_phy_read(dev
, 0x002A)
1026 & 0x00FF) | 0x0400);
1027 b43_phy_write(dev
, 0x002B, b43_phy_read(dev
, 0x002B)
1029 b43_phy_write(dev
, 0x008E, 0x58C1);
1031 b43_ofdmtab_write16(dev
, 0x0803, 0, 0x000F);
1032 b43_ofdmtab_write16(dev
, 0x0804, 0, 0x001F);
1033 b43_ofdmtab_write16(dev
, 0x0805, 0, 0x002A);
1034 b43_ofdmtab_write16(dev
, 0x0805, 0, 0x0030);
1035 b43_ofdmtab_write16(dev
, 0x0807, 0, 0x003A);
1037 b43_ofdmtab_write16(dev
, 0x0000, 0, 0x0013);
1038 b43_ofdmtab_write16(dev
, 0x0000, 1, 0x0013);
1039 b43_ofdmtab_write16(dev
, 0x0000, 2, 0x0013);
1040 b43_ofdmtab_write16(dev
, 0x0000, 3, 0x0013);
1041 b43_ofdmtab_write16(dev
, 0x0000, 4, 0x0015);
1042 b43_ofdmtab_write16(dev
, 0x0000, 5, 0x0015);
1043 b43_ofdmtab_write16(dev
, 0x0000, 6, 0x0019);
1045 b43_ofdmtab_write16(dev
, 0x0404, 0, 0x0003);
1046 b43_ofdmtab_write16(dev
, 0x0405, 0, 0x0003);
1047 b43_ofdmtab_write16(dev
, 0x0406, 0, 0x0007);
1049 for (i
= 0; i
< 16; i
++)
1050 b43_ofdmtab_write16(dev
, 0x4000, i
, (0x8 + i
) & 0x000F);
1052 b43_ofdmtab_write16(dev
, 0x3003, 0, 0x1044);
1053 b43_ofdmtab_write16(dev
, 0x3004, 0, 0x7201);
1054 b43_ofdmtab_write16(dev
, 0x3006, 0, 0x0040);
1055 b43_ofdmtab_write16(dev
, 0x3001, 0,
1056 (b43_ofdmtab_read16(dev
, 0x3001, 0) &
1059 for (i
= 0; i
< B43_TAB_FINEFREQA_SIZE
; i
++)
1060 b43_ofdmtab_write16(dev
, 0x5800, i
,
1061 b43_tab_finefreqa
[i
]);
1062 for (i
= 0; i
< B43_TAB_NOISEA2_SIZE
; i
++)
1063 b43_ofdmtab_write16(dev
, 0x1800, i
, b43_tab_noisea2
[i
]);
1064 for (i
= 0; i
< B43_TAB_ROTOR_SIZE
; i
++)
1065 b43_ofdmtab_write32(dev
, 0x2000, i
, b43_tab_rotor
[i
]);
1066 b43_phy_init_noisescaletbl(dev
);
1067 for (i
= 0; i
< B43_TAB_RETARD_SIZE
; i
++)
1068 b43_ofdmtab_write32(dev
, 0x2400, i
, b43_tab_retard
[i
]);
1071 for (i
= 0; i
< 64; i
++)
1072 b43_ofdmtab_write16(dev
, 0x4000, i
, i
);
1074 b43_ofdmtab_write16(dev
, 0x3807, 0, 0x0051);
1076 b43_phy_write(dev
, 0x001C, 0x0FF9);
1077 b43_phy_write(dev
, 0x0020, b43_phy_read(dev
, 0x0020) & 0xFF0F);
1078 b43_radio_write16(dev
, 0x0002, 0x07BF);
1080 b43_phy_write(dev
, 0x0024, 0x4680);
1081 b43_phy_write(dev
, 0x0020, 0x0003);
1082 b43_phy_write(dev
, 0x001D, 0x0F40);
1083 b43_phy_write(dev
, 0x001F, 0x1C00);
1084 b43_phy_write(dev
, 0x002A, (b43_phy_read(dev
, 0x002A)
1085 & 0x00FF) | 0x0400);
1087 b43_ofdmtab_write16(dev
, 0x3000, 1,
1088 (b43_ofdmtab_read16(dev
, 0x3000, 1)
1089 & 0x0010) | 0x0008);
1090 for (i
= 0; i
< B43_TAB_NOISEA3_SIZE
; i
++) {
1091 b43_ofdmtab_write16(dev
, 0x1800, i
, b43_tab_noisea3
[i
]);
1093 b43_phy_init_noisescaletbl(dev
);
1094 for (i
= 0; i
< B43_TAB_SIGMASQR_SIZE
; i
++) {
1095 b43_ofdmtab_write16(dev
, 0x5000, i
,
1096 b43_tab_sigmasqr1
[i
]);
1099 b43_phy_write(dev
, 0x0003, 0x1808);
1101 b43_ofdmtab_write16(dev
, 0x0803, 0, 0x000F);
1102 b43_ofdmtab_write16(dev
, 0x0804, 0, 0x001F);
1103 b43_ofdmtab_write16(dev
, 0x0805, 0, 0x002A);
1104 b43_ofdmtab_write16(dev
, 0x0805, 0, 0x0030);
1105 b43_ofdmtab_write16(dev
, 0x0807, 0, 0x003A);
1107 b43_ofdmtab_write16(dev
, 0x0000, 0, 0x0013);
1108 b43_ofdmtab_write16(dev
, 0x0001, 0, 0x0013);
1109 b43_ofdmtab_write16(dev
, 0x0002, 0, 0x0013);
1110 b43_ofdmtab_write16(dev
, 0x0003, 0, 0x0013);
1111 b43_ofdmtab_write16(dev
, 0x0004, 0, 0x0015);
1112 b43_ofdmtab_write16(dev
, 0x0005, 0, 0x0015);
1113 b43_ofdmtab_write16(dev
, 0x0006, 0, 0x0019);
1115 b43_ofdmtab_write16(dev
, 0x0404, 0, 0x0003);
1116 b43_ofdmtab_write16(dev
, 0x0405, 0, 0x0003);
1117 b43_ofdmtab_write16(dev
, 0x0406, 0, 0x0007);
1119 b43_ofdmtab_write16(dev
, 0x3C02, 0, 0x000F);
1120 b43_ofdmtab_write16(dev
, 0x3C03, 0, 0x0014);
1127 /* Initialize APHY. This is also called for the GPHY in some cases. */
1128 static void b43_phy_inita(struct b43_wldev
*dev
)
1130 struct ssb_bus
*bus
= dev
->dev
->bus
;
1131 struct b43_phy
*phy
= &dev
->phy
;
1136 if (phy
->type
== B43_PHYTYPE_A
) {
1137 b43_phy_setupa(dev
);
1139 b43_phy_setupg(dev
);
1141 (dev
->dev
->bus
->sprom
.r1
.boardflags_lo
& B43_BFL_PACTRL
))
1142 b43_phy_write(dev
, 0x046E, 0x03CF);
1146 b43_phy_write(dev
, B43_PHY_A_CRS
,
1147 (b43_phy_read(dev
, B43_PHY_A_CRS
) & 0xF83C) | 0x0340);
1148 b43_phy_write(dev
, 0x0034, 0x0001);
1151 b43_phy_write(dev
, B43_PHY_A_CRS
,
1152 b43_phy_read(dev
, B43_PHY_A_CRS
) | (1 << 14));
1153 b43_radio_init2060(dev
);
1155 if ((bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
) &&
1156 ((bus
->boardinfo
.type
== SSB_BOARD_BU4306
) ||
1157 (bus
->boardinfo
.type
== SSB_BOARD_BU4309
))) {
1158 if (phy
->lofcal
== 0xFFFF) {
1160 b43_radio_set_tx_iq(dev
);
1162 b43_radio_write16(dev
, 0x001E, phy
->lofcal
);
1165 b43_phy_write(dev
, 0x007A, 0xF111);
1167 if (phy
->cur_idle_tssi
== 0) {
1168 b43_radio_write16(dev
, 0x0019, 0x0000);
1169 b43_radio_write16(dev
, 0x0017, 0x0020);
1171 tval
= b43_ofdmtab_read16(dev
, 0x3001, 0);
1172 if (phy
->rev
== 1) {
1173 b43_ofdmtab_write16(dev
, 0x3001, 0,
1174 (b43_ofdmtab_read16(dev
, 0x3001, 0)
1178 b43_ofdmtab_write16(dev
, 0x3001, 0,
1179 (b43_ofdmtab_read16(dev
, 0x3001, 0)
1183 b43_dummy_transmission(dev
);
1184 phy
->cur_idle_tssi
= b43_phy_read(dev
, B43_PHY_A_PCTL
);
1185 b43_ofdmtab_write16(dev
, 0x3001, 0, tval
);
1187 b43_radio_set_txpower_a(dev
, 0x0018);
1189 b43_shm_clear_tssi(dev
);
1192 static void b43_phy_initb2(struct b43_wldev
*dev
)
1194 struct b43_phy
*phy
= &dev
->phy
;
1197 b43_write16(dev
, 0x03EC, 0x3F22);
1198 b43_phy_write(dev
, 0x0020, 0x301C);
1199 b43_phy_write(dev
, 0x0026, 0x0000);
1200 b43_phy_write(dev
, 0x0030, 0x00C6);
1201 b43_phy_write(dev
, 0x0088, 0x3E00);
1203 for (offset
= 0x0089; offset
< 0x00A7; offset
++) {
1204 b43_phy_write(dev
, offset
, val
);
1207 b43_phy_write(dev
, 0x03E4, 0x3000);
1208 if (phy
->channel
== 0xFF)
1209 b43_radio_selectchannel(dev
, B43_DEFAULT_CHANNEL_BG
, 0);
1211 b43_radio_selectchannel(dev
, phy
->channel
, 0);
1212 if (phy
->radio_ver
!= 0x2050) {
1213 b43_radio_write16(dev
, 0x0075, 0x0080);
1214 b43_radio_write16(dev
, 0x0079, 0x0081);
1216 b43_radio_write16(dev
, 0x0050, 0x0020);
1217 b43_radio_write16(dev
, 0x0050, 0x0023);
1218 if (phy
->radio_ver
== 0x2050) {
1219 b43_radio_write16(dev
, 0x0050, 0x0020);
1220 b43_radio_write16(dev
, 0x005A, 0x0070);
1221 b43_radio_write16(dev
, 0x005B, 0x007B);
1222 b43_radio_write16(dev
, 0x005C, 0x00B0);
1223 b43_radio_write16(dev
, 0x007A, 0x000F);
1224 b43_phy_write(dev
, 0x0038, 0x0677);
1225 b43_radio_init2050(dev
);
1227 b43_phy_write(dev
, 0x0014, 0x0080);
1228 b43_phy_write(dev
, 0x0032, 0x00CA);
1229 b43_phy_write(dev
, 0x0032, 0x00CC);
1230 b43_phy_write(dev
, 0x0035, 0x07C2);
1231 b43_lo_b_measure(dev
);
1232 b43_phy_write(dev
, 0x0026, 0xCC00);
1233 if (phy
->radio_ver
!= 0x2050)
1234 b43_phy_write(dev
, 0x0026, 0xCE00);
1235 b43_write16(dev
, B43_MMIO_CHANNEL_EXT
, 0x1000);
1236 b43_phy_write(dev
, 0x002A, 0x88A3);
1237 if (phy
->radio_ver
!= 0x2050)
1238 b43_phy_write(dev
, 0x002A, 0x88C2);
1239 b43_set_txpower_g(dev
, &phy
->bbatt
, &phy
->rfatt
, phy
->tx_control
);
1240 b43_phy_init_pctl(dev
);
1243 static void b43_phy_initb4(struct b43_wldev
*dev
)
1245 struct b43_phy
*phy
= &dev
->phy
;
1248 b43_write16(dev
, 0x03EC, 0x3F22);
1249 b43_phy_write(dev
, 0x0020, 0x301C);
1250 b43_phy_write(dev
, 0x0026, 0x0000);
1251 b43_phy_write(dev
, 0x0030, 0x00C6);
1252 b43_phy_write(dev
, 0x0088, 0x3E00);
1254 for (offset
= 0x0089; offset
< 0x00A7; offset
++) {
1255 b43_phy_write(dev
, offset
, val
);
1258 b43_phy_write(dev
, 0x03E4, 0x3000);
1259 if (phy
->channel
== 0xFF)
1260 b43_radio_selectchannel(dev
, B43_DEFAULT_CHANNEL_BG
, 0);
1262 b43_radio_selectchannel(dev
, phy
->channel
, 0);
1263 if (phy
->radio_ver
!= 0x2050) {
1264 b43_radio_write16(dev
, 0x0075, 0x0080);
1265 b43_radio_write16(dev
, 0x0079, 0x0081);
1267 b43_radio_write16(dev
, 0x0050, 0x0020);
1268 b43_radio_write16(dev
, 0x0050, 0x0023);
1269 if (phy
->radio_ver
== 0x2050) {
1270 b43_radio_write16(dev
, 0x0050, 0x0020);
1271 b43_radio_write16(dev
, 0x005A, 0x0070);
1272 b43_radio_write16(dev
, 0x005B, 0x007B);
1273 b43_radio_write16(dev
, 0x005C, 0x00B0);
1274 b43_radio_write16(dev
, 0x007A, 0x000F);
1275 b43_phy_write(dev
, 0x0038, 0x0677);
1276 b43_radio_init2050(dev
);
1278 b43_phy_write(dev
, 0x0014, 0x0080);
1279 b43_phy_write(dev
, 0x0032, 0x00CA);
1280 if (phy
->radio_ver
== 0x2050)
1281 b43_phy_write(dev
, 0x0032, 0x00E0);
1282 b43_phy_write(dev
, 0x0035, 0x07C2);
1284 b43_lo_b_measure(dev
);
1286 b43_phy_write(dev
, 0x0026, 0xCC00);
1287 if (phy
->radio_ver
== 0x2050)
1288 b43_phy_write(dev
, 0x0026, 0xCE00);
1289 b43_write16(dev
, B43_MMIO_CHANNEL_EXT
, 0x1100);
1290 b43_phy_write(dev
, 0x002A, 0x88A3);
1291 if (phy
->radio_ver
== 0x2050)
1292 b43_phy_write(dev
, 0x002A, 0x88C2);
1293 b43_set_txpower_g(dev
, &phy
->bbatt
, &phy
->rfatt
, phy
->tx_control
);
1294 if (dev
->dev
->bus
->sprom
.r1
.boardflags_lo
& B43_BFL_RSSI
) {
1295 b43_calc_nrssi_slope(dev
);
1296 b43_calc_nrssi_threshold(dev
);
1298 b43_phy_init_pctl(dev
);
1301 static void b43_phy_initb5(struct b43_wldev
*dev
)
1303 struct ssb_bus
*bus
= dev
->dev
->bus
;
1304 struct b43_phy
*phy
= &dev
->phy
;
1308 if (phy
->analog
== 1) {
1309 b43_radio_write16(dev
, 0x007A, b43_radio_read16(dev
, 0x007A)
1312 if ((bus
->boardinfo
.vendor
!= SSB_BOARDVENDOR_BCM
) &&
1313 (bus
->boardinfo
.type
!= SSB_BOARD_BU4306
)) {
1315 for (offset
= 0x00A8; offset
< 0x00C7; offset
++) {
1316 b43_phy_write(dev
, offset
, value
);
1320 b43_phy_write(dev
, 0x0035, (b43_phy_read(dev
, 0x0035) & 0xF0FF)
1322 if (phy
->radio_ver
== 0x2050)
1323 b43_phy_write(dev
, 0x0038, 0x0667);
1325 if (phy
->gmode
|| phy
->rev
>= 2) {
1326 if (phy
->radio_ver
== 0x2050) {
1327 b43_radio_write16(dev
, 0x007A,
1328 b43_radio_read16(dev
, 0x007A)
1330 b43_radio_write16(dev
, 0x0051,
1331 b43_radio_read16(dev
, 0x0051)
1334 b43_write16(dev
, B43_MMIO_PHY_RADIO
, 0x0000);
1336 b43_phy_write(dev
, 0x0802, b43_phy_read(dev
, 0x0802) | 0x0100);
1337 b43_phy_write(dev
, 0x042B, b43_phy_read(dev
, 0x042B) | 0x2000);
1339 b43_phy_write(dev
, 0x001C, 0x186A);
1341 b43_phy_write(dev
, 0x0013,
1342 (b43_phy_read(dev
, 0x0013) & 0x00FF) | 0x1900);
1343 b43_phy_write(dev
, 0x0035,
1344 (b43_phy_read(dev
, 0x0035) & 0xFFC0) | 0x0064);
1345 b43_phy_write(dev
, 0x005D,
1346 (b43_phy_read(dev
, 0x005D) & 0xFF80) | 0x000A);
1349 if (dev
->bad_frames_preempt
) {
1350 b43_phy_write(dev
, B43_PHY_RADIO_BITFIELD
,
1352 B43_PHY_RADIO_BITFIELD
) | (1 << 11));
1355 if (phy
->analog
== 1) {
1356 b43_phy_write(dev
, 0x0026, 0xCE00);
1357 b43_phy_write(dev
, 0x0021, 0x3763);
1358 b43_phy_write(dev
, 0x0022, 0x1BC3);
1359 b43_phy_write(dev
, 0x0023, 0x06F9);
1360 b43_phy_write(dev
, 0x0024, 0x037E);
1362 b43_phy_write(dev
, 0x0026, 0xCC00);
1363 b43_phy_write(dev
, 0x0030, 0x00C6);
1364 b43_write16(dev
, 0x03EC, 0x3F22);
1366 if (phy
->analog
== 1)
1367 b43_phy_write(dev
, 0x0020, 0x3E1C);
1369 b43_phy_write(dev
, 0x0020, 0x301C);
1371 if (phy
->analog
== 0)
1372 b43_write16(dev
, 0x03E4, 0x3000);
1374 old_channel
= phy
->channel
;
1375 /* Force to channel 7, even if not supported. */
1376 b43_radio_selectchannel(dev
, 7, 0);
1378 if (phy
->radio_ver
!= 0x2050) {
1379 b43_radio_write16(dev
, 0x0075, 0x0080);
1380 b43_radio_write16(dev
, 0x0079, 0x0081);
1383 b43_radio_write16(dev
, 0x0050, 0x0020);
1384 b43_radio_write16(dev
, 0x0050, 0x0023);
1386 if (phy
->radio_ver
== 0x2050) {
1387 b43_radio_write16(dev
, 0x0050, 0x0020);
1388 b43_radio_write16(dev
, 0x005A, 0x0070);
1391 b43_radio_write16(dev
, 0x005B, 0x007B);
1392 b43_radio_write16(dev
, 0x005C, 0x00B0);
1394 b43_radio_write16(dev
, 0x007A, b43_radio_read16(dev
, 0x007A) | 0x0007);
1396 b43_radio_selectchannel(dev
, old_channel
, 0);
1398 b43_phy_write(dev
, 0x0014, 0x0080);
1399 b43_phy_write(dev
, 0x0032, 0x00CA);
1400 b43_phy_write(dev
, 0x002A, 0x88A3);
1402 b43_set_txpower_g(dev
, &phy
->bbatt
, &phy
->rfatt
, phy
->tx_control
);
1404 if (phy
->radio_ver
== 0x2050)
1405 b43_radio_write16(dev
, 0x005D, 0x000D);
1407 b43_write16(dev
, 0x03E4, (b43_read16(dev
, 0x03E4) & 0xFFC0) | 0x0004);
1410 static void b43_phy_initb6(struct b43_wldev
*dev
)
1412 struct b43_phy
*phy
= &dev
->phy
;
1416 b43_phy_write(dev
, 0x003E, 0x817A);
1417 b43_radio_write16(dev
, 0x007A,
1418 (b43_radio_read16(dev
, 0x007A) | 0x0058));
1419 if (phy
->radio_rev
== 4 || phy
->radio_rev
== 5) {
1420 b43_radio_write16(dev
, 0x51, 0x37);
1421 b43_radio_write16(dev
, 0x52, 0x70);
1422 b43_radio_write16(dev
, 0x53, 0xB3);
1423 b43_radio_write16(dev
, 0x54, 0x9B);
1424 b43_radio_write16(dev
, 0x5A, 0x88);
1425 b43_radio_write16(dev
, 0x5B, 0x88);
1426 b43_radio_write16(dev
, 0x5D, 0x88);
1427 b43_radio_write16(dev
, 0x5E, 0x88);
1428 b43_radio_write16(dev
, 0x7D, 0x88);
1429 b43_hf_write(dev
, b43_hf_read(dev
)
1430 | B43_HF_TSSIRPSMW
);
1432 B43_WARN_ON(phy
->radio_rev
== 6 || phy
->radio_rev
== 7); /* We had code for these revs here... */
1433 if (phy
->radio_rev
== 8) {
1434 b43_radio_write16(dev
, 0x51, 0);
1435 b43_radio_write16(dev
, 0x52, 0x40);
1436 b43_radio_write16(dev
, 0x53, 0xB7);
1437 b43_radio_write16(dev
, 0x54, 0x98);
1438 b43_radio_write16(dev
, 0x5A, 0x88);
1439 b43_radio_write16(dev
, 0x5B, 0x6B);
1440 b43_radio_write16(dev
, 0x5C, 0x0F);
1441 if (dev
->dev
->bus
->sprom
.r1
.boardflags_lo
& B43_BFL_ALTIQ
) {
1442 b43_radio_write16(dev
, 0x5D, 0xFA);
1443 b43_radio_write16(dev
, 0x5E, 0xD8);
1445 b43_radio_write16(dev
, 0x5D, 0xF5);
1446 b43_radio_write16(dev
, 0x5E, 0xB8);
1448 b43_radio_write16(dev
, 0x0073, 0x0003);
1449 b43_radio_write16(dev
, 0x007D, 0x00A8);
1450 b43_radio_write16(dev
, 0x007C, 0x0001);
1451 b43_radio_write16(dev
, 0x007E, 0x0008);
1454 for (offset
= 0x0088; offset
< 0x0098; offset
++) {
1455 b43_phy_write(dev
, offset
, val
);
1459 for (offset
= 0x0098; offset
< 0x00A8; offset
++) {
1460 b43_phy_write(dev
, offset
, val
);
1464 for (offset
= 0x00A8; offset
< 0x00C8; offset
++) {
1465 b43_phy_write(dev
, offset
, (val
& 0x3F3F));
1468 if (phy
->type
== B43_PHYTYPE_G
) {
1469 b43_radio_write16(dev
, 0x007A,
1470 b43_radio_read16(dev
, 0x007A) | 0x0020);
1471 b43_radio_write16(dev
, 0x0051,
1472 b43_radio_read16(dev
, 0x0051) | 0x0004);
1473 b43_phy_write(dev
, 0x0802, b43_phy_read(dev
, 0x0802) | 0x0100);
1474 b43_phy_write(dev
, 0x042B, b43_phy_read(dev
, 0x042B) | 0x2000);
1475 b43_phy_write(dev
, 0x5B, 0);
1476 b43_phy_write(dev
, 0x5C, 0);
1479 old_channel
= phy
->channel
;
1480 if (old_channel
>= 8)
1481 b43_radio_selectchannel(dev
, 1, 0);
1483 b43_radio_selectchannel(dev
, 13, 0);
1485 b43_radio_write16(dev
, 0x0050, 0x0020);
1486 b43_radio_write16(dev
, 0x0050, 0x0023);
1488 if (phy
->radio_rev
< 6 || phy
->radio_rev
== 8) {
1489 b43_radio_write16(dev
, 0x7C, (b43_radio_read16(dev
, 0x7C)
1491 b43_radio_write16(dev
, 0x50, 0x20);
1493 if (phy
->radio_rev
<= 2) {
1494 b43_radio_write16(dev
, 0x7C, 0x20);
1495 b43_radio_write16(dev
, 0x5A, 0x70);
1496 b43_radio_write16(dev
, 0x5B, 0x7B);
1497 b43_radio_write16(dev
, 0x5C, 0xB0);
1499 b43_radio_write16(dev
, 0x007A,
1500 (b43_radio_read16(dev
, 0x007A) & 0x00F8) | 0x0007);
1502 b43_radio_selectchannel(dev
, old_channel
, 0);
1504 b43_phy_write(dev
, 0x0014, 0x0200);
1505 if (phy
->radio_rev
>= 6)
1506 b43_phy_write(dev
, 0x2A, 0x88C2);
1508 b43_phy_write(dev
, 0x2A, 0x8AC0);
1509 b43_phy_write(dev
, 0x0038, 0x0668);
1510 b43_set_txpower_g(dev
, &phy
->bbatt
, &phy
->rfatt
, phy
->tx_control
);
1511 if (phy
->radio_rev
<= 5) {
1512 b43_phy_write(dev
, 0x5D, (b43_phy_read(dev
, 0x5D)
1513 & 0xFF80) | 0x0003);
1515 if (phy
->radio_rev
<= 2)
1516 b43_radio_write16(dev
, 0x005D, 0x000D);
1518 if (phy
->analog
== 4) {
1519 b43_write16(dev
, 0x3E4, 9);
1520 b43_phy_write(dev
, 0x61, b43_phy_read(dev
, 0x61)
1523 b43_phy_write(dev
, 0x0002, (b43_phy_read(dev
, 0x0002) & 0xFFC0)
1526 if (phy
->type
== B43_PHYTYPE_B
) {
1527 b43_write16(dev
, 0x03E6, 0x8140);
1528 b43_phy_write(dev
, 0x0016, 0x0410);
1529 b43_phy_write(dev
, 0x0017, 0x0820);
1530 b43_phy_write(dev
, 0x0062, 0x0007);
1531 b43_radio_init2050(dev
);
1532 b43_lo_g_measure(dev
);
1533 if (dev
->dev
->bus
->sprom
.r1
.boardflags_lo
& B43_BFL_RSSI
) {
1534 b43_calc_nrssi_slope(dev
);
1535 b43_calc_nrssi_threshold(dev
);
1537 b43_phy_init_pctl(dev
);
1538 } else if (phy
->type
== B43_PHYTYPE_G
)
1539 b43_write16(dev
, 0x03E6, 0x0);
1542 static void b43_calc_loopback_gain(struct b43_wldev
*dev
)
1544 struct b43_phy
*phy
= &dev
->phy
;
1545 u16 backup_phy
[16] = { 0 };
1546 u16 backup_radio
[3];
1548 u16 i
, j
, loop_i_max
;
1550 u16 loop1_outer_done
, loop1_inner_done
;
1552 backup_phy
[0] = b43_phy_read(dev
, B43_PHY_CRS0
);
1553 backup_phy
[1] = b43_phy_read(dev
, B43_PHY_CCKBBANDCFG
);
1554 backup_phy
[2] = b43_phy_read(dev
, B43_PHY_RFOVER
);
1555 backup_phy
[3] = b43_phy_read(dev
, B43_PHY_RFOVERVAL
);
1556 if (phy
->rev
!= 1) { /* Not in specs, but needed to prevent PPC machine check */
1557 backup_phy
[4] = b43_phy_read(dev
, B43_PHY_ANALOGOVER
);
1558 backup_phy
[5] = b43_phy_read(dev
, B43_PHY_ANALOGOVERVAL
);
1560 backup_phy
[6] = b43_phy_read(dev
, B43_PHY_BASE(0x5A));
1561 backup_phy
[7] = b43_phy_read(dev
, B43_PHY_BASE(0x59));
1562 backup_phy
[8] = b43_phy_read(dev
, B43_PHY_BASE(0x58));
1563 backup_phy
[9] = b43_phy_read(dev
, B43_PHY_BASE(0x0A));
1564 backup_phy
[10] = b43_phy_read(dev
, B43_PHY_BASE(0x03));
1565 backup_phy
[11] = b43_phy_read(dev
, B43_PHY_LO_MASK
);
1566 backup_phy
[12] = b43_phy_read(dev
, B43_PHY_LO_CTL
);
1567 backup_phy
[13] = b43_phy_read(dev
, B43_PHY_BASE(0x2B));
1568 backup_phy
[14] = b43_phy_read(dev
, B43_PHY_PGACTL
);
1569 backup_phy
[15] = b43_phy_read(dev
, B43_PHY_LO_LEAKAGE
);
1570 backup_bband
= phy
->bbatt
.att
;
1571 backup_radio
[0] = b43_radio_read16(dev
, 0x52);
1572 backup_radio
[1] = b43_radio_read16(dev
, 0x43);
1573 backup_radio
[2] = b43_radio_read16(dev
, 0x7A);
1575 b43_phy_write(dev
, B43_PHY_CRS0
,
1576 b43_phy_read(dev
, B43_PHY_CRS0
) & 0x3FFF);
1577 b43_phy_write(dev
, B43_PHY_CCKBBANDCFG
,
1578 b43_phy_read(dev
, B43_PHY_CCKBBANDCFG
) | 0x8000);
1579 b43_phy_write(dev
, B43_PHY_RFOVER
,
1580 b43_phy_read(dev
, B43_PHY_RFOVER
) | 0x0002);
1581 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1582 b43_phy_read(dev
, B43_PHY_RFOVERVAL
) & 0xFFFD);
1583 b43_phy_write(dev
, B43_PHY_RFOVER
,
1584 b43_phy_read(dev
, B43_PHY_RFOVER
) | 0x0001);
1585 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1586 b43_phy_read(dev
, B43_PHY_RFOVERVAL
) & 0xFFFE);
1587 if (phy
->rev
!= 1) { /* Not in specs, but needed to prevent PPC machine check */
1588 b43_phy_write(dev
, B43_PHY_ANALOGOVER
,
1589 b43_phy_read(dev
, B43_PHY_ANALOGOVER
) | 0x0001);
1590 b43_phy_write(dev
, B43_PHY_ANALOGOVERVAL
,
1592 B43_PHY_ANALOGOVERVAL
) & 0xFFFE);
1593 b43_phy_write(dev
, B43_PHY_ANALOGOVER
,
1594 b43_phy_read(dev
, B43_PHY_ANALOGOVER
) | 0x0002);
1595 b43_phy_write(dev
, B43_PHY_ANALOGOVERVAL
,
1597 B43_PHY_ANALOGOVERVAL
) & 0xFFFD);
1599 b43_phy_write(dev
, B43_PHY_RFOVER
,
1600 b43_phy_read(dev
, B43_PHY_RFOVER
) | 0x000C);
1601 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1602 b43_phy_read(dev
, B43_PHY_RFOVERVAL
) | 0x000C);
1603 b43_phy_write(dev
, B43_PHY_RFOVER
,
1604 b43_phy_read(dev
, B43_PHY_RFOVER
) | 0x0030);
1605 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1606 (b43_phy_read(dev
, B43_PHY_RFOVERVAL
)
1609 b43_phy_write(dev
, B43_PHY_BASE(0x5A), 0x0780);
1610 b43_phy_write(dev
, B43_PHY_BASE(0x59), 0xC810);
1611 b43_phy_write(dev
, B43_PHY_BASE(0x58), 0x000D);
1613 b43_phy_write(dev
, B43_PHY_BASE(0x0A),
1614 b43_phy_read(dev
, B43_PHY_BASE(0x0A)) | 0x2000);
1615 if (phy
->rev
!= 1) { /* Not in specs, but needed to prevent PPC machine check */
1616 b43_phy_write(dev
, B43_PHY_ANALOGOVER
,
1617 b43_phy_read(dev
, B43_PHY_ANALOGOVER
) | 0x0004);
1618 b43_phy_write(dev
, B43_PHY_ANALOGOVERVAL
,
1620 B43_PHY_ANALOGOVERVAL
) & 0xFFFB);
1622 b43_phy_write(dev
, B43_PHY_BASE(0x03),
1623 (b43_phy_read(dev
, B43_PHY_BASE(0x03))
1626 if (phy
->radio_rev
== 8) {
1627 b43_radio_write16(dev
, 0x43, 0x000F);
1629 b43_radio_write16(dev
, 0x52, 0);
1630 b43_radio_write16(dev
, 0x43, (b43_radio_read16(dev
, 0x43)
1633 b43_phy_set_baseband_attenuation(dev
, 11);
1636 b43_phy_write(dev
, B43_PHY_LO_MASK
, 0xC020);
1638 b43_phy_write(dev
, B43_PHY_LO_MASK
, 0x8020);
1639 b43_phy_write(dev
, B43_PHY_LO_CTL
, 0);
1641 b43_phy_write(dev
, B43_PHY_BASE(0x2B),
1642 (b43_phy_read(dev
, B43_PHY_BASE(0x2B))
1644 b43_phy_write(dev
, B43_PHY_BASE(0x2B),
1645 (b43_phy_read(dev
, B43_PHY_BASE(0x2B))
1648 b43_phy_write(dev
, B43_PHY_RFOVER
,
1649 b43_phy_read(dev
, B43_PHY_RFOVER
) | 0x0100);
1650 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1651 b43_phy_read(dev
, B43_PHY_RFOVERVAL
) & 0xCFFF);
1653 if (dev
->dev
->bus
->sprom
.r1
.boardflags_lo
& B43_BFL_EXTLNA
) {
1654 if (phy
->rev
>= 7) {
1655 b43_phy_write(dev
, B43_PHY_RFOVER
,
1656 b43_phy_read(dev
, B43_PHY_RFOVER
)
1658 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1659 b43_phy_read(dev
, B43_PHY_RFOVERVAL
)
1663 b43_radio_write16(dev
, 0x7A, b43_radio_read16(dev
, 0x7A)
1667 loop_i_max
= (phy
->radio_rev
== 8) ? 15 : 9;
1668 for (i
= 0; i
< loop_i_max
; i
++) {
1669 for (j
= 0; j
< 16; j
++) {
1670 b43_radio_write16(dev
, 0x43, i
);
1671 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1672 (b43_phy_read(dev
, B43_PHY_RFOVERVAL
)
1673 & 0xF0FF) | (j
<< 8));
1674 b43_phy_write(dev
, B43_PHY_PGACTL
,
1675 (b43_phy_read(dev
, B43_PHY_PGACTL
)
1676 & 0x0FFF) | 0xA000);
1677 b43_phy_write(dev
, B43_PHY_PGACTL
,
1678 b43_phy_read(dev
, B43_PHY_PGACTL
)
1681 if (b43_phy_read(dev
, B43_PHY_LO_LEAKAGE
) >= 0xDFC)
1686 loop1_outer_done
= i
;
1687 loop1_inner_done
= j
;
1689 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1690 b43_phy_read(dev
, B43_PHY_RFOVERVAL
)
1693 for (j
= j
- 8; j
< 16; j
++) {
1694 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
1695 (b43_phy_read(dev
, B43_PHY_RFOVERVAL
)
1696 & 0xF0FF) | (j
<< 8));
1697 b43_phy_write(dev
, B43_PHY_PGACTL
,
1698 (b43_phy_read(dev
, B43_PHY_PGACTL
)
1699 & 0x0FFF) | 0xA000);
1700 b43_phy_write(dev
, B43_PHY_PGACTL
,
1701 b43_phy_read(dev
, B43_PHY_PGACTL
)
1705 if (b43_phy_read(dev
, B43_PHY_LO_LEAKAGE
) >= 0xDFC)
1712 if (phy
->rev
!= 1) { /* Not in specs, but needed to prevent PPC machine check */
1713 b43_phy_write(dev
, B43_PHY_ANALOGOVER
, backup_phy
[4]);
1714 b43_phy_write(dev
, B43_PHY_ANALOGOVERVAL
, backup_phy
[5]);
1716 b43_phy_write(dev
, B43_PHY_BASE(0x5A), backup_phy
[6]);
1717 b43_phy_write(dev
, B43_PHY_BASE(0x59), backup_phy
[7]);
1718 b43_phy_write(dev
, B43_PHY_BASE(0x58), backup_phy
[8]);
1719 b43_phy_write(dev
, B43_PHY_BASE(0x0A), backup_phy
[9]);
1720 b43_phy_write(dev
, B43_PHY_BASE(0x03), backup_phy
[10]);
1721 b43_phy_write(dev
, B43_PHY_LO_MASK
, backup_phy
[11]);
1722 b43_phy_write(dev
, B43_PHY_LO_CTL
, backup_phy
[12]);
1723 b43_phy_write(dev
, B43_PHY_BASE(0x2B), backup_phy
[13]);
1724 b43_phy_write(dev
, B43_PHY_PGACTL
, backup_phy
[14]);
1726 b43_phy_set_baseband_attenuation(dev
, backup_bband
);
1728 b43_radio_write16(dev
, 0x52, backup_radio
[0]);
1729 b43_radio_write16(dev
, 0x43, backup_radio
[1]);
1730 b43_radio_write16(dev
, 0x7A, backup_radio
[2]);
1732 b43_phy_write(dev
, B43_PHY_RFOVER
, backup_phy
[2] | 0x0003);
1734 b43_phy_write(dev
, B43_PHY_RFOVER
, backup_phy
[2]);
1735 b43_phy_write(dev
, B43_PHY_RFOVERVAL
, backup_phy
[3]);
1736 b43_phy_write(dev
, B43_PHY_CRS0
, backup_phy
[0]);
1737 b43_phy_write(dev
, B43_PHY_CCKBBANDCFG
, backup_phy
[1]);
1740 ((loop1_inner_done
* 6) - (loop1_outer_done
* 4)) - 11;
1741 phy
->trsw_rx_gain
= trsw_rx
* 2;
1744 static void b43_phy_initg(struct b43_wldev
*dev
)
1746 struct b43_phy
*phy
= &dev
->phy
;
1750 b43_phy_initb5(dev
);
1752 b43_phy_initb6(dev
);
1754 if (phy
->rev
>= 2 || phy
->gmode
)
1757 if (phy
->rev
>= 2) {
1758 b43_phy_write(dev
, B43_PHY_ANALOGOVER
, 0);
1759 b43_phy_write(dev
, B43_PHY_ANALOGOVERVAL
, 0);
1761 if (phy
->rev
== 2) {
1762 b43_phy_write(dev
, B43_PHY_RFOVER
, 0);
1763 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xC0);
1766 b43_phy_write(dev
, B43_PHY_RFOVER
, 0x400);
1767 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xC0);
1769 if (phy
->gmode
|| phy
->rev
>= 2) {
1770 tmp
= b43_phy_read(dev
, B43_PHY_VERSION_OFDM
);
1771 tmp
&= B43_PHYVER_VERSION
;
1772 if (tmp
== 3 || tmp
== 5) {
1773 b43_phy_write(dev
, B43_PHY_OFDM(0xC2), 0x1816);
1774 b43_phy_write(dev
, B43_PHY_OFDM(0xC3), 0x8006);
1777 b43_phy_write(dev
, B43_PHY_OFDM(0xCC),
1778 (b43_phy_read(dev
, B43_PHY_OFDM(0xCC))
1779 & 0x00FF) | 0x1F00);
1782 if ((phy
->rev
<= 2 && phy
->gmode
) || phy
->rev
>= 2)
1783 b43_phy_write(dev
, B43_PHY_OFDM(0x7E), 0x78);
1784 if (phy
->radio_rev
== 8) {
1785 b43_phy_write(dev
, B43_PHY_EXTG(0x01),
1786 b43_phy_read(dev
, B43_PHY_EXTG(0x01))
1788 b43_phy_write(dev
, B43_PHY_OFDM(0x3E),
1789 b43_phy_read(dev
, B43_PHY_OFDM(0x3E))
1792 if (has_loopback_gain(phy
))
1793 b43_calc_loopback_gain(dev
);
1795 if (phy
->radio_rev
!= 8) {
1796 if (phy
->initval
== 0xFFFF)
1797 phy
->initval
= b43_radio_init2050(dev
);
1799 b43_radio_write16(dev
, 0x0078, phy
->initval
);
1801 if (phy
->lo_control
->tx_bias
== 0xFF) {
1802 b43_lo_g_measure(dev
);
1804 if (has_tx_magnification(phy
)) {
1805 b43_radio_write16(dev
, 0x52,
1806 (b43_radio_read16(dev
, 0x52) & 0xFF00)
1807 | phy
->lo_control
->tx_bias
| phy
->
1808 lo_control
->tx_magn
);
1810 b43_radio_write16(dev
, 0x52,
1811 (b43_radio_read16(dev
, 0x52) & 0xFFF0)
1812 | phy
->lo_control
->tx_bias
);
1814 if (phy
->rev
>= 6) {
1815 b43_phy_write(dev
, B43_PHY_BASE(0x36),
1816 (b43_phy_read(dev
, B43_PHY_BASE(0x36))
1817 & 0x0FFF) | (phy
->lo_control
->
1820 if (dev
->dev
->bus
->sprom
.r1
.boardflags_lo
& B43_BFL_PACTRL
)
1821 b43_phy_write(dev
, B43_PHY_BASE(0x2E), 0x8075);
1823 b43_phy_write(dev
, B43_PHY_BASE(0x2E), 0x807F);
1825 b43_phy_write(dev
, B43_PHY_BASE(0x2F), 0x101);
1827 b43_phy_write(dev
, B43_PHY_BASE(0x2F), 0x202);
1829 if (phy
->gmode
|| phy
->rev
>= 2) {
1830 b43_lo_g_adjust(dev
);
1831 b43_phy_write(dev
, B43_PHY_LO_MASK
, 0x8078);
1834 if (!(dev
->dev
->bus
->sprom
.r1
.boardflags_lo
& B43_BFL_RSSI
)) {
1835 /* The specs state to update the NRSSI LT with
1836 * the value 0x7FFFFFFF here. I think that is some weird
1837 * compiler optimization in the original driver.
1838 * Essentially, what we do here is resetting all NRSSI LT
1839 * entries to -32 (see the limit_value() in nrssi_hw_update())
1841 b43_nrssi_hw_update(dev
, 0xFFFF); //FIXME?
1842 b43_calc_nrssi_threshold(dev
);
1843 } else if (phy
->gmode
|| phy
->rev
>= 2) {
1844 if (phy
->nrssi
[0] == -1000) {
1845 B43_WARN_ON(phy
->nrssi
[1] != -1000);
1846 b43_calc_nrssi_slope(dev
);
1848 b43_calc_nrssi_threshold(dev
);
1850 if (phy
->radio_rev
== 8)
1851 b43_phy_write(dev
, B43_PHY_EXTG(0x05), 0x3230);
1852 b43_phy_init_pctl(dev
);
1853 /* FIXME: The spec says in the following if, the 0 should be replaced
1854 'if OFDM may not be used in the current locale'
1855 but OFDM is legal everywhere */
1856 if ((dev
->dev
->bus
->chip_id
== 0x4306
1857 && dev
->dev
->bus
->chip_package
== 2) || 0) {
1858 b43_phy_write(dev
, B43_PHY_CRS0
, b43_phy_read(dev
, B43_PHY_CRS0
)
1860 b43_phy_write(dev
, B43_PHY_OFDM(0xC3),
1861 b43_phy_read(dev
, B43_PHY_OFDM(0xC3))
1866 /* Set the baseband attenuation value on chip. */
1867 void b43_phy_set_baseband_attenuation(struct b43_wldev
*dev
,
1868 u16 baseband_attenuation
)
1870 struct b43_phy
*phy
= &dev
->phy
;
1872 if (phy
->analog
== 0) {
1873 b43_write16(dev
, B43_MMIO_PHY0
, (b43_read16(dev
, B43_MMIO_PHY0
)
1875 baseband_attenuation
);
1876 } else if (phy
->analog
> 1) {
1877 b43_phy_write(dev
, B43_PHY_DACCTL
,
1878 (b43_phy_read(dev
, B43_PHY_DACCTL
)
1879 & 0xFFC3) | (baseband_attenuation
<< 2));
1881 b43_phy_write(dev
, B43_PHY_DACCTL
,
1882 (b43_phy_read(dev
, B43_PHY_DACCTL
)
1883 & 0xFF87) | (baseband_attenuation
<< 3));
1887 /* http://bcm-specs.sipsolutions.net/EstimatePowerOut
1888 * This function converts a TSSI value to dBm in Q5.2
1890 static s8
b43_phy_estimate_power_out(struct b43_wldev
*dev
, s8 tssi
)
1892 struct b43_phy
*phy
= &dev
->phy
;
1896 tmp
= (phy
->tgt_idle_tssi
- phy
->cur_idle_tssi
+ tssi
);
1898 switch (phy
->type
) {
1901 tmp
= limit_value(tmp
, 0x00, 0xFF);
1902 dbm
= phy
->tssi2dbm
[tmp
];
1903 //TODO: There's a FIXME on the specs
1907 tmp
= limit_value(tmp
, 0x00, 0x3F);
1908 dbm
= phy
->tssi2dbm
[tmp
];
1917 void b43_put_attenuation_into_ranges(struct b43_wldev
*dev
,
1918 int *_bbatt
, int *_rfatt
)
1920 int rfatt
= *_rfatt
;
1921 int bbatt
= *_bbatt
;
1922 struct b43_txpower_lo_control
*lo
= dev
->phy
.lo_control
;
1924 /* Get baseband and radio attenuation values into their permitted ranges.
1925 * Radio attenuation affects power level 4 times as much as baseband. */
1927 /* Range constants */
1928 const int rf_min
= lo
->rfatt_list
.min_val
;
1929 const int rf_max
= lo
->rfatt_list
.max_val
;
1930 const int bb_min
= lo
->bbatt_list
.min_val
;
1931 const int bb_max
= lo
->bbatt_list
.max_val
;
1934 if (rfatt
> rf_max
&& bbatt
> bb_max
- 4)
1935 break; /* Can not get it into ranges */
1936 if (rfatt
< rf_min
&& bbatt
< bb_min
+ 4)
1937 break; /* Can not get it into ranges */
1938 if (bbatt
> bb_max
&& rfatt
> rf_max
- 1)
1939 break; /* Can not get it into ranges */
1940 if (bbatt
< bb_min
&& rfatt
< rf_min
+ 1)
1941 break; /* Can not get it into ranges */
1943 if (bbatt
> bb_max
) {
1948 if (bbatt
< bb_min
) {
1953 if (rfatt
> rf_max
) {
1958 if (rfatt
< rf_min
) {
1966 *_rfatt
= limit_value(rfatt
, rf_min
, rf_max
);
1967 *_bbatt
= limit_value(bbatt
, bb_min
, bb_max
);
1970 /* http://bcm-specs.sipsolutions.net/RecalculateTransmissionPower */
1971 void b43_phy_xmitpower(struct b43_wldev
*dev
)
1973 struct ssb_bus
*bus
= dev
->dev
->bus
;
1974 struct b43_phy
*phy
= &dev
->phy
;
1976 if (phy
->cur_idle_tssi
== 0)
1978 if ((bus
->boardinfo
.vendor
== SSB_BOARDVENDOR_BCM
) &&
1979 (bus
->boardinfo
.type
== SSB_BOARD_BU4306
))
1981 #ifdef CONFIG_B43_DEBUG
1982 if (phy
->manual_txpower_control
)
1986 switch (phy
->type
) {
1987 case B43_PHYTYPE_A
:{
1989 //TODO: Nothing for A PHYs yet :-/
1994 case B43_PHYTYPE_G
:{
1999 int desired_pwr
, estimated_pwr
, pwr_adjust
;
2000 int rfatt_delta
, bbatt_delta
;
2003 unsigned long phylock_flags
;
2005 tmp
= b43_shm_read16(dev
, B43_SHM_SHARED
, 0x0058);
2006 v0
= (s8
) (tmp
& 0x00FF);
2007 v1
= (s8
) ((tmp
& 0xFF00) >> 8);
2008 tmp
= b43_shm_read16(dev
, B43_SHM_SHARED
, 0x005A);
2009 v2
= (s8
) (tmp
& 0x00FF);
2010 v3
= (s8
) ((tmp
& 0xFF00) >> 8);
2013 if (v0
== 0x7F || v1
== 0x7F || v2
== 0x7F
2016 b43_shm_read16(dev
, B43_SHM_SHARED
, 0x0070);
2017 v0
= (s8
) (tmp
& 0x00FF);
2018 v1
= (s8
) ((tmp
& 0xFF00) >> 8);
2020 b43_shm_read16(dev
, B43_SHM_SHARED
, 0x0072);
2021 v2
= (s8
) (tmp
& 0x00FF);
2022 v3
= (s8
) ((tmp
& 0xFF00) >> 8);
2023 if (v0
== 0x7F || v1
== 0x7F || v2
== 0x7F
2026 v0
= (v0
+ 0x20) & 0x3F;
2027 v1
= (v1
+ 0x20) & 0x3F;
2028 v2
= (v2
+ 0x20) & 0x3F;
2029 v3
= (v3
+ 0x20) & 0x3F;
2032 b43_shm_clear_tssi(dev
);
2034 average
= (v0
+ v1
+ v2
+ v3
+ 2) / 4;
2037 && (b43_shm_read16(dev
, B43_SHM_SHARED
, 0x005E) &
2042 b43_phy_estimate_power_out(dev
, average
);
2044 max_pwr
= dev
->dev
->bus
->sprom
.r1
.maxpwr_bg
;
2045 if ((dev
->dev
->bus
->sprom
.r1
.
2046 boardflags_lo
& B43_BFL_PACTRL
)
2047 && (phy
->type
== B43_PHYTYPE_G
))
2049 if (unlikely(max_pwr
<= 0)) {
2051 "Invalid max-TX-power value in SPROM.\n");
2052 max_pwr
= 60; /* fake it */
2053 dev
->dev
->bus
->sprom
.r1
.maxpwr_bg
= max_pwr
;
2057 max_pwr = min(REG - dev->dev->bus->sprom.antennagain_bgphy - 0x6, max_pwr)
2058 where REG is the max power as per the regulatory domain
2061 /* Get desired power (in Q5.2) */
2062 desired_pwr
= INT_TO_Q52(phy
->power_level
);
2063 /* And limit it. max_pwr already is Q5.2 */
2064 desired_pwr
= limit_value(desired_pwr
, 0, max_pwr
);
2065 if (b43_debug(dev
, B43_DBG_XMITPOWER
)) {
2067 "Current TX power output: " Q52_FMT
2068 " dBm, " "Desired TX power output: "
2069 Q52_FMT
" dBm\n", Q52_ARG(estimated_pwr
),
2070 Q52_ARG(desired_pwr
));
2073 /* Calculate the adjustment delta. */
2074 pwr_adjust
= desired_pwr
- estimated_pwr
;
2076 /* RF attenuation delta. */
2077 rfatt_delta
= ((pwr_adjust
+ 7) / 8);
2078 /* Lower attenuation => Bigger power output. Negate it. */
2079 rfatt_delta
= -rfatt_delta
;
2081 /* Baseband attenuation delta. */
2082 bbatt_delta
= pwr_adjust
/ 2;
2083 /* Lower attenuation => Bigger power output. Negate it. */
2084 bbatt_delta
= -bbatt_delta
;
2085 /* RF att affects power level 4 times as much as
2086 * Baseband attennuation. Subtract it. */
2087 bbatt_delta
-= 4 * rfatt_delta
;
2089 /* So do we finally need to adjust something? */
2090 if ((rfatt_delta
== 0) && (bbatt_delta
== 0)) {
2091 b43_lo_g_ctl_mark_cur_used(dev
);
2095 /* Calculate the new attenuation values. */
2096 bbatt
= phy
->bbatt
.att
;
2097 bbatt
+= bbatt_delta
;
2098 rfatt
= phy
->rfatt
.att
;
2099 rfatt
+= rfatt_delta
;
2101 b43_put_attenuation_into_ranges(dev
, &bbatt
, &rfatt
);
2102 tx_control
= phy
->tx_control
;
2103 if ((phy
->radio_ver
== 0x2050) && (phy
->radio_rev
== 2)) {
2105 if (tx_control
== 0) {
2111 } else if (dev
->dev
->bus
->sprom
.r1
.
2114 bbatt
+= 4 * (rfatt
- 2);
2117 } else if (rfatt
> 4 && tx_control
) {
2128 /* Save the control values */
2129 phy
->tx_control
= tx_control
;
2130 b43_put_attenuation_into_ranges(dev
, &bbatt
, &rfatt
);
2131 phy
->rfatt
.att
= rfatt
;
2132 phy
->bbatt
.att
= bbatt
;
2134 /* Adjust the hardware */
2135 b43_phy_lock(dev
, phylock_flags
);
2136 b43_radio_lock(dev
);
2137 b43_set_txpower_g(dev
, &phy
->bbatt
, &phy
->rfatt
,
2139 b43_lo_g_ctl_mark_cur_used(dev
);
2140 b43_radio_unlock(dev
);
2141 b43_phy_unlock(dev
, phylock_flags
);
2149 static inline s32
b43_tssi2dbm_ad(s32 num
, s32 den
)
2154 return (num
+ den
/ 2) / den
;
2158 s8
b43_tssi2dbm_entry(s8 entry
[], u8 index
, s16 pab0
, s16 pab1
, s16 pab2
)
2160 s32 m1
, m2
, f
= 256, q
, delta
;
2163 m1
= b43_tssi2dbm_ad(16 * pab0
+ index
* pab1
, 32);
2164 m2
= max(b43_tssi2dbm_ad(32768 + index
* pab2
, 256), 1);
2168 q
= b43_tssi2dbm_ad(f
* 4096 -
2169 b43_tssi2dbm_ad(m2
* f
, 16) * f
, 2048);
2173 } while (delta
>= 2);
2174 entry
[index
] = limit_value(b43_tssi2dbm_ad(m1
* f
, 8192), -127, 128);
2178 /* http://bcm-specs.sipsolutions.net/TSSI_to_DBM_Table */
2179 int b43_phy_init_tssi2dbm_table(struct b43_wldev
*dev
)
2181 struct b43_phy
*phy
= &dev
->phy
;
2182 s16 pab0
, pab1
, pab2
;
2186 if (phy
->type
== B43_PHYTYPE_A
) {
2187 pab0
= (s16
) (dev
->dev
->bus
->sprom
.r1
.pa1b0
);
2188 pab1
= (s16
) (dev
->dev
->bus
->sprom
.r1
.pa1b1
);
2189 pab2
= (s16
) (dev
->dev
->bus
->sprom
.r1
.pa1b2
);
2191 pab0
= (s16
) (dev
->dev
->bus
->sprom
.r1
.pa0b0
);
2192 pab1
= (s16
) (dev
->dev
->bus
->sprom
.r1
.pa0b1
);
2193 pab2
= (s16
) (dev
->dev
->bus
->sprom
.r1
.pa0b2
);
2196 if ((dev
->dev
->bus
->chip_id
== 0x4301) && (phy
->radio_ver
!= 0x2050)) {
2197 phy
->tgt_idle_tssi
= 0x34;
2198 phy
->tssi2dbm
= b43_tssi2dbm_b_table
;
2202 if (pab0
!= 0 && pab1
!= 0 && pab2
!= 0 &&
2203 pab0
!= -1 && pab1
!= -1 && pab2
!= -1) {
2204 /* The pabX values are set in SPROM. Use them. */
2205 if (phy
->type
== B43_PHYTYPE_A
) {
2206 if ((s8
) dev
->dev
->bus
->sprom
.r1
.itssi_a
!= 0 &&
2207 (s8
) dev
->dev
->bus
->sprom
.r1
.itssi_a
!= -1)
2208 phy
->tgt_idle_tssi
=
2209 (s8
) (dev
->dev
->bus
->sprom
.r1
.itssi_a
);
2211 phy
->tgt_idle_tssi
= 62;
2213 if ((s8
) dev
->dev
->bus
->sprom
.r1
.itssi_bg
!= 0 &&
2214 (s8
) dev
->dev
->bus
->sprom
.r1
.itssi_bg
!= -1)
2215 phy
->tgt_idle_tssi
=
2216 (s8
) (dev
->dev
->bus
->sprom
.r1
.itssi_bg
);
2218 phy
->tgt_idle_tssi
= 62;
2220 dyn_tssi2dbm
= kmalloc(64, GFP_KERNEL
);
2221 if (dyn_tssi2dbm
== NULL
) {
2222 b43err(dev
->wl
, "Could not allocate memory"
2223 "for tssi2dbm table\n");
2226 for (idx
= 0; idx
< 64; idx
++)
2227 if (b43_tssi2dbm_entry
2228 (dyn_tssi2dbm
, idx
, pab0
, pab1
, pab2
)) {
2229 phy
->tssi2dbm
= NULL
;
2230 b43err(dev
->wl
, "Could not generate "
2231 "tssi2dBm table\n");
2232 kfree(dyn_tssi2dbm
);
2235 phy
->tssi2dbm
= dyn_tssi2dbm
;
2236 phy
->dyn_tssi_tbl
= 1;
2238 /* pabX values not set in SPROM. */
2239 switch (phy
->type
) {
2241 /* APHY needs a generated table. */
2242 phy
->tssi2dbm
= NULL
;
2243 b43err(dev
->wl
, "Could not generate tssi2dBm "
2244 "table (wrong SPROM info)!\n");
2247 phy
->tgt_idle_tssi
= 0x34;
2248 phy
->tssi2dbm
= b43_tssi2dbm_b_table
;
2251 phy
->tgt_idle_tssi
= 0x34;
2252 phy
->tssi2dbm
= b43_tssi2dbm_g_table
;
2260 int b43_phy_init(struct b43_wldev
*dev
)
2262 struct b43_phy
*phy
= &dev
->phy
;
2265 switch (phy
->type
) {
2267 if (phy
->rev
== 2 || phy
->rev
== 3) {
2275 b43_phy_initb2(dev
);
2279 b43_phy_initb4(dev
);
2283 b43_phy_initb5(dev
);
2287 b43_phy_initb6(dev
);
2298 b43err(dev
->wl
, "Unknown PHYTYPE found\n");
2303 void b43_set_rx_antenna(struct b43_wldev
*dev
, int antenna
)
2305 struct b43_phy
*phy
= &dev
->phy
;
2310 if (antenna
== B43_ANTENNA_AUTO0
|| antenna
== B43_ANTENNA_AUTO1
)
2313 hf
= b43_hf_read(dev
);
2314 hf
&= ~B43_HF_ANTDIVHELP
;
2315 b43_hf_write(dev
, hf
);
2317 switch (phy
->type
) {
2320 tmp
= b43_phy_read(dev
, B43_PHY_BBANDCFG
);
2321 tmp
&= ~B43_PHY_BBANDCFG_RXANT
;
2322 tmp
|= (autodiv
? B43_ANTENNA_AUTO0
: antenna
)
2323 << B43_PHY_BBANDCFG_RXANT_SHIFT
;
2324 b43_phy_write(dev
, B43_PHY_BBANDCFG
, tmp
);
2327 tmp
= b43_phy_read(dev
, B43_PHY_ANTDWELL
);
2328 if (antenna
== B43_ANTENNA_AUTO0
)
2329 tmp
&= ~B43_PHY_ANTDWELL_AUTODIV1
;
2331 tmp
|= B43_PHY_ANTDWELL_AUTODIV1
;
2332 b43_phy_write(dev
, B43_PHY_ANTDWELL
, tmp
);
2334 if (phy
->type
== B43_PHYTYPE_G
) {
2335 tmp
= b43_phy_read(dev
, B43_PHY_ANTWRSETT
);
2337 tmp
|= B43_PHY_ANTWRSETT_ARXDIV
;
2339 tmp
&= ~B43_PHY_ANTWRSETT_ARXDIV
;
2340 b43_phy_write(dev
, B43_PHY_ANTWRSETT
, tmp
);
2341 if (phy
->rev
>= 2) {
2342 tmp
= b43_phy_read(dev
, B43_PHY_OFDM61
);
2343 tmp
|= B43_PHY_OFDM61_10
;
2344 b43_phy_write(dev
, B43_PHY_OFDM61
, tmp
);
2347 b43_phy_read(dev
, B43_PHY_DIVSRCHGAINBACK
);
2348 tmp
= (tmp
& 0xFF00) | 0x15;
2349 b43_phy_write(dev
, B43_PHY_DIVSRCHGAINBACK
,
2352 if (phy
->rev
== 2) {
2353 b43_phy_write(dev
, B43_PHY_ADIVRELATED
,
2358 B43_PHY_ADIVRELATED
);
2359 tmp
= (tmp
& 0xFF00) | 8;
2360 b43_phy_write(dev
, B43_PHY_ADIVRELATED
,
2365 b43_phy_write(dev
, B43_PHY_OFDM9B
, 0xDC);
2368 tmp
= b43_phy_read(dev
, B43_PHY_ANTDWELL
);
2369 tmp
= (tmp
& 0xFF00) | 0x24;
2370 b43_phy_write(dev
, B43_PHY_ANTDWELL
, tmp
);
2372 tmp
= b43_phy_read(dev
, B43_PHY_OFDM61
);
2374 b43_phy_write(dev
, B43_PHY_OFDM61
, tmp
);
2375 if (phy
->analog
== 3) {
2376 b43_phy_write(dev
, B43_PHY_CLIPPWRDOWNT
,
2378 b43_phy_write(dev
, B43_PHY_ADIVRELATED
,
2381 b43_phy_write(dev
, B43_PHY_CLIPPWRDOWNT
,
2385 B43_PHY_ADIVRELATED
);
2386 tmp
= (tmp
& 0xFF00) | 8;
2387 b43_phy_write(dev
, B43_PHY_ADIVRELATED
,
2394 tmp
= b43_phy_read(dev
, B43_PHY_CCKBBANDCFG
);
2395 tmp
&= ~B43_PHY_BBANDCFG_RXANT
;
2396 tmp
|= (autodiv
? B43_ANTENNA_AUTO0
: antenna
)
2397 << B43_PHY_BBANDCFG_RXANT_SHIFT
;
2398 b43_phy_write(dev
, B43_PHY_CCKBBANDCFG
, tmp
);
2404 hf
|= B43_HF_ANTDIVHELP
;
2405 b43_hf_write(dev
, hf
);
2408 /* Get the freq, as it has to be written to the device. */
2409 static inline u16
channel2freq_bg(u8 channel
)
2411 B43_WARN_ON(!(channel
>= 1 && channel
<= 14));
2413 return b43_radio_channel_codes_bg
[channel
- 1];
2416 /* Get the freq, as it has to be written to the device. */
2417 static inline u16
channel2freq_a(u8 channel
)
2419 B43_WARN_ON(channel
> 200);
2421 return (5000 + 5 * channel
);
2424 void b43_radio_lock(struct b43_wldev
*dev
)
2428 macctl
= b43_read32(dev
, B43_MMIO_MACCTL
);
2429 macctl
|= B43_MACCTL_RADIOLOCK
;
2430 b43_write32(dev
, B43_MMIO_MACCTL
, macctl
);
2431 /* Commit the write and wait for the device
2432 * to exit any radio register access. */
2433 b43_read32(dev
, B43_MMIO_MACCTL
);
2437 void b43_radio_unlock(struct b43_wldev
*dev
)
2441 /* Commit any write */
2442 b43_read16(dev
, B43_MMIO_PHY_VER
);
2444 macctl
= b43_read32(dev
, B43_MMIO_MACCTL
);
2445 macctl
&= ~B43_MACCTL_RADIOLOCK
;
2446 b43_write32(dev
, B43_MMIO_MACCTL
, macctl
);
2449 u16
b43_radio_read16(struct b43_wldev
*dev
, u16 offset
)
2451 struct b43_phy
*phy
= &dev
->phy
;
2453 switch (phy
->type
) {
2458 if (phy
->radio_ver
== 0x2053) {
2461 else if (offset
< 0x80)
2463 } else if (phy
->radio_ver
== 0x2050) {
2473 b43_write16(dev
, B43_MMIO_RADIO_CONTROL
, offset
);
2474 return b43_read16(dev
, B43_MMIO_RADIO_DATA_LOW
);
2477 void b43_radio_write16(struct b43_wldev
*dev
, u16 offset
, u16 val
)
2479 b43_write16(dev
, B43_MMIO_RADIO_CONTROL
, offset
);
2481 b43_write16(dev
, B43_MMIO_RADIO_DATA_LOW
, val
);
2484 static void b43_set_all_gains(struct b43_wldev
*dev
,
2485 s16 first
, s16 second
, s16 third
)
2487 struct b43_phy
*phy
= &dev
->phy
;
2489 u16 start
= 0x08, end
= 0x18;
2493 if (phy
->rev
<= 1) {
2498 table
= B43_OFDMTAB_GAINX
;
2500 table
= B43_OFDMTAB_GAINX_R1
;
2501 for (i
= 0; i
< 4; i
++)
2502 b43_ofdmtab_write16(dev
, table
, i
, first
);
2504 for (i
= start
; i
< end
; i
++)
2505 b43_ofdmtab_write16(dev
, table
, i
, second
);
2508 tmp
= ((u16
) third
<< 14) | ((u16
) third
<< 6);
2509 b43_phy_write(dev
, 0x04A0,
2510 (b43_phy_read(dev
, 0x04A0) & 0xBFBF) | tmp
);
2511 b43_phy_write(dev
, 0x04A1,
2512 (b43_phy_read(dev
, 0x04A1) & 0xBFBF) | tmp
);
2513 b43_phy_write(dev
, 0x04A2,
2514 (b43_phy_read(dev
, 0x04A2) & 0xBFBF) | tmp
);
2516 b43_dummy_transmission(dev
);
2519 static void b43_set_original_gains(struct b43_wldev
*dev
)
2521 struct b43_phy
*phy
= &dev
->phy
;
2524 u16 start
= 0x0008, end
= 0x0018;
2526 if (phy
->rev
<= 1) {
2531 table
= B43_OFDMTAB_GAINX
;
2533 table
= B43_OFDMTAB_GAINX_R1
;
2534 for (i
= 0; i
< 4; i
++) {
2536 tmp
|= (i
& 0x0001) << 1;
2537 tmp
|= (i
& 0x0002) >> 1;
2539 b43_ofdmtab_write16(dev
, table
, i
, tmp
);
2542 for (i
= start
; i
< end
; i
++)
2543 b43_ofdmtab_write16(dev
, table
, i
, i
- start
);
2545 b43_phy_write(dev
, 0x04A0,
2546 (b43_phy_read(dev
, 0x04A0) & 0xBFBF) | 0x4040);
2547 b43_phy_write(dev
, 0x04A1,
2548 (b43_phy_read(dev
, 0x04A1) & 0xBFBF) | 0x4040);
2549 b43_phy_write(dev
, 0x04A2,
2550 (b43_phy_read(dev
, 0x04A2) & 0xBFBF) | 0x4000);
2551 b43_dummy_transmission(dev
);
2554 /* Synthetic PU workaround */
2555 static void b43_synth_pu_workaround(struct b43_wldev
*dev
, u8 channel
)
2557 struct b43_phy
*phy
= &dev
->phy
;
2561 if (phy
->radio_ver
!= 0x2050 || phy
->radio_rev
>= 6) {
2562 /* We do not need the workaround. */
2566 if (channel
<= 10) {
2567 b43_write16(dev
, B43_MMIO_CHANNEL
,
2568 channel2freq_bg(channel
+ 4));
2570 b43_write16(dev
, B43_MMIO_CHANNEL
, channel2freq_bg(1));
2573 b43_write16(dev
, B43_MMIO_CHANNEL
, channel2freq_bg(channel
));
2576 u8
b43_radio_aci_detect(struct b43_wldev
*dev
, u8 channel
)
2578 struct b43_phy
*phy
= &dev
->phy
;
2580 u16 saved
, rssi
, temp
;
2583 saved
= b43_phy_read(dev
, 0x0403);
2584 b43_radio_selectchannel(dev
, channel
, 0);
2585 b43_phy_write(dev
, 0x0403, (saved
& 0xFFF8) | 5);
2586 if (phy
->aci_hw_rssi
)
2587 rssi
= b43_phy_read(dev
, 0x048A) & 0x3F;
2589 rssi
= saved
& 0x3F;
2590 /* clamp temp to signed 5bit */
2593 for (i
= 0; i
< 100; i
++) {
2594 temp
= (b43_phy_read(dev
, 0x047F) >> 8) & 0x3F;
2602 b43_phy_write(dev
, 0x0403, saved
);
2607 u8
b43_radio_aci_scan(struct b43_wldev
* dev
)
2609 struct b43_phy
*phy
= &dev
->phy
;
2611 unsigned int channel
= phy
->channel
;
2612 unsigned int i
, j
, start
, end
;
2613 unsigned long phylock_flags
;
2615 if (!((phy
->type
== B43_PHYTYPE_G
) && (phy
->rev
> 0)))
2618 b43_phy_lock(dev
, phylock_flags
);
2619 b43_radio_lock(dev
);
2620 b43_phy_write(dev
, 0x0802, b43_phy_read(dev
, 0x0802) & 0xFFFC);
2621 b43_phy_write(dev
, B43_PHY_G_CRS
,
2622 b43_phy_read(dev
, B43_PHY_G_CRS
) & 0x7FFF);
2623 b43_set_all_gains(dev
, 3, 8, 1);
2625 start
= (channel
- 5 > 0) ? channel
- 5 : 1;
2626 end
= (channel
+ 5 < 14) ? channel
+ 5 : 13;
2628 for (i
= start
; i
<= end
; i
++) {
2629 if (abs(channel
- i
) > 2)
2630 ret
[i
- 1] = b43_radio_aci_detect(dev
, i
);
2632 b43_radio_selectchannel(dev
, channel
, 0);
2633 b43_phy_write(dev
, 0x0802,
2634 (b43_phy_read(dev
, 0x0802) & 0xFFFC) | 0x0003);
2635 b43_phy_write(dev
, 0x0403, b43_phy_read(dev
, 0x0403) & 0xFFF8);
2636 b43_phy_write(dev
, B43_PHY_G_CRS
,
2637 b43_phy_read(dev
, B43_PHY_G_CRS
) | 0x8000);
2638 b43_set_original_gains(dev
);
2639 for (i
= 0; i
< 13; i
++) {
2642 end
= (i
+ 5 < 13) ? i
+ 5 : 13;
2643 for (j
= i
; j
< end
; j
++)
2646 b43_radio_unlock(dev
);
2647 b43_phy_unlock(dev
, phylock_flags
);
2649 return ret
[channel
- 1];
2652 /* http://bcm-specs.sipsolutions.net/NRSSILookupTable */
2653 void b43_nrssi_hw_write(struct b43_wldev
*dev
, u16 offset
, s16 val
)
2655 b43_phy_write(dev
, B43_PHY_NRSSILT_CTRL
, offset
);
2657 b43_phy_write(dev
, B43_PHY_NRSSILT_DATA
, (u16
) val
);
2660 /* http://bcm-specs.sipsolutions.net/NRSSILookupTable */
2661 s16
b43_nrssi_hw_read(struct b43_wldev
*dev
, u16 offset
)
2665 b43_phy_write(dev
, B43_PHY_NRSSILT_CTRL
, offset
);
2666 val
= b43_phy_read(dev
, B43_PHY_NRSSILT_DATA
);
2671 /* http://bcm-specs.sipsolutions.net/NRSSILookupTable */
2672 void b43_nrssi_hw_update(struct b43_wldev
*dev
, u16 val
)
2677 for (i
= 0; i
< 64; i
++) {
2678 tmp
= b43_nrssi_hw_read(dev
, i
);
2680 tmp
= limit_value(tmp
, -32, 31);
2681 b43_nrssi_hw_write(dev
, i
, tmp
);
2685 /* http://bcm-specs.sipsolutions.net/NRSSILookupTable */
2686 void b43_nrssi_mem_update(struct b43_wldev
*dev
)
2688 struct b43_phy
*phy
= &dev
->phy
;
2692 delta
= 0x1F - phy
->nrssi
[0];
2693 for (i
= 0; i
< 64; i
++) {
2694 tmp
= (i
- delta
) * phy
->nrssislope
;
2697 tmp
= limit_value(tmp
, 0, 0x3F);
2698 phy
->nrssi_lt
[i
] = tmp
;
2702 static void b43_calc_nrssi_offset(struct b43_wldev
*dev
)
2704 struct b43_phy
*phy
= &dev
->phy
;
2705 u16 backup
[20] = { 0 };
2710 backup
[0] = b43_phy_read(dev
, 0x0001);
2711 backup
[1] = b43_phy_read(dev
, 0x0811);
2712 backup
[2] = b43_phy_read(dev
, 0x0812);
2713 if (phy
->rev
!= 1) { /* Not in specs, but needed to prevent PPC machine check */
2714 backup
[3] = b43_phy_read(dev
, 0x0814);
2715 backup
[4] = b43_phy_read(dev
, 0x0815);
2717 backup
[5] = b43_phy_read(dev
, 0x005A);
2718 backup
[6] = b43_phy_read(dev
, 0x0059);
2719 backup
[7] = b43_phy_read(dev
, 0x0058);
2720 backup
[8] = b43_phy_read(dev
, 0x000A);
2721 backup
[9] = b43_phy_read(dev
, 0x0003);
2722 backup
[10] = b43_radio_read16(dev
, 0x007A);
2723 backup
[11] = b43_radio_read16(dev
, 0x0043);
2725 b43_phy_write(dev
, 0x0429, b43_phy_read(dev
, 0x0429) & 0x7FFF);
2726 b43_phy_write(dev
, 0x0001,
2727 (b43_phy_read(dev
, 0x0001) & 0x3FFF) | 0x4000);
2728 b43_phy_write(dev
, 0x0811, b43_phy_read(dev
, 0x0811) | 0x000C);
2729 b43_phy_write(dev
, 0x0812,
2730 (b43_phy_read(dev
, 0x0812) & 0xFFF3) | 0x0004);
2731 b43_phy_write(dev
, 0x0802, b43_phy_read(dev
, 0x0802) & ~(0x1 | 0x2));
2732 if (phy
->rev
>= 6) {
2733 backup
[12] = b43_phy_read(dev
, 0x002E);
2734 backup
[13] = b43_phy_read(dev
, 0x002F);
2735 backup
[14] = b43_phy_read(dev
, 0x080F);
2736 backup
[15] = b43_phy_read(dev
, 0x0810);
2737 backup
[16] = b43_phy_read(dev
, 0x0801);
2738 backup
[17] = b43_phy_read(dev
, 0x0060);
2739 backup
[18] = b43_phy_read(dev
, 0x0014);
2740 backup
[19] = b43_phy_read(dev
, 0x0478);
2742 b43_phy_write(dev
, 0x002E, 0);
2743 b43_phy_write(dev
, 0x002F, 0);
2744 b43_phy_write(dev
, 0x080F, 0);
2745 b43_phy_write(dev
, 0x0810, 0);
2746 b43_phy_write(dev
, 0x0478, b43_phy_read(dev
, 0x0478) | 0x0100);
2747 b43_phy_write(dev
, 0x0801, b43_phy_read(dev
, 0x0801) | 0x0040);
2748 b43_phy_write(dev
, 0x0060, b43_phy_read(dev
, 0x0060) | 0x0040);
2749 b43_phy_write(dev
, 0x0014, b43_phy_read(dev
, 0x0014) | 0x0200);
2751 b43_radio_write16(dev
, 0x007A, b43_radio_read16(dev
, 0x007A) | 0x0070);
2752 b43_radio_write16(dev
, 0x007A, b43_radio_read16(dev
, 0x007A) | 0x0080);
2755 v47F
= (s16
) ((b43_phy_read(dev
, 0x047F) >> 8) & 0x003F);
2759 for (i
= 7; i
>= 4; i
--) {
2760 b43_radio_write16(dev
, 0x007B, i
);
2763 (s16
) ((b43_phy_read(dev
, 0x047F) >> 8) & 0x003F);
2766 if (v47F
< 31 && saved
== 0xFFFF)
2769 if (saved
== 0xFFFF)
2772 b43_radio_write16(dev
, 0x007A,
2773 b43_radio_read16(dev
, 0x007A) & 0x007F);
2774 if (phy
->rev
!= 1) { /* Not in specs, but needed to prevent PPC machine check */
2775 b43_phy_write(dev
, 0x0814,
2776 b43_phy_read(dev
, 0x0814) | 0x0001);
2777 b43_phy_write(dev
, 0x0815,
2778 b43_phy_read(dev
, 0x0815) & 0xFFFE);
2780 b43_phy_write(dev
, 0x0811, b43_phy_read(dev
, 0x0811) | 0x000C);
2781 b43_phy_write(dev
, 0x0812, b43_phy_read(dev
, 0x0812) | 0x000C);
2782 b43_phy_write(dev
, 0x0811, b43_phy_read(dev
, 0x0811) | 0x0030);
2783 b43_phy_write(dev
, 0x0812, b43_phy_read(dev
, 0x0812) | 0x0030);
2784 b43_phy_write(dev
, 0x005A, 0x0480);
2785 b43_phy_write(dev
, 0x0059, 0x0810);
2786 b43_phy_write(dev
, 0x0058, 0x000D);
2787 if (phy
->rev
== 0) {
2788 b43_phy_write(dev
, 0x0003, 0x0122);
2790 b43_phy_write(dev
, 0x000A, b43_phy_read(dev
, 0x000A)
2793 if (phy
->rev
!= 1) { /* Not in specs, but needed to prevent PPC machine check */
2794 b43_phy_write(dev
, 0x0814,
2795 b43_phy_read(dev
, 0x0814) | 0x0004);
2796 b43_phy_write(dev
, 0x0815,
2797 b43_phy_read(dev
, 0x0815) & 0xFFFB);
2799 b43_phy_write(dev
, 0x0003, (b43_phy_read(dev
, 0x0003) & 0xFF9F)
2801 b43_radio_write16(dev
, 0x007A,
2802 b43_radio_read16(dev
, 0x007A) | 0x000F);
2803 b43_set_all_gains(dev
, 3, 0, 1);
2804 b43_radio_write16(dev
, 0x0043, (b43_radio_read16(dev
, 0x0043)
2805 & 0x00F0) | 0x000F);
2807 v47F
= (s16
) ((b43_phy_read(dev
, 0x047F) >> 8) & 0x003F);
2811 for (i
= 0; i
< 4; i
++) {
2812 b43_radio_write16(dev
, 0x007B, i
);
2815 (s16
) ((b43_phy_read(dev
, 0x047F) >> 8) &
2819 if (v47F
> -31 && saved
== 0xFFFF)
2822 if (saved
== 0xFFFF)
2827 b43_radio_write16(dev
, 0x007B, saved
);
2829 if (phy
->rev
>= 6) {
2830 b43_phy_write(dev
, 0x002E, backup
[12]);
2831 b43_phy_write(dev
, 0x002F, backup
[13]);
2832 b43_phy_write(dev
, 0x080F, backup
[14]);
2833 b43_phy_write(dev
, 0x0810, backup
[15]);
2835 if (phy
->rev
!= 1) { /* Not in specs, but needed to prevent PPC machine check */
2836 b43_phy_write(dev
, 0x0814, backup
[3]);
2837 b43_phy_write(dev
, 0x0815, backup
[4]);
2839 b43_phy_write(dev
, 0x005A, backup
[5]);
2840 b43_phy_write(dev
, 0x0059, backup
[6]);
2841 b43_phy_write(dev
, 0x0058, backup
[7]);
2842 b43_phy_write(dev
, 0x000A, backup
[8]);
2843 b43_phy_write(dev
, 0x0003, backup
[9]);
2844 b43_radio_write16(dev
, 0x0043, backup
[11]);
2845 b43_radio_write16(dev
, 0x007A, backup
[10]);
2846 b43_phy_write(dev
, 0x0802, b43_phy_read(dev
, 0x0802) | 0x1 | 0x2);
2847 b43_phy_write(dev
, 0x0429, b43_phy_read(dev
, 0x0429) | 0x8000);
2848 b43_set_original_gains(dev
);
2849 if (phy
->rev
>= 6) {
2850 b43_phy_write(dev
, 0x0801, backup
[16]);
2851 b43_phy_write(dev
, 0x0060, backup
[17]);
2852 b43_phy_write(dev
, 0x0014, backup
[18]);
2853 b43_phy_write(dev
, 0x0478, backup
[19]);
2855 b43_phy_write(dev
, 0x0001, backup
[0]);
2856 b43_phy_write(dev
, 0x0812, backup
[2]);
2857 b43_phy_write(dev
, 0x0811, backup
[1]);
2860 void b43_calc_nrssi_slope(struct b43_wldev
*dev
)
2862 struct b43_phy
*phy
= &dev
->phy
;
2863 u16 backup
[18] = { 0 };
2867 switch (phy
->type
) {
2869 backup
[0] = b43_radio_read16(dev
, 0x007A);
2870 backup
[1] = b43_radio_read16(dev
, 0x0052);
2871 backup
[2] = b43_radio_read16(dev
, 0x0043);
2872 backup
[3] = b43_phy_read(dev
, 0x0030);
2873 backup
[4] = b43_phy_read(dev
, 0x0026);
2874 backup
[5] = b43_phy_read(dev
, 0x0015);
2875 backup
[6] = b43_phy_read(dev
, 0x002A);
2876 backup
[7] = b43_phy_read(dev
, 0x0020);
2877 backup
[8] = b43_phy_read(dev
, 0x005A);
2878 backup
[9] = b43_phy_read(dev
, 0x0059);
2879 backup
[10] = b43_phy_read(dev
, 0x0058);
2880 backup
[11] = b43_read16(dev
, 0x03E2);
2881 backup
[12] = b43_read16(dev
, 0x03E6);
2882 backup
[13] = b43_read16(dev
, B43_MMIO_CHANNEL_EXT
);
2884 tmp
= b43_radio_read16(dev
, 0x007A);
2885 tmp
&= (phy
->rev
>= 5) ? 0x007F : 0x000F;
2886 b43_radio_write16(dev
, 0x007A, tmp
);
2887 b43_phy_write(dev
, 0x0030, 0x00FF);
2888 b43_write16(dev
, 0x03EC, 0x7F7F);
2889 b43_phy_write(dev
, 0x0026, 0x0000);
2890 b43_phy_write(dev
, 0x0015, b43_phy_read(dev
, 0x0015) | 0x0020);
2891 b43_phy_write(dev
, 0x002A, 0x08A3);
2892 b43_radio_write16(dev
, 0x007A,
2893 b43_radio_read16(dev
, 0x007A) | 0x0080);
2895 nrssi0
= (s16
) b43_phy_read(dev
, 0x0027);
2896 b43_radio_write16(dev
, 0x007A,
2897 b43_radio_read16(dev
, 0x007A) & 0x007F);
2898 if (phy
->rev
>= 2) {
2899 b43_write16(dev
, 0x03E6, 0x0040);
2900 } else if (phy
->rev
== 0) {
2901 b43_write16(dev
, 0x03E6, 0x0122);
2903 b43_write16(dev
, B43_MMIO_CHANNEL_EXT
,
2905 B43_MMIO_CHANNEL_EXT
) & 0x2000);
2907 b43_phy_write(dev
, 0x0020, 0x3F3F);
2908 b43_phy_write(dev
, 0x0015, 0xF330);
2909 b43_radio_write16(dev
, 0x005A, 0x0060);
2910 b43_radio_write16(dev
, 0x0043,
2911 b43_radio_read16(dev
, 0x0043) & 0x00F0);
2912 b43_phy_write(dev
, 0x005A, 0x0480);
2913 b43_phy_write(dev
, 0x0059, 0x0810);
2914 b43_phy_write(dev
, 0x0058, 0x000D);
2917 nrssi1
= (s16
) b43_phy_read(dev
, 0x0027);
2918 b43_phy_write(dev
, 0x0030, backup
[3]);
2919 b43_radio_write16(dev
, 0x007A, backup
[0]);
2920 b43_write16(dev
, 0x03E2, backup
[11]);
2921 b43_phy_write(dev
, 0x0026, backup
[4]);
2922 b43_phy_write(dev
, 0x0015, backup
[5]);
2923 b43_phy_write(dev
, 0x002A, backup
[6]);
2924 b43_synth_pu_workaround(dev
, phy
->channel
);
2926 b43_write16(dev
, 0x03F4, backup
[13]);
2928 b43_phy_write(dev
, 0x0020, backup
[7]);
2929 b43_phy_write(dev
, 0x005A, backup
[8]);
2930 b43_phy_write(dev
, 0x0059, backup
[9]);
2931 b43_phy_write(dev
, 0x0058, backup
[10]);
2932 b43_radio_write16(dev
, 0x0052, backup
[1]);
2933 b43_radio_write16(dev
, 0x0043, backup
[2]);
2935 if (nrssi0
== nrssi1
)
2936 phy
->nrssislope
= 0x00010000;
2938 phy
->nrssislope
= 0x00400000 / (nrssi0
- nrssi1
);
2941 phy
->nrssi
[0] = nrssi0
;
2942 phy
->nrssi
[1] = nrssi1
;
2946 if (phy
->radio_rev
>= 9)
2948 if (phy
->radio_rev
== 8)
2949 b43_calc_nrssi_offset(dev
);
2951 b43_phy_write(dev
, B43_PHY_G_CRS
,
2952 b43_phy_read(dev
, B43_PHY_G_CRS
) & 0x7FFF);
2953 b43_phy_write(dev
, 0x0802, b43_phy_read(dev
, 0x0802) & 0xFFFC);
2954 backup
[7] = b43_read16(dev
, 0x03E2);
2955 b43_write16(dev
, 0x03E2, b43_read16(dev
, 0x03E2) | 0x8000);
2956 backup
[0] = b43_radio_read16(dev
, 0x007A);
2957 backup
[1] = b43_radio_read16(dev
, 0x0052);
2958 backup
[2] = b43_radio_read16(dev
, 0x0043);
2959 backup
[3] = b43_phy_read(dev
, 0x0015);
2960 backup
[4] = b43_phy_read(dev
, 0x005A);
2961 backup
[5] = b43_phy_read(dev
, 0x0059);
2962 backup
[6] = b43_phy_read(dev
, 0x0058);
2963 backup
[8] = b43_read16(dev
, 0x03E6);
2964 backup
[9] = b43_read16(dev
, B43_MMIO_CHANNEL_EXT
);
2965 if (phy
->rev
>= 3) {
2966 backup
[10] = b43_phy_read(dev
, 0x002E);
2967 backup
[11] = b43_phy_read(dev
, 0x002F);
2968 backup
[12] = b43_phy_read(dev
, 0x080F);
2969 backup
[13] = b43_phy_read(dev
, B43_PHY_G_LO_CONTROL
);
2970 backup
[14] = b43_phy_read(dev
, 0x0801);
2971 backup
[15] = b43_phy_read(dev
, 0x0060);
2972 backup
[16] = b43_phy_read(dev
, 0x0014);
2973 backup
[17] = b43_phy_read(dev
, 0x0478);
2974 b43_phy_write(dev
, 0x002E, 0);
2975 b43_phy_write(dev
, B43_PHY_G_LO_CONTROL
, 0);
2980 b43_phy_write(dev
, 0x0478,
2981 b43_phy_read(dev
, 0x0478)
2983 b43_phy_write(dev
, 0x0801,
2984 b43_phy_read(dev
, 0x0801)
2989 b43_phy_write(dev
, 0x0801,
2990 b43_phy_read(dev
, 0x0801)
2994 b43_phy_write(dev
, 0x0060, b43_phy_read(dev
, 0x0060)
2996 b43_phy_write(dev
, 0x0014, b43_phy_read(dev
, 0x0014)
2999 b43_radio_write16(dev
, 0x007A,
3000 b43_radio_read16(dev
, 0x007A) | 0x0070);
3001 b43_set_all_gains(dev
, 0, 8, 0);
3002 b43_radio_write16(dev
, 0x007A,
3003 b43_radio_read16(dev
, 0x007A) & 0x00F7);
3004 if (phy
->rev
>= 2) {
3005 b43_phy_write(dev
, 0x0811,
3006 (b43_phy_read(dev
, 0x0811) & 0xFFCF) |
3008 b43_phy_write(dev
, 0x0812,
3009 (b43_phy_read(dev
, 0x0812) & 0xFFCF) |
3012 b43_radio_write16(dev
, 0x007A,
3013 b43_radio_read16(dev
, 0x007A) | 0x0080);
3016 nrssi0
= (s16
) ((b43_phy_read(dev
, 0x047F) >> 8) & 0x003F);
3017 if (nrssi0
>= 0x0020)
3020 b43_radio_write16(dev
, 0x007A,
3021 b43_radio_read16(dev
, 0x007A) & 0x007F);
3022 if (phy
->rev
>= 2) {
3023 b43_phy_write(dev
, 0x0003, (b43_phy_read(dev
, 0x0003)
3024 & 0xFF9F) | 0x0040);
3027 b43_write16(dev
, B43_MMIO_CHANNEL_EXT
,
3028 b43_read16(dev
, B43_MMIO_CHANNEL_EXT
)
3030 b43_radio_write16(dev
, 0x007A,
3031 b43_radio_read16(dev
, 0x007A) | 0x000F);
3032 b43_phy_write(dev
, 0x0015, 0xF330);
3033 if (phy
->rev
>= 2) {
3034 b43_phy_write(dev
, 0x0812,
3035 (b43_phy_read(dev
, 0x0812) & 0xFFCF) |
3037 b43_phy_write(dev
, 0x0811,
3038 (b43_phy_read(dev
, 0x0811) & 0xFFCF) |
3042 b43_set_all_gains(dev
, 3, 0, 1);
3043 if (phy
->radio_rev
== 8) {
3044 b43_radio_write16(dev
, 0x0043, 0x001F);
3046 tmp
= b43_radio_read16(dev
, 0x0052) & 0xFF0F;
3047 b43_radio_write16(dev
, 0x0052, tmp
| 0x0060);
3048 tmp
= b43_radio_read16(dev
, 0x0043) & 0xFFF0;
3049 b43_radio_write16(dev
, 0x0043, tmp
| 0x0009);
3051 b43_phy_write(dev
, 0x005A, 0x0480);
3052 b43_phy_write(dev
, 0x0059, 0x0810);
3053 b43_phy_write(dev
, 0x0058, 0x000D);
3055 nrssi1
= (s16
) ((b43_phy_read(dev
, 0x047F) >> 8) & 0x003F);
3056 if (nrssi1
>= 0x0020)
3058 if (nrssi0
== nrssi1
)
3059 phy
->nrssislope
= 0x00010000;
3061 phy
->nrssislope
= 0x00400000 / (nrssi0
- nrssi1
);
3063 phy
->nrssi
[0] = nrssi1
;
3064 phy
->nrssi
[1] = nrssi0
;
3066 if (phy
->rev
>= 3) {
3067 b43_phy_write(dev
, 0x002E, backup
[10]);
3068 b43_phy_write(dev
, 0x002F, backup
[11]);
3069 b43_phy_write(dev
, 0x080F, backup
[12]);
3070 b43_phy_write(dev
, B43_PHY_G_LO_CONTROL
, backup
[13]);
3072 if (phy
->rev
>= 2) {
3073 b43_phy_write(dev
, 0x0812,
3074 b43_phy_read(dev
, 0x0812) & 0xFFCF);
3075 b43_phy_write(dev
, 0x0811,
3076 b43_phy_read(dev
, 0x0811) & 0xFFCF);
3079 b43_radio_write16(dev
, 0x007A, backup
[0]);
3080 b43_radio_write16(dev
, 0x0052, backup
[1]);
3081 b43_radio_write16(dev
, 0x0043, backup
[2]);
3082 b43_write16(dev
, 0x03E2, backup
[7]);
3083 b43_write16(dev
, 0x03E6, backup
[8]);
3084 b43_write16(dev
, B43_MMIO_CHANNEL_EXT
, backup
[9]);
3085 b43_phy_write(dev
, 0x0015, backup
[3]);
3086 b43_phy_write(dev
, 0x005A, backup
[4]);
3087 b43_phy_write(dev
, 0x0059, backup
[5]);
3088 b43_phy_write(dev
, 0x0058, backup
[6]);
3089 b43_synth_pu_workaround(dev
, phy
->channel
);
3090 b43_phy_write(dev
, 0x0802,
3091 b43_phy_read(dev
, 0x0802) | (0x0001 | 0x0002));
3092 b43_set_original_gains(dev
);
3093 b43_phy_write(dev
, B43_PHY_G_CRS
,
3094 b43_phy_read(dev
, B43_PHY_G_CRS
) | 0x8000);
3095 if (phy
->rev
>= 3) {
3096 b43_phy_write(dev
, 0x0801, backup
[14]);
3097 b43_phy_write(dev
, 0x0060, backup
[15]);
3098 b43_phy_write(dev
, 0x0014, backup
[16]);
3099 b43_phy_write(dev
, 0x0478, backup
[17]);
3101 b43_nrssi_mem_update(dev
);
3102 b43_calc_nrssi_threshold(dev
);
3109 void b43_calc_nrssi_threshold(struct b43_wldev
*dev
)
3111 struct b43_phy
*phy
= &dev
->phy
;
3117 switch (phy
->type
) {
3118 case B43_PHYTYPE_B
:{
3119 if (phy
->radio_ver
!= 0x2050)
3122 (dev
->dev
->bus
->sprom
.r1
.
3123 boardflags_lo
& B43_BFL_RSSI
))
3126 if (phy
->radio_rev
>= 6) {
3128 (phy
->nrssi
[1] - phy
->nrssi
[0]) * 32;
3129 threshold
+= 20 * (phy
->nrssi
[0] + 1);
3132 threshold
= phy
->nrssi
[1] - 5;
3134 threshold
= limit_value(threshold
, 0, 0x3E);
3135 b43_phy_read(dev
, 0x0020); /* dummy read */
3136 b43_phy_write(dev
, 0x0020,
3137 (((u16
) threshold
) << 8) | 0x001C);
3139 if (phy
->radio_rev
>= 6) {
3140 b43_phy_write(dev
, 0x0087, 0x0E0D);
3141 b43_phy_write(dev
, 0x0086, 0x0C0B);
3142 b43_phy_write(dev
, 0x0085, 0x0A09);
3143 b43_phy_write(dev
, 0x0084, 0x0808);
3144 b43_phy_write(dev
, 0x0083, 0x0808);
3145 b43_phy_write(dev
, 0x0082, 0x0604);
3146 b43_phy_write(dev
, 0x0081, 0x0302);
3147 b43_phy_write(dev
, 0x0080, 0x0100);
3153 !(dev
->dev
->bus
->sprom
.r1
.boardflags_lo
& B43_BFL_RSSI
)) {
3154 tmp16
= b43_nrssi_hw_read(dev
, 0x20);
3158 b43_phy_write(dev
, 0x048A,
3159 (b43_phy_read(dev
, 0x048A)
3160 & 0xF000) | 0x09EB);
3162 b43_phy_write(dev
, 0x048A,
3163 (b43_phy_read(dev
, 0x048A)
3164 & 0xF000) | 0x0AED);
3167 if (phy
->interfmode
== B43_INTERFMODE_NONWLAN
) {
3170 } else if (!phy
->aci_wlan_automatic
&& phy
->aci_enable
) {
3178 a
= a
* (phy
->nrssi
[1] - phy
->nrssi
[0]);
3179 a
+= (phy
->nrssi
[0] << 6);
3185 a
= limit_value(a
, -31, 31);
3187 b
= b
* (phy
->nrssi
[1] - phy
->nrssi
[0]);
3188 b
+= (phy
->nrssi
[0] << 6);
3194 b
= limit_value(b
, -31, 31);
3196 tmp_u16
= b43_phy_read(dev
, 0x048A) & 0xF000;
3197 tmp_u16
|= ((u32
) b
& 0x0000003F);
3198 tmp_u16
|= (((u32
) a
& 0x0000003F) << 6);
3199 b43_phy_write(dev
, 0x048A, tmp_u16
);
3207 /* Stack implementation to save/restore values from the
3208 * interference mitigation code.
3209 * It is save to restore values in random order.
3211 static void _stack_save(u32
* _stackptr
, size_t * stackidx
,
3212 u8 id
, u16 offset
, u16 value
)
3214 u32
*stackptr
= &(_stackptr
[*stackidx
]);
3216 B43_WARN_ON(offset
& 0xF000);
3217 B43_WARN_ON(id
& 0xF0);
3219 *stackptr
|= ((u32
) id
) << 12;
3220 *stackptr
|= ((u32
) value
) << 16;
3222 B43_WARN_ON(*stackidx
>= B43_INTERFSTACK_SIZE
);
3225 static u16
_stack_restore(u32
* stackptr
, u8 id
, u16 offset
)
3229 B43_WARN_ON(offset
& 0xF000);
3230 B43_WARN_ON(id
& 0xF0);
3231 for (i
= 0; i
< B43_INTERFSTACK_SIZE
; i
++, stackptr
++) {
3232 if ((*stackptr
& 0x00000FFF) != offset
)
3234 if (((*stackptr
& 0x0000F000) >> 12) != id
)
3236 return ((*stackptr
& 0xFFFF0000) >> 16);
3243 #define phy_stacksave(offset) \
3245 _stack_save(stack, &stackidx, 0x1, (offset), \
3246 b43_phy_read(dev, (offset))); \
3248 #define phy_stackrestore(offset) \
3250 b43_phy_write(dev, (offset), \
3251 _stack_restore(stack, 0x1, \
3254 #define radio_stacksave(offset) \
3256 _stack_save(stack, &stackidx, 0x2, (offset), \
3257 b43_radio_read16(dev, (offset))); \
3259 #define radio_stackrestore(offset) \
3261 b43_radio_write16(dev, (offset), \
3262 _stack_restore(stack, 0x2, \
3265 #define ofdmtab_stacksave(table, offset) \
3267 _stack_save(stack, &stackidx, 0x3, (offset)|(table), \
3268 b43_ofdmtab_read16(dev, (table), (offset))); \
3270 #define ofdmtab_stackrestore(table, offset) \
3272 b43_ofdmtab_write16(dev, (table), (offset), \
3273 _stack_restore(stack, 0x3, \
3274 (offset)|(table))); \
3278 b43_radio_interference_mitigation_enable(struct b43_wldev
*dev
, int mode
)
3280 struct b43_phy
*phy
= &dev
->phy
;
3282 size_t stackidx
= 0;
3283 u32
*stack
= phy
->interfstack
;
3286 case B43_INTERFMODE_NONWLAN
:
3287 if (phy
->rev
!= 1) {
3288 b43_phy_write(dev
, 0x042B,
3289 b43_phy_read(dev
, 0x042B) | 0x0800);
3290 b43_phy_write(dev
, B43_PHY_G_CRS
,
3292 B43_PHY_G_CRS
) & ~0x4000);
3295 radio_stacksave(0x0078);
3296 tmp
= (b43_radio_read16(dev
, 0x0078) & 0x001E);
3297 flipped
= flip_4bit(tmp
);
3298 if (flipped
< 10 && flipped
>= 8)
3300 else if (flipped
>= 10)
3302 flipped
= flip_4bit(flipped
);
3303 flipped
= (flipped
<< 1) | 0x0020;
3304 b43_radio_write16(dev
, 0x0078, flipped
);
3306 b43_calc_nrssi_threshold(dev
);
3308 phy_stacksave(0x0406);
3309 b43_phy_write(dev
, 0x0406, 0x7E28);
3311 b43_phy_write(dev
, 0x042B, b43_phy_read(dev
, 0x042B) | 0x0800);
3312 b43_phy_write(dev
, B43_PHY_RADIO_BITFIELD
,
3314 B43_PHY_RADIO_BITFIELD
) | 0x1000);
3316 phy_stacksave(0x04A0);
3317 b43_phy_write(dev
, 0x04A0,
3318 (b43_phy_read(dev
, 0x04A0) & 0xC0C0) | 0x0008);
3319 phy_stacksave(0x04A1);
3320 b43_phy_write(dev
, 0x04A1,
3321 (b43_phy_read(dev
, 0x04A1) & 0xC0C0) | 0x0605);
3322 phy_stacksave(0x04A2);
3323 b43_phy_write(dev
, 0x04A2,
3324 (b43_phy_read(dev
, 0x04A2) & 0xC0C0) | 0x0204);
3325 phy_stacksave(0x04A8);
3326 b43_phy_write(dev
, 0x04A8,
3327 (b43_phy_read(dev
, 0x04A8) & 0xC0C0) | 0x0803);
3328 phy_stacksave(0x04AB);
3329 b43_phy_write(dev
, 0x04AB,
3330 (b43_phy_read(dev
, 0x04AB) & 0xC0C0) | 0x0605);
3332 phy_stacksave(0x04A7);
3333 b43_phy_write(dev
, 0x04A7, 0x0002);
3334 phy_stacksave(0x04A3);
3335 b43_phy_write(dev
, 0x04A3, 0x287A);
3336 phy_stacksave(0x04A9);
3337 b43_phy_write(dev
, 0x04A9, 0x2027);
3338 phy_stacksave(0x0493);
3339 b43_phy_write(dev
, 0x0493, 0x32F5);
3340 phy_stacksave(0x04AA);
3341 b43_phy_write(dev
, 0x04AA, 0x2027);
3342 phy_stacksave(0x04AC);
3343 b43_phy_write(dev
, 0x04AC, 0x32F5);
3345 case B43_INTERFMODE_MANUALWLAN
:
3346 if (b43_phy_read(dev
, 0x0033) & 0x0800)
3349 phy
->aci_enable
= 1;
3351 phy_stacksave(B43_PHY_RADIO_BITFIELD
);
3352 phy_stacksave(B43_PHY_G_CRS
);
3354 phy_stacksave(0x0406);
3356 phy_stacksave(0x04C0);
3357 phy_stacksave(0x04C1);
3359 phy_stacksave(0x0033);
3360 phy_stacksave(0x04A7);
3361 phy_stacksave(0x04A3);
3362 phy_stacksave(0x04A9);
3363 phy_stacksave(0x04AA);
3364 phy_stacksave(0x04AC);
3365 phy_stacksave(0x0493);
3366 phy_stacksave(0x04A1);
3367 phy_stacksave(0x04A0);
3368 phy_stacksave(0x04A2);
3369 phy_stacksave(0x048A);
3370 phy_stacksave(0x04A8);
3371 phy_stacksave(0x04AB);
3372 if (phy
->rev
== 2) {
3373 phy_stacksave(0x04AD);
3374 phy_stacksave(0x04AE);
3375 } else if (phy
->rev
>= 3) {
3376 phy_stacksave(0x04AD);
3377 phy_stacksave(0x0415);
3378 phy_stacksave(0x0416);
3379 phy_stacksave(0x0417);
3380 ofdmtab_stacksave(0x1A00, 0x2);
3381 ofdmtab_stacksave(0x1A00, 0x3);
3383 phy_stacksave(0x042B);
3384 phy_stacksave(0x048C);
3386 b43_phy_write(dev
, B43_PHY_RADIO_BITFIELD
,
3387 b43_phy_read(dev
, B43_PHY_RADIO_BITFIELD
)
3389 b43_phy_write(dev
, B43_PHY_G_CRS
,
3390 (b43_phy_read(dev
, B43_PHY_G_CRS
)
3391 & 0xFFFC) | 0x0002);
3393 b43_phy_write(dev
, 0x0033, 0x0800);
3394 b43_phy_write(dev
, 0x04A3, 0x2027);
3395 b43_phy_write(dev
, 0x04A9, 0x1CA8);
3396 b43_phy_write(dev
, 0x0493, 0x287A);
3397 b43_phy_write(dev
, 0x04AA, 0x1CA8);
3398 b43_phy_write(dev
, 0x04AC, 0x287A);
3400 b43_phy_write(dev
, 0x04A0, (b43_phy_read(dev
, 0x04A0)
3401 & 0xFFC0) | 0x001A);
3402 b43_phy_write(dev
, 0x04A7, 0x000D);
3405 b43_phy_write(dev
, 0x0406, 0xFF0D);
3406 } else if (phy
->rev
== 2) {
3407 b43_phy_write(dev
, 0x04C0, 0xFFFF);
3408 b43_phy_write(dev
, 0x04C1, 0x00A9);
3410 b43_phy_write(dev
, 0x04C0, 0x00C1);
3411 b43_phy_write(dev
, 0x04C1, 0x0059);
3414 b43_phy_write(dev
, 0x04A1, (b43_phy_read(dev
, 0x04A1)
3415 & 0xC0FF) | 0x1800);
3416 b43_phy_write(dev
, 0x04A1, (b43_phy_read(dev
, 0x04A1)
3417 & 0xFFC0) | 0x0015);
3418 b43_phy_write(dev
, 0x04A8, (b43_phy_read(dev
, 0x04A8)
3419 & 0xCFFF) | 0x1000);
3420 b43_phy_write(dev
, 0x04A8, (b43_phy_read(dev
, 0x04A8)
3421 & 0xF0FF) | 0x0A00);
3422 b43_phy_write(dev
, 0x04AB, (b43_phy_read(dev
, 0x04AB)
3423 & 0xCFFF) | 0x1000);
3424 b43_phy_write(dev
, 0x04AB, (b43_phy_read(dev
, 0x04AB)
3425 & 0xF0FF) | 0x0800);
3426 b43_phy_write(dev
, 0x04AB, (b43_phy_read(dev
, 0x04AB)
3427 & 0xFFCF) | 0x0010);
3428 b43_phy_write(dev
, 0x04AB, (b43_phy_read(dev
, 0x04AB)
3429 & 0xFFF0) | 0x0005);
3430 b43_phy_write(dev
, 0x04A8, (b43_phy_read(dev
, 0x04A8)
3431 & 0xFFCF) | 0x0010);
3432 b43_phy_write(dev
, 0x04A8, (b43_phy_read(dev
, 0x04A8)
3433 & 0xFFF0) | 0x0006);
3434 b43_phy_write(dev
, 0x04A2, (b43_phy_read(dev
, 0x04A2)
3435 & 0xF0FF) | 0x0800);
3436 b43_phy_write(dev
, 0x04A0, (b43_phy_read(dev
, 0x04A0)
3437 & 0xF0FF) | 0x0500);
3438 b43_phy_write(dev
, 0x04A2, (b43_phy_read(dev
, 0x04A2)
3439 & 0xFFF0) | 0x000B);
3441 if (phy
->rev
>= 3) {
3442 b43_phy_write(dev
, 0x048A, b43_phy_read(dev
, 0x048A)
3444 b43_phy_write(dev
, 0x0415, (b43_phy_read(dev
, 0x0415)
3445 & 0x8000) | 0x36D8);
3446 b43_phy_write(dev
, 0x0416, (b43_phy_read(dev
, 0x0416)
3447 & 0x8000) | 0x36D8);
3448 b43_phy_write(dev
, 0x0417, (b43_phy_read(dev
, 0x0417)
3449 & 0xFE00) | 0x016D);
3451 b43_phy_write(dev
, 0x048A, b43_phy_read(dev
, 0x048A)
3453 b43_phy_write(dev
, 0x048A, (b43_phy_read(dev
, 0x048A)
3454 & 0x9FFF) | 0x2000);
3455 b43_hf_write(dev
, b43_hf_read(dev
) | B43_HF_ACIW
);
3457 if (phy
->rev
>= 2) {
3458 b43_phy_write(dev
, 0x042B, b43_phy_read(dev
, 0x042B)
3461 b43_phy_write(dev
, 0x048C, (b43_phy_read(dev
, 0x048C)
3462 & 0xF0FF) | 0x0200);
3463 if (phy
->rev
== 2) {
3464 b43_phy_write(dev
, 0x04AE, (b43_phy_read(dev
, 0x04AE)
3465 & 0xFF00) | 0x007F);
3466 b43_phy_write(dev
, 0x04AD, (b43_phy_read(dev
, 0x04AD)
3467 & 0x00FF) | 0x1300);
3468 } else if (phy
->rev
>= 6) {
3469 b43_ofdmtab_write16(dev
, 0x1A00, 0x3, 0x007F);
3470 b43_ofdmtab_write16(dev
, 0x1A00, 0x2, 0x007F);
3471 b43_phy_write(dev
, 0x04AD, b43_phy_read(dev
, 0x04AD)
3474 b43_calc_nrssi_slope(dev
);
3482 b43_radio_interference_mitigation_disable(struct b43_wldev
*dev
, int mode
)
3484 struct b43_phy
*phy
= &dev
->phy
;
3485 u32
*stack
= phy
->interfstack
;
3488 case B43_INTERFMODE_NONWLAN
:
3489 if (phy
->rev
!= 1) {
3490 b43_phy_write(dev
, 0x042B,
3491 b43_phy_read(dev
, 0x042B) & ~0x0800);
3492 b43_phy_write(dev
, B43_PHY_G_CRS
,
3494 B43_PHY_G_CRS
) | 0x4000);
3497 radio_stackrestore(0x0078);
3498 b43_calc_nrssi_threshold(dev
);
3499 phy_stackrestore(0x0406);
3500 b43_phy_write(dev
, 0x042B, b43_phy_read(dev
, 0x042B) & ~0x0800);
3501 if (!dev
->bad_frames_preempt
) {
3502 b43_phy_write(dev
, B43_PHY_RADIO_BITFIELD
,
3503 b43_phy_read(dev
, B43_PHY_RADIO_BITFIELD
)
3506 b43_phy_write(dev
, B43_PHY_G_CRS
,
3507 b43_phy_read(dev
, B43_PHY_G_CRS
) | 0x4000);
3508 phy_stackrestore(0x04A0);
3509 phy_stackrestore(0x04A1);
3510 phy_stackrestore(0x04A2);
3511 phy_stackrestore(0x04A8);
3512 phy_stackrestore(0x04AB);
3513 phy_stackrestore(0x04A7);
3514 phy_stackrestore(0x04A3);
3515 phy_stackrestore(0x04A9);
3516 phy_stackrestore(0x0493);
3517 phy_stackrestore(0x04AA);
3518 phy_stackrestore(0x04AC);
3520 case B43_INTERFMODE_MANUALWLAN
:
3521 if (!(b43_phy_read(dev
, 0x0033) & 0x0800))
3524 phy
->aci_enable
= 0;
3526 phy_stackrestore(B43_PHY_RADIO_BITFIELD
);
3527 phy_stackrestore(B43_PHY_G_CRS
);
3528 phy_stackrestore(0x0033);
3529 phy_stackrestore(0x04A3);
3530 phy_stackrestore(0x04A9);
3531 phy_stackrestore(0x0493);
3532 phy_stackrestore(0x04AA);
3533 phy_stackrestore(0x04AC);
3534 phy_stackrestore(0x04A0);
3535 phy_stackrestore(0x04A7);
3536 if (phy
->rev
>= 2) {
3537 phy_stackrestore(0x04C0);
3538 phy_stackrestore(0x04C1);
3540 phy_stackrestore(0x0406);
3541 phy_stackrestore(0x04A1);
3542 phy_stackrestore(0x04AB);
3543 phy_stackrestore(0x04A8);
3544 if (phy
->rev
== 2) {
3545 phy_stackrestore(0x04AD);
3546 phy_stackrestore(0x04AE);
3547 } else if (phy
->rev
>= 3) {
3548 phy_stackrestore(0x04AD);
3549 phy_stackrestore(0x0415);
3550 phy_stackrestore(0x0416);
3551 phy_stackrestore(0x0417);
3552 ofdmtab_stackrestore(0x1A00, 0x2);
3553 ofdmtab_stackrestore(0x1A00, 0x3);
3555 phy_stackrestore(0x04A2);
3556 phy_stackrestore(0x048A);
3557 phy_stackrestore(0x042B);
3558 phy_stackrestore(0x048C);
3559 b43_hf_write(dev
, b43_hf_read(dev
) & ~B43_HF_ACIW
);
3560 b43_calc_nrssi_slope(dev
);
3567 #undef phy_stacksave
3568 #undef phy_stackrestore
3569 #undef radio_stacksave
3570 #undef radio_stackrestore
3571 #undef ofdmtab_stacksave
3572 #undef ofdmtab_stackrestore
3574 int b43_radio_set_interference_mitigation(struct b43_wldev
*dev
, int mode
)
3576 struct b43_phy
*phy
= &dev
->phy
;
3579 if ((phy
->type
!= B43_PHYTYPE_G
) || (phy
->rev
== 0) || (!phy
->gmode
))
3582 phy
->aci_wlan_automatic
= 0;
3584 case B43_INTERFMODE_AUTOWLAN
:
3585 phy
->aci_wlan_automatic
= 1;
3586 if (phy
->aci_enable
)
3587 mode
= B43_INTERFMODE_MANUALWLAN
;
3589 mode
= B43_INTERFMODE_NONE
;
3591 case B43_INTERFMODE_NONE
:
3592 case B43_INTERFMODE_NONWLAN
:
3593 case B43_INTERFMODE_MANUALWLAN
:
3599 currentmode
= phy
->interfmode
;
3600 if (currentmode
== mode
)
3602 if (currentmode
!= B43_INTERFMODE_NONE
)
3603 b43_radio_interference_mitigation_disable(dev
, currentmode
);
3605 if (mode
== B43_INTERFMODE_NONE
) {
3606 phy
->aci_enable
= 0;
3607 phy
->aci_hw_rssi
= 0;
3609 b43_radio_interference_mitigation_enable(dev
, mode
);
3610 phy
->interfmode
= mode
;
3615 static u16
b43_radio_core_calibration_value(struct b43_wldev
*dev
)
3617 u16 reg
, index
, ret
;
3619 static const u8 rcc_table
[] = {
3620 0x02, 0x03, 0x01, 0x0F,
3621 0x06, 0x07, 0x05, 0x0F,
3622 0x0A, 0x0B, 0x09, 0x0F,
3623 0x0E, 0x0F, 0x0D, 0x0F,
3626 reg
= b43_radio_read16(dev
, 0x60);
3627 index
= (reg
& 0x001E) >> 1;
3628 ret
= rcc_table
[index
] << 1;
3629 ret
|= (reg
& 0x0001);
3635 #define LPD(L, P, D) (((L) << 2) | ((P) << 1) | ((D) << 0))
3636 static u16
radio2050_rfover_val(struct b43_wldev
*dev
,
3637 u16 phy_register
, unsigned int lpd
)
3639 struct b43_phy
*phy
= &dev
->phy
;
3640 struct ssb_sprom
*sprom
= &(dev
->dev
->bus
->sprom
);
3645 if (has_loopback_gain(phy
)) {
3646 int max_lb_gain
= phy
->max_lb_gain
;
3650 if (phy
->radio_rev
== 8)
3651 max_lb_gain
+= 0x3E;
3653 max_lb_gain
+= 0x26;
3654 if (max_lb_gain
>= 0x46) {
3656 max_lb_gain
-= 0x46;
3657 } else if (max_lb_gain
>= 0x3A) {
3659 max_lb_gain
-= 0x3A;
3660 } else if (max_lb_gain
>= 0x2E) {
3662 max_lb_gain
-= 0x2E;
3665 max_lb_gain
-= 0x10;
3668 for (i
= 0; i
< 16; i
++) {
3669 max_lb_gain
-= (i
* 6);
3670 if (max_lb_gain
< 6)
3674 if ((phy
->rev
< 7) ||
3675 !(sprom
->r1
.boardflags_lo
& B43_BFL_EXTLNA
)) {
3676 if (phy_register
== B43_PHY_RFOVER
) {
3678 } else if (phy_register
== B43_PHY_RFOVERVAL
) {
3685 return (0x0092 | extlna
);
3687 return (0x0093 | extlna
);
3693 if (phy_register
== B43_PHY_RFOVER
) {
3695 } else if (phy_register
== B43_PHY_RFOVERVAL
) {
3703 return (0x8092 | extlna
);
3705 return (0x2092 | extlna
);
3707 return (0x2093 | extlna
);
3714 if ((phy
->rev
< 7) ||
3715 !(sprom
->r1
.boardflags_lo
& B43_BFL_EXTLNA
)) {
3716 if (phy_register
== B43_PHY_RFOVER
) {
3718 } else if (phy_register
== B43_PHY_RFOVERVAL
) {
3733 if (phy_register
== B43_PHY_RFOVER
) {
3735 } else if (phy_register
== B43_PHY_RFOVERVAL
) {
3754 struct init2050_saved_values
{
3755 /* Core registers */
3759 /* Radio registers */
3772 u16 phy_analogoverval
;
3780 u16
b43_radio_init2050(struct b43_wldev
*dev
)
3782 struct b43_phy
*phy
= &dev
->phy
;
3783 struct init2050_saved_values sav
;
3788 u32 tmp1
= 0, tmp2
= 0;
3790 memset(&sav
, 0, sizeof(sav
)); /* get rid of "may be used uninitialized..." */
3792 sav
.radio_43
= b43_radio_read16(dev
, 0x43);
3793 sav
.radio_51
= b43_radio_read16(dev
, 0x51);
3794 sav
.radio_52
= b43_radio_read16(dev
, 0x52);
3795 sav
.phy_pgactl
= b43_phy_read(dev
, B43_PHY_PGACTL
);
3796 sav
.phy_base_5A
= b43_phy_read(dev
, B43_PHY_BASE(0x5A));
3797 sav
.phy_base_59
= b43_phy_read(dev
, B43_PHY_BASE(0x59));
3798 sav
.phy_base_58
= b43_phy_read(dev
, B43_PHY_BASE(0x58));
3800 if (phy
->type
== B43_PHYTYPE_B
) {
3801 sav
.phy_base_30
= b43_phy_read(dev
, B43_PHY_BASE(0x30));
3802 sav
.reg_3EC
= b43_read16(dev
, 0x3EC);
3804 b43_phy_write(dev
, B43_PHY_BASE(0x30), 0xFF);
3805 b43_write16(dev
, 0x3EC, 0x3F3F);
3806 } else if (phy
->gmode
|| phy
->rev
>= 2) {
3807 sav
.phy_rfover
= b43_phy_read(dev
, B43_PHY_RFOVER
);
3808 sav
.phy_rfoverval
= b43_phy_read(dev
, B43_PHY_RFOVERVAL
);
3809 sav
.phy_analogover
= b43_phy_read(dev
, B43_PHY_ANALOGOVER
);
3810 sav
.phy_analogoverval
=
3811 b43_phy_read(dev
, B43_PHY_ANALOGOVERVAL
);
3812 sav
.phy_crs0
= b43_phy_read(dev
, B43_PHY_CRS0
);
3813 sav
.phy_classctl
= b43_phy_read(dev
, B43_PHY_CLASSCTL
);
3815 b43_phy_write(dev
, B43_PHY_ANALOGOVER
,
3816 b43_phy_read(dev
, B43_PHY_ANALOGOVER
)
3818 b43_phy_write(dev
, B43_PHY_ANALOGOVERVAL
,
3819 b43_phy_read(dev
, B43_PHY_ANALOGOVERVAL
)
3821 b43_phy_write(dev
, B43_PHY_CRS0
, b43_phy_read(dev
, B43_PHY_CRS0
)
3823 b43_phy_write(dev
, B43_PHY_CLASSCTL
,
3824 b43_phy_read(dev
, B43_PHY_CLASSCTL
)
3826 if (has_loopback_gain(phy
)) {
3827 sav
.phy_lo_mask
= b43_phy_read(dev
, B43_PHY_LO_MASK
);
3828 sav
.phy_lo_ctl
= b43_phy_read(dev
, B43_PHY_LO_CTL
);
3831 b43_phy_write(dev
, B43_PHY_LO_MASK
, 0xC020);
3833 b43_phy_write(dev
, B43_PHY_LO_MASK
, 0x8020);
3834 b43_phy_write(dev
, B43_PHY_LO_CTL
, 0);
3837 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3838 radio2050_rfover_val(dev
, B43_PHY_RFOVERVAL
,
3840 b43_phy_write(dev
, B43_PHY_RFOVER
,
3841 radio2050_rfover_val(dev
, B43_PHY_RFOVER
, 0));
3843 b43_write16(dev
, 0x3E2, b43_read16(dev
, 0x3E2) | 0x8000);
3845 sav
.phy_syncctl
= b43_phy_read(dev
, B43_PHY_SYNCCTL
);
3846 b43_phy_write(dev
, B43_PHY_SYNCCTL
, b43_phy_read(dev
, B43_PHY_SYNCCTL
)
3848 sav
.reg_3E6
= b43_read16(dev
, 0x3E6);
3849 sav
.reg_3F4
= b43_read16(dev
, 0x3F4);
3851 if (phy
->analog
== 0) {
3852 b43_write16(dev
, 0x03E6, 0x0122);
3854 if (phy
->analog
>= 2) {
3855 b43_phy_write(dev
, B43_PHY_BASE(0x03),
3856 (b43_phy_read(dev
, B43_PHY_BASE(0x03))
3859 b43_write16(dev
, B43_MMIO_CHANNEL_EXT
,
3860 (b43_read16(dev
, B43_MMIO_CHANNEL_EXT
) | 0x2000));
3863 rcc
= b43_radio_core_calibration_value(dev
);
3865 if (phy
->type
== B43_PHYTYPE_B
)
3866 b43_radio_write16(dev
, 0x78, 0x26);
3867 if (phy
->gmode
|| phy
->rev
>= 2) {
3868 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3869 radio2050_rfover_val(dev
, B43_PHY_RFOVERVAL
,
3872 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xBFAF);
3873 b43_phy_write(dev
, B43_PHY_BASE(0x2B), 0x1403);
3874 if (phy
->gmode
|| phy
->rev
>= 2) {
3875 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3876 radio2050_rfover_val(dev
, B43_PHY_RFOVERVAL
,
3879 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xBFA0);
3880 b43_radio_write16(dev
, 0x51, b43_radio_read16(dev
, 0x51)
3882 if (phy
->radio_rev
== 8) {
3883 b43_radio_write16(dev
, 0x43, 0x1F);
3885 b43_radio_write16(dev
, 0x52, 0);
3886 b43_radio_write16(dev
, 0x43, (b43_radio_read16(dev
, 0x43)
3887 & 0xFFF0) | 0x0009);
3889 b43_phy_write(dev
, B43_PHY_BASE(0x58), 0);
3891 for (i
= 0; i
< 16; i
++) {
3892 b43_phy_write(dev
, B43_PHY_BASE(0x5A), 0x0480);
3893 b43_phy_write(dev
, B43_PHY_BASE(0x59), 0xC810);
3894 b43_phy_write(dev
, B43_PHY_BASE(0x58), 0x000D);
3895 if (phy
->gmode
|| phy
->rev
>= 2) {
3896 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3897 radio2050_rfover_val(dev
,
3901 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xAFB0);
3903 if (phy
->gmode
|| phy
->rev
>= 2) {
3904 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3905 radio2050_rfover_val(dev
,
3909 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xEFB0);
3911 if (phy
->gmode
|| phy
->rev
>= 2) {
3912 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3913 radio2050_rfover_val(dev
,
3917 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xFFF0);
3919 tmp1
+= b43_phy_read(dev
, B43_PHY_LO_LEAKAGE
);
3920 b43_phy_write(dev
, B43_PHY_BASE(0x58), 0);
3921 if (phy
->gmode
|| phy
->rev
>= 2) {
3922 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3923 radio2050_rfover_val(dev
,
3927 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xAFB0);
3931 b43_phy_write(dev
, B43_PHY_BASE(0x58), 0);
3935 for (i
= 0; i
< 16; i
++) {
3936 radio78
= ((flip_4bit(i
) << 1) | 0x20);
3937 b43_radio_write16(dev
, 0x78, radio78
);
3939 for (j
= 0; j
< 16; j
++) {
3940 b43_phy_write(dev
, B43_PHY_BASE(0x5A), 0x0D80);
3941 b43_phy_write(dev
, B43_PHY_BASE(0x59), 0xC810);
3942 b43_phy_write(dev
, B43_PHY_BASE(0x58), 0x000D);
3943 if (phy
->gmode
|| phy
->rev
>= 2) {
3944 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3945 radio2050_rfover_val(dev
,
3950 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xAFB0);
3952 if (phy
->gmode
|| phy
->rev
>= 2) {
3953 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3954 radio2050_rfover_val(dev
,
3959 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xEFB0);
3961 if (phy
->gmode
|| phy
->rev
>= 2) {
3962 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3963 radio2050_rfover_val(dev
,
3968 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xFFF0);
3970 tmp2
+= b43_phy_read(dev
, B43_PHY_LO_LEAKAGE
);
3971 b43_phy_write(dev
, B43_PHY_BASE(0x58), 0);
3972 if (phy
->gmode
|| phy
->rev
>= 2) {
3973 b43_phy_write(dev
, B43_PHY_RFOVERVAL
,
3974 radio2050_rfover_val(dev
,
3979 b43_phy_write(dev
, B43_PHY_PGACTL
, 0xAFB0);
3987 /* Restore the registers */
3988 b43_phy_write(dev
, B43_PHY_PGACTL
, sav
.phy_pgactl
);
3989 b43_radio_write16(dev
, 0x51, sav
.radio_51
);
3990 b43_radio_write16(dev
, 0x52, sav
.radio_52
);
3991 b43_radio_write16(dev
, 0x43, sav
.radio_43
);
3992 b43_phy_write(dev
, B43_PHY_BASE(0x5A), sav
.phy_base_5A
);
3993 b43_phy_write(dev
, B43_PHY_BASE(0x59), sav
.phy_base_59
);
3994 b43_phy_write(dev
, B43_PHY_BASE(0x58), sav
.phy_base_58
);
3995 b43_write16(dev
, 0x3E6, sav
.reg_3E6
);
3996 if (phy
->analog
!= 0)
3997 b43_write16(dev
, 0x3F4, sav
.reg_3F4
);
3998 b43_phy_write(dev
, B43_PHY_SYNCCTL
, sav
.phy_syncctl
);
3999 b43_synth_pu_workaround(dev
, phy
->channel
);
4000 if (phy
->type
== B43_PHYTYPE_B
) {
4001 b43_phy_write(dev
, B43_PHY_BASE(0x30), sav
.phy_base_30
);
4002 b43_write16(dev
, 0x3EC, sav
.reg_3EC
);
4003 } else if (phy
->gmode
) {
4004 b43_write16(dev
, B43_MMIO_PHY_RADIO
,
4005 b43_read16(dev
, B43_MMIO_PHY_RADIO
)
4007 b43_phy_write(dev
, B43_PHY_RFOVER
, sav
.phy_rfover
);
4008 b43_phy_write(dev
, B43_PHY_RFOVERVAL
, sav
.phy_rfoverval
);
4009 b43_phy_write(dev
, B43_PHY_ANALOGOVER
, sav
.phy_analogover
);
4010 b43_phy_write(dev
, B43_PHY_ANALOGOVERVAL
,
4011 sav
.phy_analogoverval
);
4012 b43_phy_write(dev
, B43_PHY_CRS0
, sav
.phy_crs0
);
4013 b43_phy_write(dev
, B43_PHY_CLASSCTL
, sav
.phy_classctl
);
4014 if (has_loopback_gain(phy
)) {
4015 b43_phy_write(dev
, B43_PHY_LO_MASK
, sav
.phy_lo_mask
);
4016 b43_phy_write(dev
, B43_PHY_LO_CTL
, sav
.phy_lo_ctl
);
4027 void b43_radio_init2060(struct b43_wldev
*dev
)
4031 b43_radio_write16(dev
, 0x0004, 0x00C0);
4032 b43_radio_write16(dev
, 0x0005, 0x0008);
4033 b43_radio_write16(dev
, 0x0009, 0x0040);
4034 b43_radio_write16(dev
, 0x0005, 0x00AA);
4035 b43_radio_write16(dev
, 0x0032, 0x008F);
4036 b43_radio_write16(dev
, 0x0006, 0x008F);
4037 b43_radio_write16(dev
, 0x0034, 0x008F);
4038 b43_radio_write16(dev
, 0x002C, 0x0007);
4039 b43_radio_write16(dev
, 0x0082, 0x0080);
4040 b43_radio_write16(dev
, 0x0080, 0x0000);
4041 b43_radio_write16(dev
, 0x003F, 0x00DA);
4042 b43_radio_write16(dev
, 0x0005, b43_radio_read16(dev
, 0x0005) & ~0x0008);
4043 b43_radio_write16(dev
, 0x0081, b43_radio_read16(dev
, 0x0081) & ~0x0010);
4044 b43_radio_write16(dev
, 0x0081, b43_radio_read16(dev
, 0x0081) & ~0x0020);
4045 b43_radio_write16(dev
, 0x0081, b43_radio_read16(dev
, 0x0081) & ~0x0020);
4046 msleep(1); /* delay 400usec */
4048 b43_radio_write16(dev
, 0x0081,
4049 (b43_radio_read16(dev
, 0x0081) & ~0x0020) | 0x0010);
4050 msleep(1); /* delay 400usec */
4052 b43_radio_write16(dev
, 0x0005,
4053 (b43_radio_read16(dev
, 0x0005) & ~0x0008) | 0x0008);
4054 b43_radio_write16(dev
, 0x0085, b43_radio_read16(dev
, 0x0085) & ~0x0010);
4055 b43_radio_write16(dev
, 0x0005, b43_radio_read16(dev
, 0x0005) & ~0x0008);
4056 b43_radio_write16(dev
, 0x0081, b43_radio_read16(dev
, 0x0081) & ~0x0040);
4057 b43_radio_write16(dev
, 0x0081,
4058 (b43_radio_read16(dev
, 0x0081) & ~0x0040) | 0x0040);
4059 b43_radio_write16(dev
, 0x0005,
4060 (b43_radio_read16(dev
, 0x0081) & ~0x0008) | 0x0008);
4061 b43_phy_write(dev
, 0x0063, 0xDDC6);
4062 b43_phy_write(dev
, 0x0069, 0x07BE);
4063 b43_phy_write(dev
, 0x006A, 0x0000);
4065 err
= b43_radio_selectchannel(dev
, B43_DEFAULT_CHANNEL_A
, 0);
4071 static inline u16
freq_r3A_value(u16 frequency
)
4075 if (frequency
< 5091)
4077 else if (frequency
< 5321)
4079 else if (frequency
< 5806)
4087 void b43_radio_set_tx_iq(struct b43_wldev
*dev
)
4089 static const u8 data_high
[5] = { 0x00, 0x40, 0x80, 0x90, 0xD0 };
4090 static const u8 data_low
[5] = { 0x00, 0x01, 0x05, 0x06, 0x0A };
4091 u16 tmp
= b43_radio_read16(dev
, 0x001E);
4094 for (i
= 0; i
< 5; i
++) {
4095 for (j
= 0; j
< 5; j
++) {
4096 if (tmp
== (data_high
[i
] << 4 | data_low
[j
])) {
4097 b43_phy_write(dev
, 0x0069,
4098 (i
- j
) << 8 | 0x00C0);
4105 int b43_radio_selectchannel(struct b43_wldev
*dev
,
4106 u8 channel
, int synthetic_pu_workaround
)
4108 struct b43_phy
*phy
= &dev
->phy
;
4113 /* First we set the channel radio code to prevent the
4114 * firmware from sending ghost packets.
4116 channelcookie
= channel
;
4117 if (phy
->type
== B43_PHYTYPE_A
)
4118 channelcookie
|= 0x100;
4119 b43_shm_write16(dev
, B43_SHM_SHARED
, B43_SHM_SH_CHAN
, channelcookie
);
4121 if (phy
->type
== B43_PHYTYPE_A
) {
4124 freq
= channel2freq_a(channel
);
4126 r8
= b43_radio_read16(dev
, 0x0008);
4127 b43_write16(dev
, 0x03F0, freq
);
4128 b43_radio_write16(dev
, 0x0008, r8
);
4130 //TODO: write max channel TX power? to Radio 0x2D
4131 tmp
= b43_radio_read16(dev
, 0x002E);
4133 //TODO: OR tmp with the Power out estimation for this channel?
4134 b43_radio_write16(dev
, 0x002E, tmp
);
4136 if (freq
>= 4920 && freq
<= 5500) {
4138 * r8 = (((freq * 15 * 0xE1FC780F) >> 32) / 29) & 0x0F;
4139 * = (freq * 0.025862069
4141 r8
= 3 * freq
/ 116; /* is equal to r8 = freq * 0.025862 */
4143 b43_radio_write16(dev
, 0x0007, (r8
<< 4) | r8
);
4144 b43_radio_write16(dev
, 0x0020, (r8
<< 4) | r8
);
4145 b43_radio_write16(dev
, 0x0021, (r8
<< 4) | r8
);
4146 b43_radio_write16(dev
, 0x0022, (b43_radio_read16(dev
, 0x0022)
4147 & 0x000F) | (r8
<< 4));
4148 b43_radio_write16(dev
, 0x002A, (r8
<< 4));
4149 b43_radio_write16(dev
, 0x002B, (r8
<< 4));
4150 b43_radio_write16(dev
, 0x0008, (b43_radio_read16(dev
, 0x0008)
4151 & 0x00F0) | (r8
<< 4));
4152 b43_radio_write16(dev
, 0x0029, (b43_radio_read16(dev
, 0x0029)
4153 & 0xFF0F) | 0x00B0);
4154 b43_radio_write16(dev
, 0x0035, 0x00AA);
4155 b43_radio_write16(dev
, 0x0036, 0x0085);
4156 b43_radio_write16(dev
, 0x003A, (b43_radio_read16(dev
, 0x003A)
4158 freq_r3A_value(freq
));
4159 b43_radio_write16(dev
, 0x003D,
4160 b43_radio_read16(dev
, 0x003D) & 0x00FF);
4161 b43_radio_write16(dev
, 0x0081, (b43_radio_read16(dev
, 0x0081)
4162 & 0xFF7F) | 0x0080);
4163 b43_radio_write16(dev
, 0x0035,
4164 b43_radio_read16(dev
, 0x0035) & 0xFFEF);
4165 b43_radio_write16(dev
, 0x0035, (b43_radio_read16(dev
, 0x0035)
4166 & 0xFFEF) | 0x0010);
4167 b43_radio_set_tx_iq(dev
);
4168 //TODO: TSSI2dbm workaround
4169 b43_phy_xmitpower(dev
); //FIXME correct?
4171 if ((channel
< 1) || (channel
> 14))
4174 if (synthetic_pu_workaround
)
4175 b43_synth_pu_workaround(dev
, channel
);
4177 b43_write16(dev
, B43_MMIO_CHANNEL
, channel2freq_bg(channel
));
4179 if (channel
== 14) {
4180 if (dev
->dev
->bus
->sprom
.r1
.country_code
==
4181 SSB_SPROM1CCODE_JAPAN
)
4183 b43_hf_read(dev
) & ~B43_HF_ACPR
);
4186 b43_hf_read(dev
) | B43_HF_ACPR
);
4187 b43_write16(dev
, B43_MMIO_CHANNEL_EXT
,
4188 b43_read16(dev
, B43_MMIO_CHANNEL_EXT
)
4191 b43_write16(dev
, B43_MMIO_CHANNEL_EXT
,
4192 b43_read16(dev
, B43_MMIO_CHANNEL_EXT
)
4197 phy
->channel
= channel
;
4198 /* Wait for the radio to tune to the channel and stabilize. */
4204 /* http://bcm-specs.sipsolutions.net/TX_Gain_Base_Band */
4205 static u16
b43_get_txgain_base_band(u16 txpower
)
4209 B43_WARN_ON(txpower
> 63);
4213 else if (txpower
>= 49)
4215 else if (txpower
>= 44)
4223 /* http://bcm-specs.sipsolutions.net/TX_Gain_Radio_Frequency_Power_Amplifier */
4224 static u16
b43_get_txgain_freq_power_amp(u16 txpower
)
4228 B43_WARN_ON(txpower
> 63);
4232 else if (txpower
>= 25)
4234 else if (txpower
>= 20)
4236 else if (txpower
>= 12)
4244 /* http://bcm-specs.sipsolutions.net/TX_Gain_Digital_Analog_Converter */
4245 static u16
b43_get_txgain_dac(u16 txpower
)
4249 B43_WARN_ON(txpower
> 63);
4253 else if (txpower
>= 49)
4255 else if (txpower
>= 44)
4257 else if (txpower
>= 32)
4259 else if (txpower
>= 25)
4261 else if (txpower
>= 20)
4263 else if (txpower
>= 12)
4271 static void b43_radio_set_txpower_a(struct b43_wldev
*dev
, u16 txpower
)
4273 struct b43_phy
*phy
= &dev
->phy
;
4274 u16 pamp
, base
, dac
, t
;
4276 txpower
= limit_value(txpower
, 0, 63);
4278 pamp
= b43_get_txgain_freq_power_amp(txpower
);
4281 b43_phy_write(dev
, 0x0019, pamp
);
4283 base
= b43_get_txgain_base_band(txpower
);
4285 b43_phy_write(dev
, 0x0017, base
| 0x0020);
4287 t
= b43_ofdmtab_read16(dev
, 0x3000, 1);
4290 dac
= b43_get_txgain_dac(txpower
);
4294 b43_ofdmtab_write16(dev
, 0x3000, 1, dac
);
4296 phy
->txpwr_offset
= txpower
;
4298 //TODO: FuncPlaceholder (Adjust BB loft cancel)
4301 void b43_radio_turn_on(struct b43_wldev
*dev
)
4303 struct b43_phy
*phy
= &dev
->phy
;
4311 switch (phy
->type
) {
4313 b43_radio_write16(dev
, 0x0004, 0x00C0);
4314 b43_radio_write16(dev
, 0x0005, 0x0008);
4315 b43_phy_write(dev
, 0x0010, b43_phy_read(dev
, 0x0010) & 0xFFF7);
4316 b43_phy_write(dev
, 0x0011, b43_phy_read(dev
, 0x0011) & 0xFFF7);
4317 b43_radio_init2060(dev
);
4321 b43_phy_write(dev
, 0x0015, 0x8000);
4322 b43_phy_write(dev
, 0x0015, 0xCC00);
4323 b43_phy_write(dev
, 0x0015, (phy
->gmode
? 0x00C0 : 0x0000));
4324 err
= b43_radio_selectchannel(dev
, B43_DEFAULT_CHANNEL_BG
, 1);
4331 b43dbg(dev
->wl
, "Radio turned on\n");
4334 void b43_radio_turn_off(struct b43_wldev
*dev
)
4336 struct b43_phy
*phy
= &dev
->phy
;
4338 if (phy
->type
== B43_PHYTYPE_A
) {
4339 b43_radio_write16(dev
, 0x0004, 0x00FF);
4340 b43_radio_write16(dev
, 0x0005, 0x00FB);
4341 b43_phy_write(dev
, 0x0010, b43_phy_read(dev
, 0x0010) | 0x0008);
4342 b43_phy_write(dev
, 0x0011, b43_phy_read(dev
, 0x0011) | 0x0008);
4344 if (phy
->type
== B43_PHYTYPE_G
&& dev
->dev
->id
.revision
>= 5) {
4345 b43_phy_write(dev
, 0x0811, b43_phy_read(dev
, 0x0811) | 0x008C);
4346 b43_phy_write(dev
, 0x0812, b43_phy_read(dev
, 0x0812) & 0xFF73);
4348 b43_phy_write(dev
, 0x0015, 0xAA00);
4350 b43dbg(dev
->wl
, "Radio turned off\n");