2 * Sonics Silicon Backplane PCI-Hostbus related functions.
4 * Copyright (C) 2005-2006 Michael Buesch <mb@bu3sch.de>
5 * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
6 * Copyright (C) 2005 Stefano Brivio <st3@riseup.net>
7 * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
8 * Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
10 * Derived from the Broadcom 4400 device driver.
11 * Copyright (C) 2002 David S. Miller (davem@redhat.com)
12 * Fixed by Pekka Pietikainen (pp@ee.oulu.fi)
13 * Copyright (C) 2006 Broadcom Corporation.
15 * Licensed under the GNU/GPL. See COPYING for details.
18 #include <linux/ssb/ssb.h>
19 #include <linux/ssb/ssb_regs.h>
20 #include <linux/pci.h>
21 #include <linux/delay.h>
23 #include "ssb_private.h"
26 /* Define the following to 1 to enable a printk on each coreswitch. */
27 #define SSB_VERBOSE_PCICORESWITCH_DEBUG 0
30 /* Lowlevel coreswitching */
31 int ssb_pci_switch_coreidx(struct ssb_bus
*bus
, u8 coreidx
)
38 err
= pci_write_config_dword(bus
->host_pci
, SSB_BAR0_WIN
,
39 (coreidx
* SSB_CORE_SIZE
)
43 err
= pci_read_config_dword(bus
->host_pci
, SSB_BAR0_WIN
,
47 cur_core
= (cur_core
- SSB_ENUM_BASE
)
49 if (cur_core
== coreidx
)
52 if (attempts
++ > SSB_BAR0_MAX_RETRIES
)
58 ssb_printk(KERN_ERR PFX
"Failed to switch to core %u\n", coreidx
);
62 int ssb_pci_switch_core(struct ssb_bus
*bus
,
63 struct ssb_device
*dev
)
68 #if SSB_VERBOSE_PCICORESWITCH_DEBUG
69 ssb_printk(KERN_INFO PFX
70 "Switching to %s core, index %d\n",
71 ssb_core_name(dev
->id
.coreid
),
75 spin_lock_irqsave(&bus
->bar_lock
, flags
);
76 err
= ssb_pci_switch_coreidx(bus
, dev
->core_index
);
78 bus
->mapped_device
= dev
;
79 spin_unlock_irqrestore(&bus
->bar_lock
, flags
);
84 /* Enable/disable the on board crystal oscillator and/or PLL. */
85 int ssb_pci_xtal(struct ssb_bus
*bus
, u32 what
, int turn_on
)
88 u32 in
, out
, outenable
;
91 if (bus
->bustype
!= SSB_BUSTYPE_PCI
)
94 err
= pci_read_config_dword(bus
->host_pci
, SSB_GPIO_IN
, &in
);
97 err
= pci_read_config_dword(bus
->host_pci
, SSB_GPIO_OUT
, &out
);
100 err
= pci_read_config_dword(bus
->host_pci
, SSB_GPIO_OUT_ENABLE
, &outenable
);
107 /* Avoid glitching the clock if GPRS is already using it.
108 * We can't actually read the state of the PLLPD so we infer it
109 * by the value of XTAL_PU which *is* readable via gpioin.
111 if (!(in
& SSB_GPIO_XTAL
)) {
112 if (what
& SSB_GPIO_XTAL
) {
113 /* Turn the crystal on */
114 out
|= SSB_GPIO_XTAL
;
115 if (what
& SSB_GPIO_PLL
)
117 err
= pci_write_config_dword(bus
->host_pci
, SSB_GPIO_OUT
, out
);
120 err
= pci_write_config_dword(bus
->host_pci
, SSB_GPIO_OUT_ENABLE
,
126 if (what
& SSB_GPIO_PLL
) {
127 /* Turn the PLL on */
128 out
&= ~SSB_GPIO_PLL
;
129 err
= pci_write_config_dword(bus
->host_pci
, SSB_GPIO_OUT
, out
);
136 err
= pci_read_config_word(bus
->host_pci
, PCI_STATUS
, &pci_status
);
139 pci_status
&= ~PCI_STATUS_SIG_TARGET_ABORT
;
140 err
= pci_write_config_word(bus
->host_pci
, PCI_STATUS
, pci_status
);
144 if (what
& SSB_GPIO_XTAL
) {
145 /* Turn the crystal off */
146 out
&= ~SSB_GPIO_XTAL
;
148 if (what
& SSB_GPIO_PLL
) {
149 /* Turn the PLL off */
152 err
= pci_write_config_dword(bus
->host_pci
, SSB_GPIO_OUT
, out
);
155 err
= pci_write_config_dword(bus
->host_pci
, SSB_GPIO_OUT_ENABLE
, outenable
);
164 printk(KERN_ERR PFX
"Error: ssb_pci_xtal() could not access PCI config space!\n");
169 /* Get the word-offset for a SSB_SPROM_XXX define. */
170 #define SPOFF(offset) (((offset) - SSB_SPROM_BASE1) / sizeof(u16))
171 /* Helper to extract some _offset, which is one of the SSB_SPROM_XXX defines. */
172 #define SPEX16(_outvar, _offset, _mask, _shift) \
173 out->_outvar = ((in[SPOFF(_offset)] & (_mask)) >> (_shift))
174 #define SPEX32(_outvar, _offset, _mask, _shift) \
175 out->_outvar = ((((u32)in[SPOFF((_offset)+2)] << 16 | \
176 in[SPOFF(_offset)]) & (_mask)) >> (_shift))
177 #define SPEX(_outvar, _offset, _mask, _shift) \
178 SPEX16(_outvar, _offset, _mask, _shift)
181 static inline u8
ssb_crc8(u8 crc
, u8 data
)
183 /* Polynomial: x^8 + x^7 + x^6 + x^4 + x^2 + 1 */
184 static const u8 t
[] = {
185 0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
186 0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
187 0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
188 0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
189 0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
190 0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
191 0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
192 0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
193 0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
194 0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
195 0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
196 0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
197 0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
198 0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
199 0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
200 0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
201 0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
202 0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
203 0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
204 0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
205 0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
206 0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
207 0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
208 0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
209 0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
210 0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
211 0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
212 0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
213 0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
214 0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
215 0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
216 0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F,
218 return t
[crc
^ data
];
221 static u8
ssb_sprom_crc(const u16
*sprom
, u16 size
)
226 for (word
= 0; word
< size
- 1; word
++) {
227 crc
= ssb_crc8(crc
, sprom
[word
] & 0x00FF);
228 crc
= ssb_crc8(crc
, (sprom
[word
] & 0xFF00) >> 8);
230 crc
= ssb_crc8(crc
, sprom
[size
- 1] & 0x00FF);
236 static int sprom_check_crc(const u16
*sprom
, size_t size
)
242 crc
= ssb_sprom_crc(sprom
, size
);
243 tmp
= sprom
[size
- 1] & SSB_SPROM_REVISION_CRC
;
244 expected_crc
= tmp
>> SSB_SPROM_REVISION_CRC_SHIFT
;
245 if (crc
!= expected_crc
)
251 static int sprom_do_read(struct ssb_bus
*bus
, u16
*sprom
)
255 for (i
= 0; i
< bus
->sprom_size
; i
++)
256 sprom
[i
] = ioread16(bus
->mmio
+ bus
->sprom_offset
+ (i
* 2));
261 static int sprom_do_write(struct ssb_bus
*bus
, const u16
*sprom
)
263 struct pci_dev
*pdev
= bus
->host_pci
;
266 u16 size
= bus
->sprom_size
;
268 ssb_printk(KERN_NOTICE PFX
"Writing SPROM. Do NOT turn off the power! Please stand by...\n");
269 err
= pci_read_config_dword(pdev
, SSB_SPROMCTL
, &spromctl
);
272 spromctl
|= SSB_SPROMCTL_WE
;
273 err
= pci_write_config_dword(pdev
, SSB_SPROMCTL
, spromctl
);
276 ssb_printk(KERN_NOTICE PFX
"[ 0%%");
278 for (i
= 0; i
< size
; i
++) {
281 else if (i
== size
/ 2)
283 else if (i
== (size
* 3) / 4)
287 writew(sprom
[i
], bus
->mmio
+ bus
->sprom_offset
+ (i
* 2));
291 err
= pci_read_config_dword(pdev
, SSB_SPROMCTL
, &spromctl
);
294 spromctl
&= ~SSB_SPROMCTL_WE
;
295 err
= pci_write_config_dword(pdev
, SSB_SPROMCTL
, spromctl
);
299 ssb_printk("100%% ]\n");
300 ssb_printk(KERN_NOTICE PFX
"SPROM written.\n");
304 ssb_printk(KERN_ERR PFX
"Could not access SPROM control register.\n");
308 static s8
r123_extract_antgain(u8 sprom_revision
, const u16
*in
,
314 v
= in
[SPOFF(SSB_SPROM1_AGAIN
)];
315 gain
= (v
& mask
) >> shift
;
317 gain
= 2; /* If unset use 2dBm */
318 if (sprom_revision
== 1) {
319 /* Convert to Q5.2 */
322 /* Q5.2 Fractional part is stored in 0xC0 */
323 gain
= ((gain
& 0xC0) >> 6) | ((gain
& 0x3F) << 2);
329 static void sprom_extract_r123(struct ssb_sprom
*out
, const u16
*in
)
336 if (out
->revision
== 3) /* rev 3 moved MAC */
337 loc
[0] = SSB_SPROM3_IL0MAC
;
339 loc
[0] = SSB_SPROM1_IL0MAC
;
340 loc
[1] = SSB_SPROM1_ET0MAC
;
341 loc
[2] = SSB_SPROM1_ET1MAC
;
343 for (i
= 0; i
< 3; i
++) {
344 v
= in
[SPOFF(loc
[0]) + i
];
345 *(((__be16
*)out
->il0mac
) + i
) = cpu_to_be16(v
);
347 if (out
->revision
< 3) { /* only rev 1-2 have et0, et1 */
348 for (i
= 0; i
< 3; i
++) {
349 v
= in
[SPOFF(loc
[1]) + i
];
350 *(((__be16
*)out
->et0mac
) + i
) = cpu_to_be16(v
);
352 for (i
= 0; i
< 3; i
++) {
353 v
= in
[SPOFF(loc
[2]) + i
];
354 *(((__be16
*)out
->et1mac
) + i
) = cpu_to_be16(v
);
357 SPEX(et0phyaddr
, SSB_SPROM1_ETHPHY
, SSB_SPROM1_ETHPHY_ET0A
, 0);
358 SPEX(et1phyaddr
, SSB_SPROM1_ETHPHY
, SSB_SPROM1_ETHPHY_ET1A
,
359 SSB_SPROM1_ETHPHY_ET1A_SHIFT
);
360 SPEX(et0mdcport
, SSB_SPROM1_ETHPHY
, SSB_SPROM1_ETHPHY_ET0M
, 14);
361 SPEX(et1mdcport
, SSB_SPROM1_ETHPHY
, SSB_SPROM1_ETHPHY_ET1M
, 15);
362 SPEX(board_rev
, SSB_SPROM1_BINF
, SSB_SPROM1_BINF_BREV
, 0);
363 SPEX(country_code
, SSB_SPROM1_BINF
, SSB_SPROM1_BINF_CCODE
,
364 SSB_SPROM1_BINF_CCODE_SHIFT
);
365 SPEX(ant_available_a
, SSB_SPROM1_BINF
, SSB_SPROM1_BINF_ANTA
,
366 SSB_SPROM1_BINF_ANTA_SHIFT
);
367 SPEX(ant_available_bg
, SSB_SPROM1_BINF
, SSB_SPROM1_BINF_ANTBG
,
368 SSB_SPROM1_BINF_ANTBG_SHIFT
);
369 SPEX(pa0b0
, SSB_SPROM1_PA0B0
, 0xFFFF, 0);
370 SPEX(pa0b1
, SSB_SPROM1_PA0B1
, 0xFFFF, 0);
371 SPEX(pa0b2
, SSB_SPROM1_PA0B2
, 0xFFFF, 0);
372 SPEX(pa1b0
, SSB_SPROM1_PA1B0
, 0xFFFF, 0);
373 SPEX(pa1b1
, SSB_SPROM1_PA1B1
, 0xFFFF, 0);
374 SPEX(pa1b2
, SSB_SPROM1_PA1B2
, 0xFFFF, 0);
375 SPEX(gpio0
, SSB_SPROM1_GPIOA
, SSB_SPROM1_GPIOA_P0
, 0);
376 SPEX(gpio1
, SSB_SPROM1_GPIOA
, SSB_SPROM1_GPIOA_P1
,
377 SSB_SPROM1_GPIOA_P1_SHIFT
);
378 SPEX(gpio2
, SSB_SPROM1_GPIOB
, SSB_SPROM1_GPIOB_P2
, 0);
379 SPEX(gpio3
, SSB_SPROM1_GPIOB
, SSB_SPROM1_GPIOB_P3
,
380 SSB_SPROM1_GPIOB_P3_SHIFT
);
381 SPEX(maxpwr_a
, SSB_SPROM1_MAXPWR
, SSB_SPROM1_MAXPWR_A
,
382 SSB_SPROM1_MAXPWR_A_SHIFT
);
383 SPEX(maxpwr_bg
, SSB_SPROM1_MAXPWR
, SSB_SPROM1_MAXPWR_BG
, 0);
384 SPEX(itssi_a
, SSB_SPROM1_ITSSI
, SSB_SPROM1_ITSSI_A
,
385 SSB_SPROM1_ITSSI_A_SHIFT
);
386 SPEX(itssi_bg
, SSB_SPROM1_ITSSI
, SSB_SPROM1_ITSSI_BG
, 0);
387 SPEX(boardflags_lo
, SSB_SPROM1_BFLLO
, 0xFFFF, 0);
388 if (out
->revision
>= 2)
389 SPEX(boardflags_hi
, SSB_SPROM2_BFLHI
, 0xFFFF, 0);
391 /* Extract the antenna gain values. */
392 gain
= r123_extract_antgain(out
->revision
, in
,
394 SSB_SPROM1_AGAIN_BG_SHIFT
);
395 out
->antenna_gain
.ghz24
.a0
= gain
;
396 out
->antenna_gain
.ghz24
.a1
= gain
;
397 out
->antenna_gain
.ghz24
.a2
= gain
;
398 out
->antenna_gain
.ghz24
.a3
= gain
;
399 gain
= r123_extract_antgain(out
->revision
, in
,
401 SSB_SPROM1_AGAIN_A_SHIFT
);
402 out
->antenna_gain
.ghz5
.a0
= gain
;
403 out
->antenna_gain
.ghz5
.a1
= gain
;
404 out
->antenna_gain
.ghz5
.a2
= gain
;
405 out
->antenna_gain
.ghz5
.a3
= gain
;
408 static void sprom_extract_r45(struct ssb_sprom
*out
, const u16
*in
)
414 if (out
->revision
== 4)
415 il0mac_offset
= SSB_SPROM4_IL0MAC
;
417 il0mac_offset
= SSB_SPROM5_IL0MAC
;
418 /* extract the MAC address */
419 for (i
= 0; i
< 3; i
++) {
420 v
= in
[SPOFF(il0mac_offset
) + i
];
421 *(((__be16
*)out
->il0mac
) + i
) = cpu_to_be16(v
);
423 SPEX(et0phyaddr
, SSB_SPROM4_ETHPHY
, SSB_SPROM4_ETHPHY_ET0A
, 0);
424 SPEX(et1phyaddr
, SSB_SPROM4_ETHPHY
, SSB_SPROM4_ETHPHY_ET1A
,
425 SSB_SPROM4_ETHPHY_ET1A_SHIFT
);
426 if (out
->revision
== 4) {
427 SPEX(country_code
, SSB_SPROM4_CCODE
, 0xFFFF, 0);
428 SPEX(boardflags_lo
, SSB_SPROM4_BFLLO
, 0xFFFF, 0);
429 SPEX(boardflags_hi
, SSB_SPROM4_BFLHI
, 0xFFFF, 0);
431 SPEX(country_code
, SSB_SPROM5_CCODE
, 0xFFFF, 0);
432 SPEX(boardflags_lo
, SSB_SPROM5_BFLLO
, 0xFFFF, 0);
433 SPEX(boardflags_hi
, SSB_SPROM5_BFLHI
, 0xFFFF, 0);
435 SPEX(ant_available_a
, SSB_SPROM4_ANTAVAIL
, SSB_SPROM4_ANTAVAIL_A
,
436 SSB_SPROM4_ANTAVAIL_A_SHIFT
);
437 SPEX(ant_available_bg
, SSB_SPROM4_ANTAVAIL
, SSB_SPROM4_ANTAVAIL_BG
,
438 SSB_SPROM4_ANTAVAIL_BG_SHIFT
);
439 SPEX(maxpwr_bg
, SSB_SPROM4_MAXP_BG
, SSB_SPROM4_MAXP_BG_MASK
, 0);
440 SPEX(itssi_bg
, SSB_SPROM4_MAXP_BG
, SSB_SPROM4_ITSSI_BG
,
441 SSB_SPROM4_ITSSI_BG_SHIFT
);
442 SPEX(maxpwr_a
, SSB_SPROM4_MAXP_A
, SSB_SPROM4_MAXP_A_MASK
, 0);
443 SPEX(itssi_a
, SSB_SPROM4_MAXP_A
, SSB_SPROM4_ITSSI_A
,
444 SSB_SPROM4_ITSSI_A_SHIFT
);
445 if (out
->revision
== 4) {
446 SPEX(gpio0
, SSB_SPROM4_GPIOA
, SSB_SPROM4_GPIOA_P0
, 0);
447 SPEX(gpio1
, SSB_SPROM4_GPIOA
, SSB_SPROM4_GPIOA_P1
,
448 SSB_SPROM4_GPIOA_P1_SHIFT
);
449 SPEX(gpio2
, SSB_SPROM4_GPIOB
, SSB_SPROM4_GPIOB_P2
, 0);
450 SPEX(gpio3
, SSB_SPROM4_GPIOB
, SSB_SPROM4_GPIOB_P3
,
451 SSB_SPROM4_GPIOB_P3_SHIFT
);
453 SPEX(gpio0
, SSB_SPROM5_GPIOA
, SSB_SPROM5_GPIOA_P0
, 0);
454 SPEX(gpio1
, SSB_SPROM5_GPIOA
, SSB_SPROM5_GPIOA_P1
,
455 SSB_SPROM5_GPIOA_P1_SHIFT
);
456 SPEX(gpio2
, SSB_SPROM5_GPIOB
, SSB_SPROM5_GPIOB_P2
, 0);
457 SPEX(gpio3
, SSB_SPROM5_GPIOB
, SSB_SPROM5_GPIOB_P3
,
458 SSB_SPROM5_GPIOB_P3_SHIFT
);
461 /* Extract the antenna gain values. */
462 SPEX(antenna_gain
.ghz24
.a0
, SSB_SPROM4_AGAIN01
,
463 SSB_SPROM4_AGAIN0
, SSB_SPROM4_AGAIN0_SHIFT
);
464 SPEX(antenna_gain
.ghz24
.a1
, SSB_SPROM4_AGAIN01
,
465 SSB_SPROM4_AGAIN1
, SSB_SPROM4_AGAIN1_SHIFT
);
466 SPEX(antenna_gain
.ghz24
.a2
, SSB_SPROM4_AGAIN23
,
467 SSB_SPROM4_AGAIN2
, SSB_SPROM4_AGAIN2_SHIFT
);
468 SPEX(antenna_gain
.ghz24
.a3
, SSB_SPROM4_AGAIN23
,
469 SSB_SPROM4_AGAIN3
, SSB_SPROM4_AGAIN3_SHIFT
);
470 memcpy(&out
->antenna_gain
.ghz5
, &out
->antenna_gain
.ghz24
,
471 sizeof(out
->antenna_gain
.ghz5
));
473 /* TODO - get remaining rev 4 stuff needed */
476 static void sprom_extract_r8(struct ssb_sprom
*out
, const u16
*in
)
481 /* extract the MAC address */
482 for (i
= 0; i
< 3; i
++) {
483 v
= in
[SPOFF(SSB_SPROM8_IL0MAC
) + i
];
484 *(((__be16
*)out
->il0mac
) + i
) = cpu_to_be16(v
);
486 SPEX(country_code
, SSB_SPROM8_CCODE
, 0xFFFF, 0);
487 SPEX(boardflags_lo
, SSB_SPROM8_BFLLO
, 0xFFFF, 0);
488 SPEX(boardflags_hi
, SSB_SPROM8_BFLHI
, 0xFFFF, 0);
489 SPEX(boardflags2_lo
, SSB_SPROM8_BFL2LO
, 0xFFFF, 0);
490 SPEX(boardflags2_hi
, SSB_SPROM8_BFL2HI
, 0xFFFF, 0);
491 SPEX(ant_available_a
, SSB_SPROM8_ANTAVAIL
, SSB_SPROM8_ANTAVAIL_A
,
492 SSB_SPROM8_ANTAVAIL_A_SHIFT
);
493 SPEX(ant_available_bg
, SSB_SPROM8_ANTAVAIL
, SSB_SPROM8_ANTAVAIL_BG
,
494 SSB_SPROM8_ANTAVAIL_BG_SHIFT
);
495 SPEX(maxpwr_bg
, SSB_SPROM8_MAXP_BG
, SSB_SPROM8_MAXP_BG_MASK
, 0);
496 SPEX(itssi_bg
, SSB_SPROM8_MAXP_BG
, SSB_SPROM8_ITSSI_BG
,
497 SSB_SPROM8_ITSSI_BG_SHIFT
);
498 SPEX(maxpwr_a
, SSB_SPROM8_MAXP_A
, SSB_SPROM8_MAXP_A_MASK
, 0);
499 SPEX(itssi_a
, SSB_SPROM8_MAXP_A
, SSB_SPROM8_ITSSI_A
,
500 SSB_SPROM8_ITSSI_A_SHIFT
);
501 SPEX(maxpwr_ah
, SSB_SPROM8_MAXP_AHL
, SSB_SPROM8_MAXP_AH_MASK
, 0);
502 SPEX(maxpwr_al
, SSB_SPROM8_MAXP_AHL
, SSB_SPROM8_MAXP_AL_MASK
,
503 SSB_SPROM8_MAXP_AL_SHIFT
);
504 SPEX(gpio0
, SSB_SPROM8_GPIOA
, SSB_SPROM8_GPIOA_P0
, 0);
505 SPEX(gpio1
, SSB_SPROM8_GPIOA
, SSB_SPROM8_GPIOA_P1
,
506 SSB_SPROM8_GPIOA_P1_SHIFT
);
507 SPEX(gpio2
, SSB_SPROM8_GPIOB
, SSB_SPROM8_GPIOB_P2
, 0);
508 SPEX(gpio3
, SSB_SPROM8_GPIOB
, SSB_SPROM8_GPIOB_P3
,
509 SSB_SPROM8_GPIOB_P3_SHIFT
);
510 SPEX(tri2g
, SSB_SPROM8_TRI25G
, SSB_SPROM8_TRI2G
, 0);
511 SPEX(tri5g
, SSB_SPROM8_TRI25G
, SSB_SPROM8_TRI5G
,
512 SSB_SPROM8_TRI5G_SHIFT
);
513 SPEX(tri5gl
, SSB_SPROM8_TRI5GHL
, SSB_SPROM8_TRI5GL
, 0);
514 SPEX(tri5gh
, SSB_SPROM8_TRI5GHL
, SSB_SPROM8_TRI5GH
,
515 SSB_SPROM8_TRI5GH_SHIFT
);
516 SPEX(rxpo2g
, SSB_SPROM8_RXPO
, SSB_SPROM8_RXPO2G
, 0);
517 SPEX(rxpo5g
, SSB_SPROM8_RXPO
, SSB_SPROM8_RXPO5G
,
518 SSB_SPROM8_RXPO5G_SHIFT
);
519 SPEX(rssismf2g
, SSB_SPROM8_RSSIPARM2G
, SSB_SPROM8_RSSISMF2G
, 0);
520 SPEX(rssismc2g
, SSB_SPROM8_RSSIPARM2G
, SSB_SPROM8_RSSISMC2G
,
521 SSB_SPROM8_RSSISMC2G_SHIFT
);
522 SPEX(rssisav2g
, SSB_SPROM8_RSSIPARM2G
, SSB_SPROM8_RSSISAV2G
,
523 SSB_SPROM8_RSSISAV2G_SHIFT
);
524 SPEX(bxa2g
, SSB_SPROM8_RSSIPARM2G
, SSB_SPROM8_BXA2G
,
525 SSB_SPROM8_BXA2G_SHIFT
);
526 SPEX(rssismf5g
, SSB_SPROM8_RSSIPARM5G
, SSB_SPROM8_RSSISMF5G
, 0);
527 SPEX(rssismc5g
, SSB_SPROM8_RSSIPARM5G
, SSB_SPROM8_RSSISMC5G
,
528 SSB_SPROM8_RSSISMC5G_SHIFT
);
529 SPEX(rssisav5g
, SSB_SPROM8_RSSIPARM5G
, SSB_SPROM8_RSSISAV5G
,
530 SSB_SPROM8_RSSISAV5G_SHIFT
);
531 SPEX(bxa5g
, SSB_SPROM8_RSSIPARM5G
, SSB_SPROM8_BXA5G
,
532 SSB_SPROM8_BXA5G_SHIFT
);
533 SPEX(pa0b0
, SSB_SPROM8_PA0B0
, 0xFFFF, 0);
534 SPEX(pa0b1
, SSB_SPROM8_PA0B1
, 0xFFFF, 0);
535 SPEX(pa0b2
, SSB_SPROM8_PA0B2
, 0xFFFF, 0);
536 SPEX(pa1b0
, SSB_SPROM8_PA1B0
, 0xFFFF, 0);
537 SPEX(pa1b1
, SSB_SPROM8_PA1B1
, 0xFFFF, 0);
538 SPEX(pa1b2
, SSB_SPROM8_PA1B2
, 0xFFFF, 0);
539 SPEX(pa1lob0
, SSB_SPROM8_PA1LOB0
, 0xFFFF, 0);
540 SPEX(pa1lob1
, SSB_SPROM8_PA1LOB1
, 0xFFFF, 0);
541 SPEX(pa1lob2
, SSB_SPROM8_PA1LOB2
, 0xFFFF, 0);
542 SPEX(pa1hib0
, SSB_SPROM8_PA1HIB0
, 0xFFFF, 0);
543 SPEX(pa1hib1
, SSB_SPROM8_PA1HIB1
, 0xFFFF, 0);
544 SPEX(pa1hib2
, SSB_SPROM8_PA1HIB2
, 0xFFFF, 0);
545 SPEX(cck2gpo
, SSB_SPROM8_CCK2GPO
, 0xFFFF, 0);
546 SPEX32(ofdm2gpo
, SSB_SPROM8_OFDM2GPO
, 0xFFFFFFFF, 0);
547 SPEX32(ofdm5glpo
, SSB_SPROM8_OFDM5GLPO
, 0xFFFFFFFF, 0);
548 SPEX32(ofdm5gpo
, SSB_SPROM8_OFDM5GPO
, 0xFFFFFFFF, 0);
549 SPEX32(ofdm5ghpo
, SSB_SPROM8_OFDM5GHPO
, 0xFFFFFFFF, 0);
551 /* Extract the antenna gain values. */
552 SPEX(antenna_gain
.ghz24
.a0
, SSB_SPROM8_AGAIN01
,
553 SSB_SPROM8_AGAIN0
, SSB_SPROM8_AGAIN0_SHIFT
);
554 SPEX(antenna_gain
.ghz24
.a1
, SSB_SPROM8_AGAIN01
,
555 SSB_SPROM8_AGAIN1
, SSB_SPROM8_AGAIN1_SHIFT
);
556 SPEX(antenna_gain
.ghz24
.a2
, SSB_SPROM8_AGAIN23
,
557 SSB_SPROM8_AGAIN2
, SSB_SPROM8_AGAIN2_SHIFT
);
558 SPEX(antenna_gain
.ghz24
.a3
, SSB_SPROM8_AGAIN23
,
559 SSB_SPROM8_AGAIN3
, SSB_SPROM8_AGAIN3_SHIFT
);
560 memcpy(&out
->antenna_gain
.ghz5
, &out
->antenna_gain
.ghz24
,
561 sizeof(out
->antenna_gain
.ghz5
));
563 /* TODO - get remaining rev 8 stuff needed */
566 static int sprom_extract(struct ssb_bus
*bus
, struct ssb_sprom
*out
,
567 const u16
*in
, u16 size
)
569 memset(out
, 0, sizeof(*out
));
571 out
->revision
= in
[size
- 1] & 0x00FF;
572 ssb_dprintk(KERN_DEBUG PFX
"SPROM revision %d detected.\n", out
->revision
);
573 memset(out
->et0mac
, 0xFF, 6); /* preset et0 and et1 mac */
574 memset(out
->et1mac
, 0xFF, 6);
575 if ((bus
->chip_id
& 0xFF00) == 0x4400) {
576 /* Workaround: The BCM44XX chip has a stupid revision
577 * number stored in the SPROM.
578 * Always extract r1. */
580 sprom_extract_r123(out
, in
);
581 } else if (bus
->chip_id
== 0x4321) {
582 /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */
584 sprom_extract_r45(out
, in
);
586 switch (out
->revision
) {
590 sprom_extract_r123(out
, in
);
594 sprom_extract_r45(out
, in
);
597 sprom_extract_r8(out
, in
);
600 ssb_printk(KERN_WARNING PFX
"Unsupported SPROM"
601 " revision %d detected. Will extract"
602 " v1\n", out
->revision
);
604 sprom_extract_r123(out
, in
);
608 if (out
->boardflags_lo
== 0xFFFF)
609 out
->boardflags_lo
= 0; /* per specs */
610 if (out
->boardflags_hi
== 0xFFFF)
611 out
->boardflags_hi
= 0; /* per specs */
616 static int ssb_pci_sprom_get(struct ssb_bus
*bus
,
617 struct ssb_sprom
*sprom
)
619 const struct ssb_sprom
*fallback
;
623 if (!ssb_is_sprom_available(bus
)) {
624 ssb_printk(KERN_ERR PFX
"No SPROM available!\n");
627 if (bus
->chipco
.dev
) { /* can be unavailible! */
629 * get SPROM offset: SSB_SPROM_BASE1 except for
630 * chipcommon rev >= 31 or chip ID is 0x4312 and
631 * chipcommon status & 3 == 2
633 if (bus
->chipco
.dev
->id
.revision
>= 31)
634 bus
->sprom_offset
= SSB_SPROM_BASE31
;
635 else if (bus
->chip_id
== 0x4312 &&
636 (bus
->chipco
.status
& 0x03) == 2)
637 bus
->sprom_offset
= SSB_SPROM_BASE31
;
639 bus
->sprom_offset
= SSB_SPROM_BASE1
;
641 bus
->sprom_offset
= SSB_SPROM_BASE1
;
643 ssb_dprintk(KERN_INFO PFX
"SPROM offset is 0x%x\n", bus
->sprom_offset
);
645 buf
= kcalloc(SSB_SPROMSIZE_WORDS_R123
, sizeof(u16
), GFP_KERNEL
);
648 bus
->sprom_size
= SSB_SPROMSIZE_WORDS_R123
;
649 sprom_do_read(bus
, buf
);
650 err
= sprom_check_crc(buf
, bus
->sprom_size
);
652 /* try for a 440 byte SPROM - revision 4 and higher */
654 buf
= kcalloc(SSB_SPROMSIZE_WORDS_R4
, sizeof(u16
),
658 bus
->sprom_size
= SSB_SPROMSIZE_WORDS_R4
;
659 sprom_do_read(bus
, buf
);
660 err
= sprom_check_crc(buf
, bus
->sprom_size
);
662 /* All CRC attempts failed.
663 * Maybe there is no SPROM on the device?
664 * If we have a fallback, use that. */
665 fallback
= ssb_get_fallback_sprom();
667 memcpy(sprom
, fallback
, sizeof(*sprom
));
671 ssb_printk(KERN_WARNING PFX
"WARNING: Invalid"
672 " SPROM CRC (corrupt SPROM)\n");
675 err
= sprom_extract(bus
, sprom
, buf
, bus
->sprom_size
);
683 static void ssb_pci_get_boardinfo(struct ssb_bus
*bus
,
684 struct ssb_boardinfo
*bi
)
686 pci_read_config_word(bus
->host_pci
, PCI_SUBSYSTEM_VENDOR_ID
,
688 pci_read_config_word(bus
->host_pci
, PCI_SUBSYSTEM_ID
,
690 pci_read_config_word(bus
->host_pci
, PCI_REVISION_ID
,
694 int ssb_pci_get_invariants(struct ssb_bus
*bus
,
695 struct ssb_init_invariants
*iv
)
699 err
= ssb_pci_sprom_get(bus
, &iv
->sprom
);
702 ssb_pci_get_boardinfo(bus
, &iv
->boardinfo
);
708 #ifdef CONFIG_SSB_DEBUG
709 static int ssb_pci_assert_buspower(struct ssb_bus
*bus
)
711 if (likely(bus
->powered_up
))
714 printk(KERN_ERR PFX
"FATAL ERROR: Bus powered down "
715 "while accessing PCI MMIO space\n");
716 if (bus
->power_warn_count
<= 10) {
717 bus
->power_warn_count
++;
724 static inline int ssb_pci_assert_buspower(struct ssb_bus
*bus
)
730 static u8
ssb_pci_read8(struct ssb_device
*dev
, u16 offset
)
732 struct ssb_bus
*bus
= dev
->bus
;
734 if (unlikely(ssb_pci_assert_buspower(bus
)))
736 if (unlikely(bus
->mapped_device
!= dev
)) {
737 if (unlikely(ssb_pci_switch_core(bus
, dev
)))
740 return ioread8(bus
->mmio
+ offset
);
743 static u16
ssb_pci_read16(struct ssb_device
*dev
, u16 offset
)
745 struct ssb_bus
*bus
= dev
->bus
;
747 if (unlikely(ssb_pci_assert_buspower(bus
)))
749 if (unlikely(bus
->mapped_device
!= dev
)) {
750 if (unlikely(ssb_pci_switch_core(bus
, dev
)))
753 return ioread16(bus
->mmio
+ offset
);
756 static u32
ssb_pci_read32(struct ssb_device
*dev
, u16 offset
)
758 struct ssb_bus
*bus
= dev
->bus
;
760 if (unlikely(ssb_pci_assert_buspower(bus
)))
762 if (unlikely(bus
->mapped_device
!= dev
)) {
763 if (unlikely(ssb_pci_switch_core(bus
, dev
)))
766 return ioread32(bus
->mmio
+ offset
);
769 #ifdef CONFIG_SSB_BLOCKIO
770 static void ssb_pci_block_read(struct ssb_device
*dev
, void *buffer
,
771 size_t count
, u16 offset
, u8 reg_width
)
773 struct ssb_bus
*bus
= dev
->bus
;
774 void __iomem
*addr
= bus
->mmio
+ offset
;
776 if (unlikely(ssb_pci_assert_buspower(bus
)))
778 if (unlikely(bus
->mapped_device
!= dev
)) {
779 if (unlikely(ssb_pci_switch_core(bus
, dev
)))
784 ioread8_rep(addr
, buffer
, count
);
787 SSB_WARN_ON(count
& 1);
788 ioread16_rep(addr
, buffer
, count
>> 1);
791 SSB_WARN_ON(count
& 3);
792 ioread32_rep(addr
, buffer
, count
>> 2);
800 memset(buffer
, 0xFF, count
);
802 #endif /* CONFIG_SSB_BLOCKIO */
804 static void ssb_pci_write8(struct ssb_device
*dev
, u16 offset
, u8 value
)
806 struct ssb_bus
*bus
= dev
->bus
;
808 if (unlikely(ssb_pci_assert_buspower(bus
)))
810 if (unlikely(bus
->mapped_device
!= dev
)) {
811 if (unlikely(ssb_pci_switch_core(bus
, dev
)))
814 iowrite8(value
, bus
->mmio
+ offset
);
817 static void ssb_pci_write16(struct ssb_device
*dev
, u16 offset
, u16 value
)
819 struct ssb_bus
*bus
= dev
->bus
;
821 if (unlikely(ssb_pci_assert_buspower(bus
)))
823 if (unlikely(bus
->mapped_device
!= dev
)) {
824 if (unlikely(ssb_pci_switch_core(bus
, dev
)))
827 iowrite16(value
, bus
->mmio
+ offset
);
830 static void ssb_pci_write32(struct ssb_device
*dev
, u16 offset
, u32 value
)
832 struct ssb_bus
*bus
= dev
->bus
;
834 if (unlikely(ssb_pci_assert_buspower(bus
)))
836 if (unlikely(bus
->mapped_device
!= dev
)) {
837 if (unlikely(ssb_pci_switch_core(bus
, dev
)))
840 iowrite32(value
, bus
->mmio
+ offset
);
843 #ifdef CONFIG_SSB_BLOCKIO
844 static void ssb_pci_block_write(struct ssb_device
*dev
, const void *buffer
,
845 size_t count
, u16 offset
, u8 reg_width
)
847 struct ssb_bus
*bus
= dev
->bus
;
848 void __iomem
*addr
= bus
->mmio
+ offset
;
850 if (unlikely(ssb_pci_assert_buspower(bus
)))
852 if (unlikely(bus
->mapped_device
!= dev
)) {
853 if (unlikely(ssb_pci_switch_core(bus
, dev
)))
858 iowrite8_rep(addr
, buffer
, count
);
861 SSB_WARN_ON(count
& 1);
862 iowrite16_rep(addr
, buffer
, count
>> 1);
865 SSB_WARN_ON(count
& 3);
866 iowrite32_rep(addr
, buffer
, count
>> 2);
872 #endif /* CONFIG_SSB_BLOCKIO */
874 /* Not "static", as it's used in main.c */
875 const struct ssb_bus_ops ssb_pci_ops
= {
876 .read8
= ssb_pci_read8
,
877 .read16
= ssb_pci_read16
,
878 .read32
= ssb_pci_read32
,
879 .write8
= ssb_pci_write8
,
880 .write16
= ssb_pci_write16
,
881 .write32
= ssb_pci_write32
,
882 #ifdef CONFIG_SSB_BLOCKIO
883 .block_read
= ssb_pci_block_read
,
884 .block_write
= ssb_pci_block_write
,
888 static ssize_t
ssb_pci_attr_sprom_show(struct device
*pcidev
,
889 struct device_attribute
*attr
,
892 struct pci_dev
*pdev
= container_of(pcidev
, struct pci_dev
, dev
);
895 bus
= ssb_pci_dev_to_bus(pdev
);
899 return ssb_attr_sprom_show(bus
, buf
, sprom_do_read
);
902 static ssize_t
ssb_pci_attr_sprom_store(struct device
*pcidev
,
903 struct device_attribute
*attr
,
904 const char *buf
, size_t count
)
906 struct pci_dev
*pdev
= container_of(pcidev
, struct pci_dev
, dev
);
909 bus
= ssb_pci_dev_to_bus(pdev
);
913 return ssb_attr_sprom_store(bus
, buf
, count
,
914 sprom_check_crc
, sprom_do_write
);
917 static DEVICE_ATTR(ssb_sprom
, 0600,
918 ssb_pci_attr_sprom_show
,
919 ssb_pci_attr_sprom_store
);
921 void ssb_pci_exit(struct ssb_bus
*bus
)
923 struct pci_dev
*pdev
;
925 if (bus
->bustype
!= SSB_BUSTYPE_PCI
)
928 pdev
= bus
->host_pci
;
929 device_remove_file(&pdev
->dev
, &dev_attr_ssb_sprom
);
932 int ssb_pci_init(struct ssb_bus
*bus
)
934 struct pci_dev
*pdev
;
937 if (bus
->bustype
!= SSB_BUSTYPE_PCI
)
940 pdev
= bus
->host_pci
;
941 mutex_init(&bus
->sprom_mutex
);
942 err
= device_create_file(&pdev
->dev
, &dev_attr_ssb_sprom
);