projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
fix a dependency bug
[openwrt.git] / target / linux / generic-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,
334 SSB_SPROM1_MAXPWR_A_SHIFT);
335 SPEX(maxpwr_bg, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_BG, 0);
336 SPEX(itssi_a, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_A,
337 SSB_SPROM1_ITSSI_A_SHIFT);
338 SPEX(itssi_bg, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_BG, 0);
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_bus *bus,
411 struct ssb_sprom *out, const u16 *in)
412 {
413 memset(out, 0, sizeof(*out));
414
415 SPEX(revision, SSB_SPROM_REVISION, SSB_SPROM_REVISION_REV, 0);
416 SPEX(crc, SSB_SPROM_REVISION, SSB_SPROM_REVISION_CRC,
417 SSB_SPROM_REVISION_CRC_SHIFT);
418
419 if ((bus->chip_id & 0xFF00) == 0x4400) {
420 /* Workaround: The BCM44XX chip has a stupid revision
421 * number stored in the SPROM.
422 * Always extract r1. */
423 sprom_extract_r1(&out->r1, in);
424 } else {
425 if (out->revision == 0)
426 goto unsupported;
427 if (out->revision >= 1 && out->revision <= 3)
428 sprom_extract_r1(&out->r1, in);
429 if (out->revision >= 2 && out->revision <= 3)
430 sprom_extract_r2(&out->r2, in);
431 if (out->revision == 3)
432 sprom_extract_r3(&out->r3, in);
433 if (out->revision >= 4)
434 goto unsupported;
435 }
436
437 return 0;
438 unsupported:
439 ssb_printk(KERN_WARNING PFX "Unsupported SPROM revision %d "
440 "detected. Will extract v1\n", out->revision);
441 sprom_extract_r1(&out->r1, in);
442 return 0;
443 }
444
445 static int ssb_pci_sprom_get(struct ssb_bus *bus,
446 struct ssb_sprom *sprom)
447 {
448 int err = -ENOMEM;
449 u16 *buf;
450
451 buf = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);
452 if (!buf)
453 goto out;
454 sprom_do_read(bus, buf);
455 err = sprom_check_crc(buf);
456 if (err) {
457 ssb_printk(KERN_WARNING PFX
458 "WARNING: Invalid SPROM CRC (corrupt SPROM)\n");
459 }
460 err = sprom_extract(bus, sprom, buf);
461
462 kfree(buf);
463 out:
464 return err;
465 }
466
467 static void ssb_pci_get_boardinfo(struct ssb_bus *bus,
468 struct ssb_boardinfo *bi)
469 {
470 pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID,
471 &bi->vendor);
472 pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID,
473 &bi->type);
474 pci_read_config_word(bus->host_pci, PCI_REVISION_ID,
475 &bi->rev);
476 }
477
478 int ssb_pci_get_invariants(struct ssb_bus *bus,
479 struct ssb_init_invariants *iv)
480 {
481 int err;
482
483 err = ssb_pci_sprom_get(bus, &iv->sprom);
484 if (err)
485 goto out;
486 ssb_pci_get_boardinfo(bus, &iv->boardinfo);
487
488 out:
489 return err;
490 }
491
492 static u16 ssb_pci_read16(struct ssb_device *dev, u16 offset)
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 0xFFFF;
499 }
500 return readw(bus->mmio + offset);
501 }
502
503 static u32 ssb_pci_read32(struct ssb_device *dev, u16 offset)
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 0xFFFFFFFF;
510 }
511 return readl(bus->mmio + offset);
512 }
513
514 static void ssb_pci_write16(struct ssb_device *dev, u16 offset, u16 value)
515 {
516 struct ssb_bus *bus = dev->bus;
517
518 if (unlikely(bus->mapped_device != dev)) {
519 if (unlikely(ssb_pci_switch_core(bus, dev)))
520 return;
521 }
522 writew(value, bus->mmio + offset);
523 }
524
525 static void ssb_pci_write32(struct ssb_device *dev, u16 offset, u32 value)
526 {
527 struct ssb_bus *bus = dev->bus;
528
529 if (unlikely(bus->mapped_device != dev)) {
530 if (unlikely(ssb_pci_switch_core(bus, dev)))
531 return;
532 }
533 writel(value, bus->mmio + offset);
534 }
535
536 const struct ssb_bus_ops ssb_pci_ops = {
537 .read16 = ssb_pci_read16,
538 .read32 = ssb_pci_read32,
539 .write16 = ssb_pci_write16,
540 .write32 = ssb_pci_write32,
541 };
542
543 static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len)
544 {
545 int i, pos = 0;
546
547 for (i = 0; i < SSB_SPROMSIZE_WORDS; i++) {
548 pos += snprintf(buf + pos, buf_len - pos - 1,
549 "%04X", swab16(sprom[i]) & 0xFFFF);
550 }
551 pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
552
553 return pos + 1;
554 }
555
556 static int hex2sprom(u16 *sprom, const char *dump, size_t len)
557 {
558 char tmp[5] = { 0 };
559 int cnt = 0;
560 unsigned long parsed;
561
562 if (len < SSB_SPROMSIZE_BYTES * 2)
563 return -EINVAL;
564
565 while (cnt < SSB_SPROMSIZE_WORDS) {
566 memcpy(tmp, dump, 4);
567 dump += 4;
568 parsed = simple_strtoul(tmp, NULL, 16);
569 sprom[cnt++] = swab16((u16)parsed);
570 }
571
572 return 0;
573 }
574
575 static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev,
576 struct device_attribute *attr,
577 char *buf)
578 {
579 struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
580 struct ssb_bus *bus;
581 u16 *sprom;
582 int err = -ENODEV;
583 ssize_t count = 0;
584
585 bus = ssb_pci_dev_to_bus(pdev);
586 if (!bus)
587 goto out;
588 err = -ENOMEM;
589 sprom = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);
590 if (!sprom)
591 goto out;
592
593 err = -ERESTARTSYS;
594 if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
595 goto out_kfree;
596 sprom_do_read(bus, sprom);
597 mutex_unlock(&bus->pci_sprom_mutex);
598
599 count = sprom2hex(sprom, buf, PAGE_SIZE);
600 err = 0;
601
602 out_kfree:
603 kfree(sprom);
604 out:
605 return err ? err : count;
606 }
607
608 static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev,
609 struct device_attribute *attr,
610 const char *buf, size_t count)
611 {
612 struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
613 struct ssb_bus *bus;
614 u16 *sprom;
615 int res = 0, err = -ENODEV;
616
617 bus = ssb_pci_dev_to_bus(pdev);
618 if (!bus)
619 goto out;
620 err = -ENOMEM;
621 sprom = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);
622 if (!sprom)
623 goto out;
624 err = hex2sprom(sprom, buf, count);
625 if (err) {
626 err = -EINVAL;
627 goto out_kfree;
628 }
629 err = sprom_check_crc(sprom);
630 if (err) {
631 err = -EINVAL;
632 goto out_kfree;
633 }
634
635 err = -ERESTARTSYS;
636 if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
637 goto out_kfree;
638 err = ssb_devices_freeze(bus);
639 if (err) {
640 ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n");
641 goto out_unlock;
642 }
643 res = sprom_do_write(bus, sprom);
644 err = ssb_devices_thaw(bus);
645 if (err)
646 ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n");
647 out_unlock:
648 mutex_unlock(&bus->pci_sprom_mutex);
649 out_kfree:
650 kfree(sprom);
651 out:
652 if (res)
653 return res;
654 return err ? err : count;
655 }
656
657 static DEVICE_ATTR(ssb_sprom, 0600,
658 ssb_pci_attr_sprom_show,
659 ssb_pci_attr_sprom_store);
660
661 void ssb_pci_exit(struct ssb_bus *bus)
662 {
663 struct pci_dev *pdev;
664
665 if (bus->bustype != SSB_BUSTYPE_PCI)
666 return;
667
668 pdev = bus->host_pci;
669 device_remove_file(&pdev->dev, &dev_attr_ssb_sprom);
670 }
671
672 int ssb_pci_init(struct ssb_bus *bus)
673 {
674 struct pci_dev *pdev;
675 int err;
676
677 if (bus->bustype != SSB_BUSTYPE_PCI)
678 return 0;
679
680 pdev = bus->host_pci;
681 mutex_init(&bus->pci_sprom_mutex);
682 err = device_create_file(&pdev->dev, &dev_attr_ssb_sprom);
683 if (err)
684 goto out;
685
686 out:
687 return err;
688 }
Personal OpenWRT clone
This page took 0.100597 seconds and 5 git commands to generate.