fcd8e871cbf4c37f2919709840b5e75c8a95ee6e
[openwrt/openwrt.git] / target / linux / brcm47xx-2.6 / files / drivers / ssb / pci.c
1 /*
2 * Sonics Silicon Backplane PCI-Hostbus related functions.
3 *
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>
9 *
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.
14 *
15 * Licensed under the GNU/GPL. See COPYING for details.
16 */
17
18 #include <linux/ssb/ssb.h>
19 #include <linux/ssb/ssb_regs.h>
20 #include <linux/pci.h>
21 #include <linux/delay.h>
22
23 #include "ssb_private.h"
24
25
26 int ssb_pci_switch_coreidx(struct ssb_bus *bus, u8 coreidx)
27 {
28 int err;
29 int attempts = 0;
30 u32 cur_core;
31
32 while (1) {
33 err = pci_write_config_dword(bus->host_pci, SSB_BAR0_WIN,
34 (coreidx * SSB_CORE_SIZE)
35 + SSB_ENUM_BASE);
36 if (err)
37 goto error;
38 err = pci_read_config_dword(bus->host_pci, SSB_BAR0_WIN,
39 &cur_core);
40 if (err)
41 goto error;
42 cur_core = (cur_core - SSB_ENUM_BASE)
43 / SSB_CORE_SIZE;
44 if (cur_core == coreidx)
45 break;
46
47 if (attempts++ > SSB_BAR0_MAX_RETRIES)
48 goto error;
49 udelay(10);
50 }
51 return 0;
52 error:
53 ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
54 return -ENODEV;
55 }
56
57 int ssb_pci_switch_core(struct ssb_bus *bus,
58 struct ssb_device *dev)
59 {
60 int err;
61 unsigned long flags;
62
63 ssb_dprintk(KERN_INFO PFX
64 "Switching to %s core, index %d\n",
65 ssb_core_name(dev->id.coreid),
66 dev->core_index);
67
68 spin_lock_irqsave(&bus->bar_lock, flags);
69 err = ssb_pci_switch_coreidx(bus, dev->core_index);
70 if (!err)
71 bus->mapped_device = dev;
72 spin_unlock_irqrestore(&bus->bar_lock, flags);
73
74 return err;
75 }
76
77 int ssb_pci_xtal(struct ssb_bus *bus, u32 what, int turn_on)
78 {
79 int err;
80 u32 in, out, outenable;
81 u16 pci_status;
82
83 if (bus->bustype != SSB_BUSTYPE_PCI)
84 return 0;
85
86 err = pci_read_config_dword(bus->host_pci, SSB_GPIO_IN, &in);
87 if (err)
88 goto err_pci;
89 err = pci_read_config_dword(bus->host_pci, SSB_GPIO_OUT, &out);
90 if (err)
91 goto err_pci;
92 err = pci_read_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE, &outenable);
93 if (err)
94 goto err_pci;
95
96 outenable |= what;
97
98 if (turn_on) {
99 /* Avoid glitching the clock if GPRS is already using it.
100 * We can't actually read the state of the PLLPD so we infer it
101 * by the value of XTAL_PU which *is* readable via gpioin.
102 */
103 if (!(in & SSB_GPIO_XTAL)) {
104 if (what & SSB_GPIO_XTAL) {
105 /* Turn the crystal on */
106 out |= SSB_GPIO_XTAL;
107 if (what & SSB_GPIO_PLL)
108 out |= SSB_GPIO_PLL;
109 err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
110 if (err)
111 goto err_pci;
112 err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE,
113 outenable);
114 if (err)
115 goto err_pci;
116 msleep(1);
117 }
118 if (what & SSB_GPIO_PLL) {
119 /* Turn the PLL on */
120 out &= ~SSB_GPIO_PLL;
121 err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
122 if (err)
123 goto err_pci;
124 msleep(5);
125 }
126 }
127
128 err = pci_read_config_word(bus->host_pci, PCI_STATUS, &pci_status);
129 if (err)
130 goto err_pci;
131 pci_status &= ~PCI_STATUS_SIG_TARGET_ABORT;
132 err = pci_write_config_word(bus->host_pci, PCI_STATUS, pci_status);
133 if (err)
134 goto err_pci;
135 } else {
136 if (what & SSB_GPIO_XTAL) {
137 /* Turn the crystal off */
138 out &= ~SSB_GPIO_XTAL;
139 }
140 if (what & SSB_GPIO_PLL) {
141 /* Turn the PLL off */
142 out |= SSB_GPIO_PLL;
143 }
144 err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
145 if (err)
146 goto err_pci;
147 err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE, outenable);
148 if (err)
149 goto err_pci;
150 }
151
152 out:
153 return err;
154
155 err_pci:
156 printk(KERN_ERR PFX "Error: ssb_pci_xtal() could not access PCI config space!\n");
157 err = -EBUSY;
158 goto out;
159 }
160
161 #define SPOFF(offset) (((offset) - SSB_SPROM_BASE) / sizeof(u16))
162 #define SPEX(_outvar, _offset, _mask, _shift) \
163 out->_outvar = ((in[SPOFF(_offset)] & (_mask)) >> (_shift))
164
165 static inline u8 ssb_crc8(u8 crc, u8 data)
166 {
167 /* Polynomial: x^8 + x^7 + x^6 + x^4 + x^2 + 1 */
168 static const u8 t[] = {
169 0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
170 0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
171 0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
172 0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
173 0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
174 0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
175 0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
176 0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
177 0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
178 0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
179 0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
180 0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
181 0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
182 0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
183 0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
184 0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
185 0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
186 0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
187 0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
188 0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
189 0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
190 0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
191 0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
192 0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
193 0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
194 0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
195 0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
196 0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
197 0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
198 0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
199 0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
200 0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F,
201 };
202 return t[crc ^ data];
203 }
204
205 static u8 ssb_sprom_crc(const u16 *sprom)
206 {
207 int word;
208 u8 crc = 0xFF;
209
210 for (word = 0; word < SSB_SPROMSIZE_WORDS - 1; word++) {
211 crc = ssb_crc8(crc, sprom[word] & 0x00FF);
212 crc = ssb_crc8(crc, (sprom[word] & 0xFF00) >> 8);
213 }
214 crc = ssb_crc8(crc, sprom[SPOFF(SSB_SPROM_REVISION)] & 0x00FF);
215 crc ^= 0xFF;
216
217 return crc;
218 }
219
220 static int sprom_check_crc(const u16 *sprom)
221 {
222 u8 crc;
223 u8 expected_crc;
224 u16 tmp;
225
226 crc = ssb_sprom_crc(sprom);
227 tmp = sprom[SPOFF(SSB_SPROM_REVISION)] & SSB_SPROM_REVISION_CRC;
228 expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
229 if (crc != expected_crc)
230 return -EPROTO;
231
232 return 0;
233 }
234
235 static void sprom_do_read(struct ssb_bus *bus, u16 *sprom)
236 {
237 int i;
238
239 for (i = 0; i < SSB_SPROMSIZE_WORDS; i++)
240 sprom[i] = readw(bus->mmio + SSB_SPROM_BASE + (i * 2));
241 }
242
243 static int sprom_do_write(struct ssb_bus *bus, const u16 *sprom)
244 {
245 struct pci_dev *pdev = bus->host_pci;
246 int i, err;
247 u32 spromctl;
248
249 ssb_printk(KERN_NOTICE PFX "Writing SPROM. Do NOT turn off the power! Please stand by...\n");
250 err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);
251 if (err)
252 goto err_ctlreg;
253 spromctl |= SSB_SPROMCTL_WE;
254 err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl);
255 if (err)
256 goto err_ctlreg;
257 ssb_printk(KERN_NOTICE PFX "[ 0%%");
258 msleep(500);
259 for (i = 0; i < SSB_SPROMSIZE_WORDS; i++) {
260 if (i == SSB_SPROMSIZE_WORDS / 4)
261 ssb_printk("25%%");
262 else if (i == SSB_SPROMSIZE_WORDS / 2)
263 ssb_printk("50%%");
264 else if (i == (SSB_SPROMSIZE_WORDS / 4) * 3)
265 ssb_printk("75%%");
266 else if (i % 2)
267 ssb_printk(".");
268 writew(sprom[i], bus->mmio + SSB_SPROM_BASE + (i * 2));
269 mmiowb();
270 msleep(20);
271 }
272 err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);
273 if (err)
274 goto err_ctlreg;
275 spromctl &= ~SSB_SPROMCTL_WE;
276 err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl);
277 if (err)
278 goto err_ctlreg;
279 msleep(500);
280 ssb_printk("100%% ]\n");
281 ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
282
283 return 0;
284 err_ctlreg:
285 ssb_printk(KERN_ERR PFX "Could not access SPROM control register.\n");
286 return err;
287 }
288
289 static void sprom_extract_r1(struct ssb_sprom_r1 *out, const u16 *in)
290 {
291 int i;
292 u16 v;
293
294 SPEX(pci_spid, SSB_SPROM1_SPID, 0xFFFF, 0);
295 SPEX(pci_svid, SSB_SPROM1_SVID, 0xFFFF, 0);
296 SPEX(pci_pid, SSB_SPROM1_PID, 0xFFFF, 0);
297 for (i = 0; i < 3; i++) {
298 v = in[SPOFF(SSB_SPROM1_IL0MAC) + i];
299 *(((u16 *)out->il0mac) + i) = cpu_to_be16(v);
300 }
301 for (i = 0; i < 3; i++) {
302 v = in[SPOFF(SSB_SPROM1_ET0MAC) + i];
303 *(((u16 *)out->et0mac) + i) = cpu_to_be16(v);
304 }
305 for (i = 0; i < 3; i++) {
306 v = in[SPOFF(SSB_SPROM1_ET1MAC) + i];
307 *(((u16 *)out->et1mac) + i) = cpu_to_be16(v);
308 }
309 SPEX(et0phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0A, 0);
310 SPEX(et1phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1A,
311 SSB_SPROM1_ETHPHY_ET1A_SHIFT);
312 SPEX(et0mdcport, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0M, 14);
313 SPEX(et1mdcport, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1M, 15);
314 SPEX(board_rev, SSB_SPROM1_BINF, SSB_SPROM1_BINF_BREV, 0);
315 SPEX(country_code, SSB_SPROM1_BINF, SSB_SPROM1_BINF_CCODE,
316 SSB_SPROM1_BINF_CCODE_SHIFT);
317 SPEX(antenna_a, SSB_SPROM1_BINF, SSB_SPROM1_BINF_ANTA,
318 SSB_SPROM1_BINF_ANTA_SHIFT);
319 SPEX(antenna_bg, SSB_SPROM1_BINF, SSB_SPROM1_BINF_ANTBG,
320 SSB_SPROM1_BINF_ANTBG_SHIFT);
321 SPEX(pa0b0, SSB_SPROM1_PA0B0, 0xFFFF, 0);
322 SPEX(pa0b1, SSB_SPROM1_PA0B1, 0xFFFF, 0);
323 SPEX(pa0b2, SSB_SPROM1_PA0B2, 0xFFFF, 0);
324 SPEX(pa1b0, SSB_SPROM1_PA1B0, 0xFFFF, 0);
325 SPEX(pa1b1, SSB_SPROM1_PA1B1, 0xFFFF, 0);
326 SPEX(pa1b2, SSB_SPROM1_PA1B2, 0xFFFF, 0);
327 SPEX(gpio0, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P0, 0);
328 SPEX(gpio1, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P1,
329 SSB_SPROM1_GPIOA_P1_SHIFT);
330 SPEX(gpio2, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P2, 0);
331 SPEX(gpio3, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P3,
332 SSB_SPROM1_GPIOB_P3_SHIFT);
333 SPEX(maxpwr_a, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_A, 0);
334 SPEX(maxpwr_bg, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_BG,
335 SSB_SPROM1_MAXPWR_BG_SHIFT);
336 SPEX(itssi_a, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_A, 0);
337 SPEX(itssi_bg, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_BG,
338 SSB_SPROM1_ITSSI_BG_SHIFT);
339 SPEX(boardflags_lo, SSB_SPROM1_BFLLO, 0xFFFF, 0);
340 SPEX(antenna_gain_a, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_A, 0);
341 SPEX(antenna_gain_bg, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_BG,
342 SSB_SPROM1_AGAIN_BG_SHIFT);
343 for (i = 0; i < 4; i++) {
344 v = in[SPOFF(SSB_SPROM1_OEM) + i];
345 *(((u16 *)out->oem) + i) = cpu_to_le16(v);
346 }
347 }
348
349 static void sprom_extract_r2(struct ssb_sprom_r2 *out, const u16 *in)
350 {
351 int i;
352 u16 v;
353
354 SPEX(boardflags_hi, SSB_SPROM2_BFLHI, 0xFFFF, 0);
355 SPEX(maxpwr_a_hi, SSB_SPROM2_MAXP_A, SSB_SPROM2_MAXP_A_HI, 0);
356 SPEX(maxpwr_a_lo, SSB_SPROM2_MAXP_A, SSB_SPROM2_MAXP_A_LO,
357 SSB_SPROM2_MAXP_A_LO_SHIFT);
358 SPEX(pa1lob0, SSB_SPROM2_PA1LOB0, 0xFFFF, 0);
359 SPEX(pa1lob1, SSB_SPROM2_PA1LOB1, 0xFFFF, 0);
360 SPEX(pa1lob2, SSB_SPROM2_PA1LOB2, 0xFFFF, 0);
361 SPEX(pa1hib0, SSB_SPROM2_PA1HIB0, 0xFFFF, 0);
362 SPEX(pa1hib1, SSB_SPROM2_PA1HIB1, 0xFFFF, 0);
363 SPEX(pa1hib2, SSB_SPROM2_PA1HIB2, 0xFFFF, 0);
364 SPEX(ofdm_pwr_off, SSB_SPROM2_OPO, SSB_SPROM2_OPO_VALUE, 0);
365 for (i = 0; i < 4; i++) {
366 v = in[SPOFF(SSB_SPROM2_CCODE) + i];
367 *(((u16 *)out->country_str) + i) = cpu_to_le16(v);
368 }
369 }
370
371 static void sprom_extract_r3(struct ssb_sprom_r3 *out, const u16 *in)
372 {
373 out->ofdmapo = (in[SPOFF(SSB_SPROM3_OFDMAPO) + 0] & 0xFF00) >> 8;
374 out->ofdmapo |= (in[SPOFF(SSB_SPROM3_OFDMAPO) + 0] & 0x00FF) << 8;
375 out->ofdmapo <<= 16;
376 out->ofdmapo |= (in[SPOFF(SSB_SPROM3_OFDMAPO) + 1] & 0xFF00) >> 8;
377 out->ofdmapo |= (in[SPOFF(SSB_SPROM3_OFDMAPO) + 1] & 0x00FF) << 8;
378
379 out->ofdmalpo = (in[SPOFF(SSB_SPROM3_OFDMALPO) + 0] & 0xFF00) >> 8;
380 out->ofdmalpo |= (in[SPOFF(SSB_SPROM3_OFDMALPO) + 0] & 0x00FF) << 8;
381 out->ofdmalpo <<= 16;
382 out->ofdmalpo |= (in[SPOFF(SSB_SPROM3_OFDMALPO) + 1] & 0xFF00) >> 8;
383 out->ofdmalpo |= (in[SPOFF(SSB_SPROM3_OFDMALPO) + 1] & 0x00FF) << 8;
384
385 out->ofdmahpo = (in[SPOFF(SSB_SPROM3_OFDMAHPO) + 0] & 0xFF00) >> 8;
386 out->ofdmahpo |= (in[SPOFF(SSB_SPROM3_OFDMAHPO) + 0] & 0x00FF) << 8;
387 out->ofdmahpo <<= 16;
388 out->ofdmahpo |= (in[SPOFF(SSB_SPROM3_OFDMAHPO) + 1] & 0xFF00) >> 8;
389 out->ofdmahpo |= (in[SPOFF(SSB_SPROM3_OFDMAHPO) + 1] & 0x00FF) << 8;
390
391 SPEX(gpioldc_on_cnt, SSB_SPROM3_GPIOLDC, SSB_SPROM3_GPIOLDC_ON,
392 SSB_SPROM3_GPIOLDC_ON_SHIFT);
393 SPEX(gpioldc_off_cnt, SSB_SPROM3_GPIOLDC, SSB_SPROM3_GPIOLDC_OFF,
394 SSB_SPROM3_GPIOLDC_OFF_SHIFT);
395 SPEX(cckpo_1M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_1M, 0);
396 SPEX(cckpo_2M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_2M,
397 SSB_SPROM3_CCKPO_2M_SHIFT);
398 SPEX(cckpo_55M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_55M,
399 SSB_SPROM3_CCKPO_55M_SHIFT);
400 SPEX(cckpo_11M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_11M,
401 SSB_SPROM3_CCKPO_11M_SHIFT);
402
403 out->ofdmgpo = (in[SPOFF(SSB_SPROM3_OFDMGPO) + 0] & 0xFF00) >> 8;
404 out->ofdmgpo |= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 0] & 0x00FF) << 8;
405 out->ofdmgpo <<= 16;
406 out->ofdmgpo |= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 1] & 0xFF00) >> 8;
407 out->ofdmgpo |= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 1] & 0x00FF) << 8;
408 }
409
410 static int sprom_extract(struct ssb_sprom *out, const u16 *in)
411 {
412 memset(out, 0, sizeof(*out));
413
414 SPEX(revision, SSB_SPROM_REVISION, SSB_SPROM_REVISION_REV, 0);
415 SPEX(crc, SSB_SPROM_REVISION, SSB_SPROM_REVISION_CRC,
416 SSB_SPROM_REVISION_CRC_SHIFT);
417
418 if (out->revision == 0)
419 goto unsupported;
420 if (out->revision >= 1 && out->revision <= 3)
421 sprom_extract_r1(&out->r1, in);
422 if (out->revision >= 2 && out->revision <= 3)
423 sprom_extract_r2(&out->r2, in);
424 if (out->revision == 3)
425 sprom_extract_r3(&out->r3, in);
426 if (out->revision >= 4)
427 goto unsupported;
428
429 return 0;
430 unsupported:
431 ssb_printk(KERN_WARNING PFX "Unsupported SPROM revision %d "
432 "detected. Will extract v1\n", out->revision);
433 sprom_extract_r1(&out->r1, in);
434 return 0;
435 }
436
437 int ssb_pci_sprom_get(struct ssb_bus *bus)
438 {
439 int err = -ENOMEM;
440 u16 *buf;
441
442 assert(bus->bustype == SSB_BUSTYPE_PCI);
443
444 buf = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);
445 if (!buf)
446 goto out;
447 sprom_do_read(bus, buf);
448 err = sprom_check_crc(buf);
449 if (err) {
450 ssb_printk(KERN_WARNING PFX
451 "WARNING: Invalid SPROM CRC (corrupt SPROM)\n");
452 }
453 err = sprom_extract(&bus->sprom, buf);
454
455 kfree(buf);
456 out:
457 return err;
458 }
459
460 void ssb_pci_get_boardtype(struct ssb_bus *bus)
461 {
462 pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID,
463 &bus->board_vendor);
464 pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID,
465 &bus->board_type);
466 pci_read_config_word(bus->host_pci, PCI_REVISION_ID,
467 &bus->board_rev);
468 }
469
470 static u16 ssb_pci_read16(struct ssb_device *dev, u16 offset)
471 {
472 struct ssb_bus *bus = dev->bus;
473
474 if (unlikely(bus->mapped_device != dev)) {
475 if (unlikely(ssb_pci_switch_core(bus, dev)))
476 return 0xFFFF;
477 }
478 return readw(bus->mmio + offset);
479 }
480
481 static u32 ssb_pci_read32(struct ssb_device *dev, u16 offset)
482 {
483 struct ssb_bus *bus = dev->bus;
484
485 if (unlikely(bus->mapped_device != dev)) {
486 if (unlikely(ssb_pci_switch_core(bus, dev)))
487 return 0xFFFFFFFF;
488 }
489 return readl(bus->mmio + offset);
490 }
491
492 static void ssb_pci_write16(struct ssb_device *dev, u16 offset, u16 value)
493 {
494 struct ssb_bus *bus = dev->bus;
495
496 if (unlikely(bus->mapped_device != dev)) {
497 if (unlikely(ssb_pci_switch_core(bus, dev)))
498 return;
499 }
500 writew(value, bus->mmio + offset);
501 }
502
503 static void ssb_pci_write32(struct ssb_device *dev, u16 offset, u32 value)
504 {
505 struct ssb_bus *bus = dev->bus;
506
507 if (unlikely(bus->mapped_device != dev)) {
508 if (unlikely(ssb_pci_switch_core(bus, dev)))
509 return;
510 }
511 writel(value, bus->mmio + offset);
512 }
513
514 const struct ssb_bus_ops ssb_pci_ops = {
515 .read16 = ssb_pci_read16,
516 .read32 = ssb_pci_read32,
517 .write16 = ssb_pci_write16,
518 .write32 = ssb_pci_write32,
519 };
520
521 static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len)
522 {
523 int i, pos = 0;
524
525 for (i = 0; i < SSB_SPROMSIZE_WORDS; i++) {
526 pos += snprintf(buf + pos, buf_len - pos - 1,
527 "%04X", swab16(sprom[i]) & 0xFFFF);
528 }
529 pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
530
531 return pos + 1;
532 }
533
534 static int hex2sprom(u16 *sprom, const char *dump, size_t len)
535 {
536 char tmp[5] = { 0 };
537 int cnt = 0;
538 unsigned long parsed;
539
540 if (len < SSB_SPROMSIZE_BYTES * 2)
541 return -EINVAL;
542
543 while (cnt < SSB_SPROMSIZE_WORDS) {
544 memcpy(tmp, dump, 4);
545 dump += 4;
546 parsed = simple_strtoul(tmp, NULL, 16);
547 sprom[cnt++] = swab16((u16)parsed);
548 }
549
550 return 0;
551 }
552
553 static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev,
554 struct device_attribute *attr,
555 char *buf)
556 {
557 struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
558 struct ssb_bus *bus;
559 u16 *sprom;
560 int err = -ENODEV;
561 ssize_t count = 0;
562
563 bus = ssb_pci_dev_to_bus(pdev);
564 if (!bus)
565 goto out;
566 err = -ENOMEM;
567 sprom = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);
568 if (!sprom)
569 goto out;
570
571 err = -ERESTARTSYS;
572 if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
573 goto out_kfree;
574 sprom_do_read(bus, sprom);
575 mutex_unlock(&bus->pci_sprom_mutex);
576
577 count = sprom2hex(sprom, buf, PAGE_SIZE);
578 err = 0;
579
580 out_kfree:
581 kfree(sprom);
582 out:
583 return err ? err : count;
584 }
585
586 static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev,
587 struct device_attribute *attr,
588 const char *buf, size_t count)
589 {
590 struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
591 struct ssb_bus *bus;
592 u16 *sprom;
593 int res = 0, err = -ENODEV;
594
595 bus = ssb_pci_dev_to_bus(pdev);
596 if (!bus)
597 goto out;
598 err = -ENOMEM;
599 sprom = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);
600 if (!sprom)
601 goto out;
602 err = hex2sprom(sprom, buf, count);
603 if (err) {
604 err = -EINVAL;
605 goto out_kfree;
606 }
607 err = sprom_check_crc(sprom);
608 if (err) {
609 err = -EINVAL;
610 goto out_kfree;
611 }
612
613 err = -ERESTARTSYS;
614 if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
615 goto out_kfree;
616 err = ssb_devices_freeze(bus);
617 if (err) {
618 ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n");
619 goto out_unlock;
620 }
621 res = sprom_do_write(bus, sprom);
622 err = ssb_devices_thaw(bus);
623 if (err)
624 ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n");
625 out_unlock:
626 mutex_unlock(&bus->pci_sprom_mutex);
627 out_kfree:
628 kfree(sprom);
629 out:
630 if (res)
631 return res;
632 return err ? err : count;
633 }
634
635 static DEVICE_ATTR(ssb_sprom, 0600,
636 ssb_pci_attr_sprom_show,
637 ssb_pci_attr_sprom_store);
638
639 void ssb_pci_exit(struct ssb_bus *bus)
640 {
641 struct pci_dev *pdev;
642
643 if (bus->bustype != SSB_BUSTYPE_PCI)
644 return;
645
646 pdev = bus->host_pci;
647 device_remove_file(&pdev->dev, &dev_attr_ssb_sprom);
648 }
649
650 int ssb_pci_init(struct ssb_bus *bus)
651 {
652 struct pci_dev *pdev;
653 int err;
654
655 if (bus->bustype != SSB_BUSTYPE_PCI)
656 return 0;
657
658 pdev = bus->host_pci;
659 mutex_init(&bus->pci_sprom_mutex);
660 err = device_create_file(&pdev->dev, &dev_attr_ssb_sprom);
661 if (err)
662 goto out;
663 err = ssb_pci_sprom_get(bus);
664 if (err)
665 goto err_remove_sprom_file;
666
667 out:
668 return err;
669 err_remove_sprom_file:
670 device_remove_file(&pdev->dev, &dev_attr_ssb_sprom);
671 return err;
672 }