projects / openwrt.git / blob
? search:


82872c78ad9bfa06bd8142a7291f59e6698655d1
[openwrt.git] / target / linux / generic / patches-2.6.37 / 020-ssb_update.patch
1 --- a/drivers/ssb/main.c
2 +++ b/drivers/ssb/main.c
3 @@ -383,6 +383,35 @@ static int ssb_device_uevent(struct devi
4 ssb_dev->id.revision);
5 }
6
7 +#define ssb_config_attr(attrib, field, format_string) \
8 +static ssize_t \
9 +attrib##_show(struct device *dev, struct device_attribute *attr, char *buf) \
10 +{ \
11 + return sprintf(buf, format_string, dev_to_ssb_dev(dev)->field); \
12 +}
13 +
14 +ssb_config_attr(core_num, core_index, "%u\n")
15 +ssb_config_attr(coreid, id.coreid, "0x%04x\n")
16 +ssb_config_attr(vendor, id.vendor, "0x%04x\n")
17 +ssb_config_attr(revision, id.revision, "%u\n")
18 +ssb_config_attr(irq, irq, "%u\n")
19 +static ssize_t
20 +name_show(struct device *dev, struct device_attribute *attr, char *buf)
21 +{
22 + return sprintf(buf, "%s\n",
23 + ssb_core_name(dev_to_ssb_dev(dev)->id.coreid));
24 +}
25 +
26 +static struct device_attribute ssb_device_attrs[] = {
27 + __ATTR_RO(name),
28 + __ATTR_RO(core_num),
29 + __ATTR_RO(coreid),
30 + __ATTR_RO(vendor),
31 + __ATTR_RO(revision),
32 + __ATTR_RO(irq),
33 + __ATTR_NULL,
34 +};
35 +
36 static struct bus_type ssb_bustype = {
37 .name = "ssb",
38 .match = ssb_bus_match,
39 @@ -392,6 +421,7 @@ static struct bus_type ssb_bustype = {
40 .suspend = ssb_device_suspend,
41 .resume = ssb_device_resume,
42 .uevent = ssb_device_uevent,
43 + .dev_attrs = ssb_device_attrs,
44 };
45
46 static void ssb_buses_lock(void)
47 @@ -527,7 +557,7 @@ error:
48 }
49
50 /* Needs ssb_buses_lock() */
51 -static int ssb_attach_queued_buses(void)
52 +static int __devinit ssb_attach_queued_buses(void)
53 {
54 struct ssb_bus *bus, *n;
55 int err = 0;
56 @@ -738,9 +768,9 @@ out:
57 return err;
58 }
59
60 -static int ssb_bus_register(struct ssb_bus *bus,
61 - ssb_invariants_func_t get_invariants,
62 - unsigned long baseaddr)
63 +static int __devinit ssb_bus_register(struct ssb_bus *bus,
64 + ssb_invariants_func_t get_invariants,
65 + unsigned long baseaddr)
66 {
67 int err;
68
69 @@ -821,8 +851,8 @@ err_disable_xtal:
70 }
71
72 #ifdef CONFIG_SSB_PCIHOST
73 -int ssb_bus_pcibus_register(struct ssb_bus *bus,
74 - struct pci_dev *host_pci)
75 +int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus,
76 + struct pci_dev *host_pci)
77 {
78 int err;
79
80 @@ -845,9 +875,9 @@ EXPORT_SYMBOL(ssb_bus_pcibus_register);
81 #endif /* CONFIG_SSB_PCIHOST */
82
83 #ifdef CONFIG_SSB_PCMCIAHOST
84 -int ssb_bus_pcmciabus_register(struct ssb_bus *bus,
85 - struct pcmcia_device *pcmcia_dev,
86 - unsigned long baseaddr)
87 +int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus,
88 + struct pcmcia_device *pcmcia_dev,
89 + unsigned long baseaddr)
90 {
91 int err;
92
93 @@ -867,8 +897,9 @@ EXPORT_SYMBOL(ssb_bus_pcmciabus_register
94 #endif /* CONFIG_SSB_PCMCIAHOST */
95
96 #ifdef CONFIG_SSB_SDIOHOST
97 -int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func,
98 - unsigned int quirks)
99 +int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus,
100 + struct sdio_func *func,
101 + unsigned int quirks)
102 {
103 int err;
104
105 @@ -888,9 +919,9 @@ int ssb_bus_sdiobus_register(struct ssb_
106 EXPORT_SYMBOL(ssb_bus_sdiobus_register);
107 #endif /* CONFIG_SSB_PCMCIAHOST */
108
109 -int ssb_bus_ssbbus_register(struct ssb_bus *bus,
110 - unsigned long baseaddr,
111 - ssb_invariants_func_t get_invariants)
112 +int __devinit ssb_bus_ssbbus_register(struct ssb_bus *bus,
113 + unsigned long baseaddr,
114 + ssb_invariants_func_t get_invariants)
115 {
116 int err;
117
118 @@ -971,8 +1002,8 @@ u32 ssb_calc_clock_rate(u32 plltype, u32
119 switch (plltype) {
120 case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */
121 if (m & SSB_CHIPCO_CLK_T6_MMASK)
122 - return SSB_CHIPCO_CLK_T6_M0;
123 - return SSB_CHIPCO_CLK_T6_M1;
124 + return SSB_CHIPCO_CLK_T6_M1;
125 + return SSB_CHIPCO_CLK_T6_M0;
126 case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */
127 case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
128 case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */
129 @@ -1087,23 +1118,22 @@ static u32 ssb_tmslow_reject_bitmask(str
130 {
131 u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV;
132
133 - /* The REJECT bit changed position in TMSLOW between
134 - * Backplane revisions. */
135 + /* The REJECT bit seems to be different for Backplane rev 2.3 */
136 switch (rev) {
137 case SSB_IDLOW_SSBREV_22:
138 - return SSB_TMSLOW_REJECT_22;
139 + case SSB_IDLOW_SSBREV_24:
140 + case SSB_IDLOW_SSBREV_26:
141 + return SSB_TMSLOW_REJECT;
142 case SSB_IDLOW_SSBREV_23:
143 return SSB_TMSLOW_REJECT_23;
144 - case SSB_IDLOW_SSBREV_24: /* TODO - find the proper REJECT bits */
145 - case SSB_IDLOW_SSBREV_25: /* same here */
146 - case SSB_IDLOW_SSBREV_26: /* same here */
147 + case SSB_IDLOW_SSBREV_25: /* TODO - find the proper REJECT bit */
148 case SSB_IDLOW_SSBREV_27: /* same here */
149 - return SSB_TMSLOW_REJECT_23; /* this is a guess */
150 + return SSB_TMSLOW_REJECT; /* this is a guess */
151 default:
152 printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev);
153 WARN_ON(1);
154 }
155 - return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23);
156 + return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23);
157 }
158
159 int ssb_device_is_enabled(struct ssb_device *dev)
160 @@ -1162,10 +1192,10 @@ void ssb_device_enable(struct ssb_device
161 }
162 EXPORT_SYMBOL(ssb_device_enable);
163
164 -/* Wait for a bit in a register to get set or unset.
165 +/* Wait for bitmask in a register to get set or cleared.
166 * timeout is in units of ten-microseconds */
167 -static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask,
168 - int timeout, int set)
169 +static int ssb_wait_bits(struct ssb_device *dev, u16 reg, u32 bitmask,
170 + int timeout, int set)
171 {
172 int i;
173 u32 val;
174 @@ -1173,7 +1203,7 @@ static int ssb_wait_bit(struct ssb_devic
175 for (i = 0; i < timeout; i++) {
176 val = ssb_read32(dev, reg);
177 if (set) {
178 - if (val & bitmask)
179 + if ((val & bitmask) == bitmask)
180 return 0;
181 } else {
182 if (!(val & bitmask))
183 @@ -1190,20 +1220,38 @@ static int ssb_wait_bit(struct ssb_devic
184
185 void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags)
186 {
187 - u32 reject;
188 + u32 reject, val;
189
190 if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET)
191 return;
192
193 reject = ssb_tmslow_reject_bitmask(dev);
194 - ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK);
195 - ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1);
196 - ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0);
197 - ssb_write32(dev, SSB_TMSLOW,
198 - SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK |
199 - reject | SSB_TMSLOW_RESET |
200 - core_specific_flags);
201 - ssb_flush_tmslow(dev);
202 +
203 + if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_CLOCK) {
204 + ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK);
205 + ssb_wait_bits(dev, SSB_TMSLOW, reject, 1000, 1);
206 + ssb_wait_bits(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0);
207 +
208 + if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) {
209 + val = ssb_read32(dev, SSB_IMSTATE);
210 + val |= SSB_IMSTATE_REJECT;
211 + ssb_write32(dev, SSB_IMSTATE, val);
212 + ssb_wait_bits(dev, SSB_IMSTATE, SSB_IMSTATE_BUSY, 1000,
213 + 0);
214 + }
215 +
216 + ssb_write32(dev, SSB_TMSLOW,
217 + SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK |
218 + reject | SSB_TMSLOW_RESET |
219 + core_specific_flags);
220 + ssb_flush_tmslow(dev);
221 +
222 + if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) {
223 + val = ssb_read32(dev, SSB_IMSTATE);
224 + val &= ~SSB_IMSTATE_REJECT;
225 + ssb_write32(dev, SSB_IMSTATE, val);
226 + }
227 + }
228
229 ssb_write32(dev, SSB_TMSLOW,
230 reject | SSB_TMSLOW_RESET |
231 @@ -1218,7 +1266,10 @@ u32 ssb_dma_translation(struct ssb_devic
232 case SSB_BUSTYPE_SSB:
233 return 0;
234 case SSB_BUSTYPE_PCI:
235 - return SSB_PCI_DMA;
236 + if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64)
237 + return SSB_PCIE_DMA_H32;
238 + else
239 + return SSB_PCI_DMA;
240 default:
241 __ssb_dma_not_implemented(dev);
242 }
243 @@ -1261,20 +1312,20 @@ EXPORT_SYMBOL(ssb_bus_may_powerdown);
244
245 int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl)
246 {
247 - struct ssb_chipcommon *cc;
248 int err;
249 enum ssb_clkmode mode;
250
251 err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1);
252 if (err)
253 goto error;
254 - cc = &bus->chipco;
255 - mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST;
256 - ssb_chipco_set_clockmode(cc, mode);
257
258 #ifdef CONFIG_SSB_DEBUG
259 bus->powered_up = 1;
260 #endif
261 +
262 + mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST;
263 + ssb_chipco_set_clockmode(&bus->chipco, mode);
264 +
265 return 0;
266 error:
267 ssb_printk(KERN_ERR PFX "Bus powerup failed\n");
268 @@ -1282,6 +1333,37 @@ error:
269 }
270 EXPORT_SYMBOL(ssb_bus_powerup);
271
272 +static void ssb_broadcast_value(struct ssb_device *dev,
273 + u32 address, u32 data)
274 +{
275 +#ifdef CONFIG_SSB_DRIVER_PCICORE
276 + /* This is used for both, PCI and ChipCommon core, so be careful. */
277 + BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR);
278 + BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA);
279 +#endif
280 +
281 + ssb_write32(dev, SSB_CHIPCO_BCAST_ADDR, address);
282 + ssb_read32(dev, SSB_CHIPCO_BCAST_ADDR); /* flush */
283 + ssb_write32(dev, SSB_CHIPCO_BCAST_DATA, data);
284 + ssb_read32(dev, SSB_CHIPCO_BCAST_DATA); /* flush */
285 +}
286 +
287 +void ssb_commit_settings(struct ssb_bus *bus)
288 +{
289 + struct ssb_device *dev;
290 +
291 +#ifdef CONFIG_SSB_DRIVER_PCICORE
292 + dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev;
293 +#else
294 + dev = bus->chipco.dev;
295 +#endif
296 + if (WARN_ON(!dev))
297 + return;
298 + /* This forces an update of the cached registers. */
299 + ssb_broadcast_value(dev, 0xFD8, 0);
300 +}
301 +EXPORT_SYMBOL(ssb_commit_settings);
302 +
303 u32 ssb_admatch_base(u32 adm)
304 {
305 u32 base = 0;
306 --- a/drivers/ssb/pci.c
307 +++ b/drivers/ssb/pci.c
308 @@ -406,6 +406,46 @@ static void sprom_extract_r123(struct ss
309 out->antenna_gain.ghz5.a3 = gain;
310 }
311
312 +/* Revs 4 5 and 8 have partially shared layout */
313 +static void sprom_extract_r458(struct ssb_sprom *out, const u16 *in)
314 +{
315 + SPEX(txpid2g[0], SSB_SPROM4_TXPID2G01,
316 + SSB_SPROM4_TXPID2G0, SSB_SPROM4_TXPID2G0_SHIFT);
317 + SPEX(txpid2g[1], SSB_SPROM4_TXPID2G01,
318 + SSB_SPROM4_TXPID2G1, SSB_SPROM4_TXPID2G1_SHIFT);
319 + SPEX(txpid2g[2], SSB_SPROM4_TXPID2G23,
320 + SSB_SPROM4_TXPID2G2, SSB_SPROM4_TXPID2G2_SHIFT);
321 + SPEX(txpid2g[3], SSB_SPROM4_TXPID2G23,
322 + SSB_SPROM4_TXPID2G3, SSB_SPROM4_TXPID2G3_SHIFT);
323 +
324 + SPEX(txpid5gl[0], SSB_SPROM4_TXPID5GL01,
325 + SSB_SPROM4_TXPID5GL0, SSB_SPROM4_TXPID5GL0_SHIFT);
326 + SPEX(txpid5gl[1], SSB_SPROM4_TXPID5GL01,
327 + SSB_SPROM4_TXPID5GL1, SSB_SPROM4_TXPID5GL1_SHIFT);
328 + SPEX(txpid5gl[2], SSB_SPROM4_TXPID5GL23,
329 + SSB_SPROM4_TXPID5GL2, SSB_SPROM4_TXPID5GL2_SHIFT);
330 + SPEX(txpid5gl[3], SSB_SPROM4_TXPID5GL23,
331 + SSB_SPROM4_TXPID5GL3, SSB_SPROM4_TXPID5GL3_SHIFT);
332 +
333 + SPEX(txpid5g[0], SSB_SPROM4_TXPID5G01,
334 + SSB_SPROM4_TXPID5G0, SSB_SPROM4_TXPID5G0_SHIFT);
335 + SPEX(txpid5g[1], SSB_SPROM4_TXPID5G01,
336 + SSB_SPROM4_TXPID5G1, SSB_SPROM4_TXPID5G1_SHIFT);
337 + SPEX(txpid5g[2], SSB_SPROM4_TXPID5G23,
338 + SSB_SPROM4_TXPID5G2, SSB_SPROM4_TXPID5G2_SHIFT);
339 + SPEX(txpid5g[3], SSB_SPROM4_TXPID5G23,
340 + SSB_SPROM4_TXPID5G3, SSB_SPROM4_TXPID5G3_SHIFT);
341 +
342 + SPEX(txpid5gh[0], SSB_SPROM4_TXPID5GH01,
343 + SSB_SPROM4_TXPID5GH0, SSB_SPROM4_TXPID5GH0_SHIFT);
344 + SPEX(txpid5gh[1], SSB_SPROM4_TXPID5GH01,
345 + SSB_SPROM4_TXPID5GH1, SSB_SPROM4_TXPID5GH1_SHIFT);
346 + SPEX(txpid5gh[2], SSB_SPROM4_TXPID5GH23,
347 + SSB_SPROM4_TXPID5GH2, SSB_SPROM4_TXPID5GH2_SHIFT);
348 + SPEX(txpid5gh[3], SSB_SPROM4_TXPID5GH23,
349 + SSB_SPROM4_TXPID5GH3, SSB_SPROM4_TXPID5GH3_SHIFT);
350 +}
351 +
352 static void sprom_extract_r45(struct ssb_sprom *out, const u16 *in)
353 {
354 int i;
355 @@ -428,10 +468,14 @@ static void sprom_extract_r45(struct ssb
356 SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0);
357 SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0);
358 SPEX(boardflags_hi, SSB_SPROM4_BFLHI, 0xFFFF, 0);
359 + SPEX(boardflags2_lo, SSB_SPROM4_BFL2LO, 0xFFFF, 0);
360 + SPEX(boardflags2_hi, SSB_SPROM4_BFL2HI, 0xFFFF, 0);
361 } else {
362 SPEX(country_code, SSB_SPROM5_CCODE, 0xFFFF, 0);
363 SPEX(boardflags_lo, SSB_SPROM5_BFLLO, 0xFFFF, 0);
364 SPEX(boardflags_hi, SSB_SPROM5_BFLHI, 0xFFFF, 0);
365 + SPEX(boardflags2_lo, SSB_SPROM5_BFL2LO, 0xFFFF, 0);
366 + SPEX(boardflags2_hi, SSB_SPROM5_BFL2HI, 0xFFFF, 0);
367 }
368 SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A,
369 SSB_SPROM4_ANTAVAIL_A_SHIFT);
370 @@ -471,6 +515,8 @@ static void sprom_extract_r45(struct ssb
371 memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24,
372 sizeof(out->antenna_gain.ghz5));
373
374 + sprom_extract_r458(out, in);
375 +
376 /* TODO - get remaining rev 4 stuff needed */
377 }
378
379 @@ -561,6 +607,8 @@ static void sprom_extract_r8(struct ssb_
380 memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24,
381 sizeof(out->antenna_gain.ghz5));
382
383 + sprom_extract_r458(out, in);
384 +
385 /* TODO - get remaining rev 8 stuff needed */
386 }
387
388 @@ -573,37 +621,34 @@ static int sprom_extract(struct ssb_bus
389 ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision);
390 memset(out->et0mac, 0xFF, 6); /* preset et0 and et1 mac */
391 memset(out->et1mac, 0xFF, 6);
392 +
393 if ((bus->chip_id & 0xFF00) == 0x4400) {
394 /* Workaround: The BCM44XX chip has a stupid revision
395 * number stored in the SPROM.
396 * Always extract r1. */
397 out->revision = 1;
398 + ssb_dprintk(KERN_DEBUG PFX "SPROM treated as revision %d\n", out->revision);
399 + }
400 +
401 + switch (out->revision) {
402 + case 1:
403 + case 2:
404 + case 3:
405 sprom_extract_r123(out, in);
406 - } else if (bus->chip_id == 0x4321) {
407 - /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */
408 - out->revision = 4;
409 + break;
410 + case 4:
411 + case 5:
412 sprom_extract_r45(out, in);
413 - } else {
414 - switch (out->revision) {
415 - case 1:
416 - case 2:
417 - case 3:
418 - sprom_extract_r123(out, in);
419 - break;
420 - case 4:
421 - case 5:
422 - sprom_extract_r45(out, in);
423 - break;
424 - case 8:
425 - sprom_extract_r8(out, in);
426 - break;
427 - default:
428 - ssb_printk(KERN_WARNING PFX "Unsupported SPROM"
429 - " revision %d detected. Will extract"
430 - " v1\n", out->revision);
431 - out->revision = 1;
432 - sprom_extract_r123(out, in);
433 - }
434 + break;
435 + case 8:
436 + sprom_extract_r8(out, in);
437 + break;
438 + default:
439 + ssb_printk(KERN_WARNING PFX "Unsupported SPROM"
440 + " revision %d detected. Will extract"
441 + " v1\n", out->revision);
442 + out->revision = 1;
443 + sprom_extract_r123(out, in);
444 }
445
446 if (out->boardflags_lo == 0xFFFF)
447 @@ -617,15 +662,14 @@ static int sprom_extract(struct ssb_bus
448 static int ssb_pci_sprom_get(struct ssb_bus *bus,
449 struct ssb_sprom *sprom)
450 {
451 - const struct ssb_sprom *fallback;
452 - int err = -ENOMEM;
453 + int err;
454 u16 *buf;
455
456 if (!ssb_is_sprom_available(bus)) {
457 ssb_printk(KERN_ERR PFX "No SPROM available!\n");
458 return -ENODEV;
459 }
460 - if (bus->chipco.dev) { /* can be unavailible! */
461 + if (bus->chipco.dev) { /* can be unavailable! */
462 /*
463 * get SPROM offset: SSB_SPROM_BASE1 except for
464 * chipcommon rev >= 31 or chip ID is 0x4312 and
465 @@ -645,7 +689,7 @@ static int ssb_pci_sprom_get(struct ssb_
466
467 buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL);
468 if (!buf)
469 - goto out;
470 + return -ENOMEM;
471 bus->sprom_size = SSB_SPROMSIZE_WORDS_R123;
472 sprom_do_read(bus, buf);
473 err = sprom_check_crc(buf, bus->sprom_size);
474 @@ -655,17 +699,24 @@ static int ssb_pci_sprom_get(struct ssb_
475 buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
476 GFP_KERNEL);
477 if (!buf)
478 - goto out;
479 + return -ENOMEM;
480 bus->sprom_size = SSB_SPROMSIZE_WORDS_R4;
481 sprom_do_read(bus, buf);
482 err = sprom_check_crc(buf, bus->sprom_size);
483 if (err) {
484 /* All CRC attempts failed.
485 * Maybe there is no SPROM on the device?
486 - * If we have a fallback, use that. */
487 - fallback = ssb_get_fallback_sprom();
488 - if (fallback) {
489 - memcpy(sprom, fallback, sizeof(*sprom));
490 + * Now we ask the arch code if there is some sprom
491 + * available for this device in some other storage */
492 + err = ssb_fill_sprom_with_fallback(bus, sprom);
493 + if (err) {
494 + ssb_printk(KERN_WARNING PFX "WARNING: Using"
495 + " fallback SPROM failed (err %d)\n",
496 + err);
497 + } else {
498 + ssb_dprintk(KERN_DEBUG PFX "Using SPROM"
499 + " revision %d provided by"
500 + " platform.\n", sprom->revision);
501 err = 0;
502 goto out_free;
503 }
504 @@ -677,19 +728,15 @@ static int ssb_pci_sprom_get(struct ssb_
505
506 out_free:
507 kfree(buf);
508 -out:
509 return err;
510 }
511
512 static void ssb_pci_get_boardinfo(struct ssb_bus *bus,
513 struct ssb_boardinfo *bi)
514 {
515 - pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID,
516 - &bi->vendor);
517 - pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID,
518 - &bi->type);
519 - pci_read_config_word(bus->host_pci, PCI_REVISION_ID,
520 - &bi->rev);
521 + bi->vendor = bus->host_pci->subsystem_vendor;
522 + bi->type = bus->host_pci->subsystem_device;
523 + bi->rev = bus->host_pci->revision;
524 }
525
526 int ssb_pci_get_invariants(struct ssb_bus *bus,
527 --- a/drivers/ssb/pcihost_wrapper.c
528 +++ b/drivers/ssb/pcihost_wrapper.c
529 @@ -53,12 +53,13 @@ static int ssb_pcihost_resume(struct pci
530 # define ssb_pcihost_resume NULL
531 #endif /* CONFIG_PM */
532
533 -static int ssb_pcihost_probe(struct pci_dev *dev,
534 - const struct pci_device_id *id)
535 +static int __devinit ssb_pcihost_probe(struct pci_dev *dev,
536 + const struct pci_device_id *id)
537 {
538 struct ssb_bus *ssb;
539 int err = -ENOMEM;
540 const char *name;
541 + u32 val;
542
543 ssb = kzalloc(sizeof(*ssb), GFP_KERNEL);
544 if (!ssb)
545 @@ -74,6 +75,12 @@ static int ssb_pcihost_probe(struct pci_
546 goto err_pci_disable;
547 pci_set_master(dev);
548
549 + /* Disable the RETRY_TIMEOUT register (0x41) to keep
550 + * PCI Tx retries from interfering with C3 CPU state */
551 + pci_read_config_dword(dev, 0x40, &val);
552 + if ((val & 0x0000ff00) != 0)
553 + pci_write_config_dword(dev, 0x40, val & 0xffff00ff);
554 +
555 err = ssb_bus_pcibus_register(ssb, dev);
556 if (err)
557 goto err_pci_release_regions;
558 @@ -103,7 +110,7 @@ static void ssb_pcihost_remove(struct pc
559 pci_set_drvdata(dev, NULL);
560 }
561
562 -int ssb_pcihost_register(struct pci_driver *driver)
563 +int __devinit ssb_pcihost_register(struct pci_driver *driver)
564 {
565 driver->probe = ssb_pcihost_probe;
566 driver->remove = ssb_pcihost_remove;
567 --- a/drivers/ssb/scan.c
568 +++ b/drivers/ssb/scan.c
569 @@ -258,7 +258,10 @@ static int we_support_multiple_80211_cor
570 #ifdef CONFIG_SSB_PCIHOST
571 if (bus->bustype == SSB_BUSTYPE_PCI) {
572 if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM &&
573 - bus->host_pci->device == 0x4324)
574 + ((bus->host_pci->device == 0x4313) ||
575 + (bus->host_pci->device == 0x431A) ||
576 + (bus->host_pci->device == 0x4321) ||
577 + (bus->host_pci->device == 0x4324)))
578 return 1;
579 }
580 #endif /* CONFIG_SSB_PCIHOST */
581 @@ -307,8 +310,7 @@ int ssb_bus_scan(struct ssb_bus *bus,
582 } else {
583 if (bus->bustype == SSB_BUSTYPE_PCI) {
584 bus->chip_id = pcidev_to_chipid(bus->host_pci);
585 - pci_read_config_word(bus->host_pci, PCI_REVISION_ID,
586 - &bus->chip_rev);
587 + bus->chip_rev = bus->host_pci->revision;
588 bus->chip_package = 0;
589 } else {
590 bus->chip_id = 0x4710;
591 @@ -405,10 +407,10 @@ int ssb_bus_scan(struct ssb_bus *bus,
592 /* Ignore PCI cores on PCI-E cards.
593 * Ignore PCI-E cores on PCI cards. */
594 if (dev->id.coreid == SSB_DEV_PCI) {
595 - if (bus->host_pci->is_pcie)
596 + if (pci_is_pcie(bus->host_pci))
597 continue;
598 } else {
599 - if (!bus->host_pci->is_pcie)
600 + if (!pci_is_pcie(bus->host_pci))
601 continue;
602 }
603 }
604 @@ -420,6 +422,16 @@ int ssb_bus_scan(struct ssb_bus *bus,
605 bus->pcicore.dev = dev;
606 #endif /* CONFIG_SSB_DRIVER_PCICORE */
607 break;
608 + case SSB_DEV_ETHERNET:
609 + if (bus->bustype == SSB_BUSTYPE_PCI) {
610 + if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM &&
611 + (bus->host_pci->device & 0xFF00) == 0x4300) {
612 + /* This is a dangling ethernet core on a
613 + * wireless device. Ignore it. */
614 + continue;
615 + }
616 + }
617 + break;
618 default:
619 break;
620 }
621 --- a/include/linux/ssb/ssb.h
622 +++ b/include/linux/ssb/ssb.h
623 @@ -27,6 +27,8 @@ struct ssb_sprom {
624 u8 et1mdcport; /* MDIO for enet1 */
625 u8 board_rev; /* Board revision number from SPROM. */
626 u8 country_code; /* Country Code */
627 + u16 leddc_on_time; /* LED Powersave Duty Cycle On Count */
628 + u16 leddc_off_time; /* LED Powersave Duty Cycle Off Count */
629 u8 ant_available_a; /* 2GHz antenna available bits (up to 4) */
630 u8 ant_available_bg; /* 5GHz antenna available bits (up to 4) */
631 u16 pa0b0;
632 @@ -55,6 +57,10 @@ struct ssb_sprom {
633 u8 tri5gl; /* 5.2GHz TX isolation */
634 u8 tri5g; /* 5.3GHz TX isolation */
635 u8 tri5gh; /* 5.8GHz TX isolation */
636 + u8 txpid2g[4]; /* 2GHz TX power index */
637 + u8 txpid5gl[4]; /* 4.9 - 5.1GHz TX power index */
638 + u8 txpid5g[4]; /* 5.1 - 5.5GHz TX power index */
639 + u8 txpid5gh[4]; /* 5.5 - ...GHz TX power index */
640 u8 rxpo2g; /* 2GHz RX power offset */
641 u8 rxpo5g; /* 5GHz RX power offset */
642 u8 rssisav2g; /* 2GHz RSSI params */
643 @@ -95,7 +101,7 @@ struct ssb_sprom {
644 struct ssb_boardinfo {
645 u16 vendor;
646 u16 type;
647 - u16 rev;
648 + u8 rev;
649 };
650
651
652 @@ -304,7 +310,7 @@ struct ssb_bus {
653
654 /* ID information about the Chip. */
655 u16 chip_id;
656 - u16 chip_rev;
657 + u8 chip_rev;
658 u16 sprom_offset;
659 u16 sprom_size; /* number of words in sprom */
660 u8 chip_package;
661 @@ -400,7 +406,9 @@ extern bool ssb_is_sprom_available(struc
662
663 /* Set a fallback SPROM.
664 * See kdoc at the function definition for complete documentation. */
665 -extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom);
666 +extern int ssb_arch_register_fallback_sprom(
667 + int (*sprom_callback)(struct ssb_bus *bus,
668 + struct ssb_sprom *out));
669
670 /* Suspend a SSB bus.
671 * Call this from the parent bus suspend routine. */
672 @@ -514,6 +522,7 @@ extern int ssb_bus_may_powerdown(struct
673 * Otherwise static always-on powercontrol will be used. */
674 extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl);
675
676 +extern void ssb_commit_settings(struct ssb_bus *bus);
677
678 /* Various helper functions */
679 extern u32 ssb_admatch_base(u32 adm);
680 --- a/include/linux/ssb/ssb_regs.h
681 +++ b/include/linux/ssb/ssb_regs.h
682 @@ -85,6 +85,8 @@
683 #define SSB_IMSTATE_AP_RSV 0x00000030 /* Reserved */
684 #define SSB_IMSTATE_IBE 0x00020000 /* In Band Error */
685 #define SSB_IMSTATE_TO 0x00040000 /* Timeout */
686 +#define SSB_IMSTATE_BUSY 0x01800000 /* Busy (Backplane rev >= 2.3 only) */
687 +#define SSB_IMSTATE_REJECT 0x02000000 /* Reject (Backplane rev >= 2.3 only) */
688 #define SSB_INTVEC 0x0F94 /* SB Interrupt Mask */
689 #define SSB_INTVEC_PCI 0x00000001 /* Enable interrupts for PCI */
690 #define SSB_INTVEC_ENET0 0x00000002 /* Enable interrupts for enet 0 */
691 @@ -95,9 +97,8 @@
692 #define SSB_INTVEC_ENET1 0x00000040 /* Enable interrupts for enet 1 */
693 #define SSB_TMSLOW 0x0F98 /* SB Target State Low */
694 #define SSB_TMSLOW_RESET 0x00000001 /* Reset */
695 -#define SSB_TMSLOW_REJECT_22 0x00000002 /* Reject (Backplane rev 2.2) */
696 +#define SSB_TMSLOW_REJECT 0x00000002 /* Reject (Standard Backplane) */
697 #define SSB_TMSLOW_REJECT_23 0x00000004 /* Reject (Backplane rev 2.3) */
698 -#define SSB_TMSLOW_PHYCLK 0x00000010 /* MAC PHY Clock Control Enable */
699 #define SSB_TMSLOW_CLOCK 0x00010000 /* Clock Enable */
700 #define SSB_TMSLOW_FGC 0x00020000 /* Force Gated Clocks On */
701 #define SSB_TMSLOW_PE 0x40000000 /* Power Management Enable */
702 @@ -268,6 +269,8 @@
703 /* SPROM Revision 4 */
704 #define SSB_SPROM4_BFLLO 0x0044 /* Boardflags (low 16 bits) */
705 #define SSB_SPROM4_BFLHI 0x0046 /* Board Flags Hi */
706 +#define SSB_SPROM4_BFL2LO 0x0048 /* Board flags 2 (low 16 bits) */
707 +#define SSB_SPROM4_BFL2HI 0x004A /* Board flags 2 Hi */
708 #define SSB_SPROM4_IL0MAC 0x004C /* 6 byte MAC address for a/b/g/n */
709 #define SSB_SPROM4_CCODE 0x0052 /* Country Code (2 bytes) */
710 #define SSB_SPROM4_GPIOA 0x0056 /* Gen. Purpose IO # 0 and 1 */
711 @@ -299,6 +302,46 @@
712 #define SSB_SPROM4_AGAIN2_SHIFT 0
713 #define SSB_SPROM4_AGAIN3 0xFF00 /* Antenna 3 */
714 #define SSB_SPROM4_AGAIN3_SHIFT 8
715 +#define SSB_SPROM4_TXPID2G01 0x0062 /* TX Power Index 2GHz */
716 +#define SSB_SPROM4_TXPID2G0 0x00FF
717 +#define SSB_SPROM4_TXPID2G0_SHIFT 0
718 +#define SSB_SPROM4_TXPID2G1 0xFF00
719 +#define SSB_SPROM4_TXPID2G1_SHIFT 8
720 +#define SSB_SPROM4_TXPID2G23 0x0064 /* TX Power Index 2GHz */
721 +#define SSB_SPROM4_TXPID2G2 0x00FF
722 +#define SSB_SPROM4_TXPID2G2_SHIFT 0
723 +#define SSB_SPROM4_TXPID2G3 0xFF00
724 +#define SSB_SPROM4_TXPID2G3_SHIFT 8
725 +#define SSB_SPROM4_TXPID5G01 0x0066 /* TX Power Index 5GHz middle subband */
726 +#define SSB_SPROM4_TXPID5G0 0x00FF
727 +#define SSB_SPROM4_TXPID5G0_SHIFT 0
728 +#define SSB_SPROM4_TXPID5G1 0xFF00
729 +#define SSB_SPROM4_TXPID5G1_SHIFT 8
730 +#define SSB_SPROM4_TXPID5G23 0x0068 /* TX Power Index 5GHz middle subband */
731 +#define SSB_SPROM4_TXPID5G2 0x00FF
732 +#define SSB_SPROM4_TXPID5G2_SHIFT 0
733 +#define SSB_SPROM4_TXPID5G3 0xFF00
734 +#define SSB_SPROM4_TXPID5G3_SHIFT 8
735 +#define SSB_SPROM4_TXPID5GL01 0x006A /* TX Power Index 5GHz low subband */
736 +#define SSB_SPROM4_TXPID5GL0 0x00FF
737 +#define SSB_SPROM4_TXPID5GL0_SHIFT 0
738 +#define SSB_SPROM4_TXPID5GL1 0xFF00
739 +#define SSB_SPROM4_TXPID5GL1_SHIFT 8
740 +#define SSB_SPROM4_TXPID5GL23 0x006C /* TX Power Index 5GHz low subband */
741 +#define SSB_SPROM4_TXPID5GL2 0x00FF
742 +#define SSB_SPROM4_TXPID5GL2_SHIFT 0
743 +#define SSB_SPROM4_TXPID5GL3 0xFF00
744 +#define SSB_SPROM4_TXPID5GL3_SHIFT 8
745 +#define SSB_SPROM4_TXPID5GH01 0x006E /* TX Power Index 5GHz high subband */
746 +#define SSB_SPROM4_TXPID5GH0 0x00FF
747 +#define SSB_SPROM4_TXPID5GH0_SHIFT 0
748 +#define SSB_SPROM4_TXPID5GH1 0xFF00
749 +#define SSB_SPROM4_TXPID5GH1_SHIFT 8
750 +#define SSB_SPROM4_TXPID5GH23 0x0070 /* TX Power Index 5GHz high subband */
751 +#define SSB_SPROM4_TXPID5GH2 0x00FF
752 +#define SSB_SPROM4_TXPID5GH2_SHIFT 0
753 +#define SSB_SPROM4_TXPID5GH3 0xFF00
754 +#define SSB_SPROM4_TXPID5GH3_SHIFT 8
755 #define SSB_SPROM4_MAXP_BG 0x0080 /* Max Power BG in path 1 */
756 #define SSB_SPROM4_MAXP_BG_MASK 0x00FF /* Mask for Max Power BG */
757 #define SSB_SPROM4_ITSSI_BG 0xFF00 /* Mask for path 1 itssi_bg */
758 @@ -318,6 +361,8 @@
759 #define SSB_SPROM5_CCODE 0x0044 /* Country Code (2 bytes) */
760 #define SSB_SPROM5_BFLLO 0x004A /* Boardflags (low 16 bits) */
761 #define SSB_SPROM5_BFLHI 0x004C /* Board Flags Hi */
762 +#define SSB_SPROM5_BFL2LO 0x004E /* Board flags 2 (low 16 bits) */
763 +#define SSB_SPROM5_BFL2HI 0x0050 /* Board flags 2 Hi */
764 #define SSB_SPROM5_IL0MAC 0x0052 /* 6 byte MAC address for a/b/g/n */
765 #define SSB_SPROM5_GPIOA 0x0076 /* Gen. Purpose IO # 0 and 1 */
766 #define SSB_SPROM5_GPIOA_P0 0x00FF /* Pin 0 */
767 --- a/drivers/ssb/driver_chipcommon.c
768 +++ b/drivers/ssb/driver_chipcommon.c
769 @@ -46,40 +46,66 @@ void ssb_chipco_set_clockmode(struct ssb
770 if (!ccdev)
771 return;
772 bus = ccdev->bus;
773 +
774 + /* We support SLOW only on 6..9 */
775 + if (ccdev->id.revision >= 10 && mode == SSB_CLKMODE_SLOW)
776 + mode = SSB_CLKMODE_DYNAMIC;
777 +
778 + if (cc->capabilities & SSB_CHIPCO_CAP_PMU)
779 + return; /* PMU controls clockmode, separated function needed */
780 + SSB_WARN_ON(ccdev->id.revision >= 20);
781 +
782 /* chipcommon cores prior to rev6 don't support dynamic clock control */
783 if (ccdev->id.revision < 6)
784 return;
785 - /* chipcommon cores rev10 are a whole new ball game */
786 +
787 + /* ChipCommon cores rev10+ need testing */
788 if (ccdev->id.revision >= 10)
789 return;
790 +
791 if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL))
792 return;
793
794 switch (mode) {
795 - case SSB_CLKMODE_SLOW:
796 + case SSB_CLKMODE_SLOW: /* For revs 6..9 only */
797 tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
798 tmp |= SSB_CHIPCO_SLOWCLKCTL_FSLOW;
799 chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
800 break;
801 case SSB_CLKMODE_FAST:
802 - ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */
803 - tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
804 - tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW;
805 - tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL;
806 - chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
807 + if (ccdev->id.revision < 10) {
808 + ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */
809 + tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
810 + tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW;
811 + tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL;
812 + chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
813 + } else {
814 + chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL,
815 + (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) |
816 + SSB_CHIPCO_SYSCLKCTL_FORCEHT));
817 + /* udelay(150); TODO: not available in early init */
818 + }
819 break;
820 case SSB_CLKMODE_DYNAMIC:
821 - tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
822 - tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW;
823 - tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL;
824 - tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL;
825 - if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL)
826 - tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL;
827 - chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
828 -
829 - /* for dynamic control, we have to release our xtal_pu "force on" */
830 - if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL)
831 - ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0);
832 + if (ccdev->id.revision < 10) {
833 + tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
834 + tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW;
835 + tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL;
836 + tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL;
837 + if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) !=
838 + SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL)
839 + tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL;
840 + chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
841 +
842 + /* For dynamic control, we have to release our xtal_pu
843 + * "force on" */
844 + if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL)
845 + ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0);
846 + } else {
847 + chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL,
848 + (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) &
849 + ~SSB_CHIPCO_SYSCLKCTL_FORCEHT));
850 + }
851 break;
852 default:
853 SSB_WARN_ON(1);
854 @@ -260,6 +286,12 @@ void ssb_chipcommon_init(struct ssb_chip
855 if (cc->dev->id.revision >= 11)
856 cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT);
857 ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status);
858 +
859 + if (cc->dev->id.revision >= 20) {
860 + chipco_write32(cc, SSB_CHIPCO_GPIOPULLUP, 0);
861 + chipco_write32(cc, SSB_CHIPCO_GPIOPULLDOWN, 0);
862 + }
863 +
864 ssb_pmu_init(cc);
865 chipco_powercontrol_init(cc);
866 ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST);
867 --- a/drivers/ssb/driver_chipcommon_pmu.c
868 +++ b/drivers/ssb/driver_chipcommon_pmu.c
869 @@ -417,12 +417,14 @@ static void ssb_pmu_resources_init(struc
870 u32 min_msk = 0, max_msk = 0;
871 unsigned int i;
872 const struct pmu_res_updown_tab_entry *updown_tab = NULL;
873 - unsigned int updown_tab_size;
874 + unsigned int updown_tab_size = 0;
875 const struct pmu_res_depend_tab_entry *depend_tab = NULL;
876 - unsigned int depend_tab_size;
877 + unsigned int depend_tab_size = 0;
878
879 switch (bus->chip_id) {
880 case 0x4312:
881 + min_msk = 0xCBB;
882 + break;
883 case 0x4322:
884 /* We keep the default settings:
885 * min_msk = 0xCBB
886 --- a/drivers/ssb/driver_gige.c
887 +++ b/drivers/ssb/driver_gige.c
888 @@ -106,8 +106,9 @@ void gige_pcicfg_write32(struct ssb_gige
889 gige_write32(dev, SSB_GIGE_PCICFG + offset, value);
890 }
891
892 -static int ssb_gige_pci_read_config(struct pci_bus *bus, unsigned int devfn,
893 - int reg, int size, u32 *val)
894 +static int __devinit ssb_gige_pci_read_config(struct pci_bus *bus,
895 + unsigned int devfn, int reg,
896 + int size, u32 *val)
897 {
898 struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops);
899 unsigned long flags;
900 @@ -136,8 +137,9 @@ static int ssb_gige_pci_read_config(stru
901 return PCIBIOS_SUCCESSFUL;
902 }
903
904 -static int ssb_gige_pci_write_config(struct pci_bus *bus, unsigned int devfn,
905 - int reg, int size, u32 val)
906 +static int __devinit ssb_gige_pci_write_config(struct pci_bus *bus,
907 + unsigned int devfn, int reg,
908 + int size, u32 val)
909 {
910 struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops);
911 unsigned long flags;
912 @@ -166,7 +168,8 @@ static int ssb_gige_pci_write_config(str
913 return PCIBIOS_SUCCESSFUL;
914 }
915
916 -static int ssb_gige_probe(struct ssb_device *sdev, const struct ssb_device_id *id)
917 +static int __devinit ssb_gige_probe(struct ssb_device *sdev,
918 + const struct ssb_device_id *id)
919 {
920 struct ssb_gige *dev;
921 u32 base, tmslow, tmshigh;
922 --- a/drivers/ssb/driver_pcicore.c
923 +++ b/drivers/ssb/driver_pcicore.c
924 @@ -15,6 +15,11 @@
925
926 #include "ssb_private.h"
927
928 +static u32 ssb_pcie_read(struct ssb_pcicore *pc, u32 address);
929 +static void ssb_pcie_write(struct ssb_pcicore *pc, u32 address, u32 data);
930 +static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address);
931 +static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device,
932 + u8 address, u16 data);
933
934 static inline
935 u32 pcicore_read32(struct ssb_pcicore *pc, u16 offset)
936 @@ -309,7 +314,7 @@ int ssb_pcicore_pcibios_map_irq(const st
937 return ssb_mips_irq(extpci_core->dev) + 2;
938 }
939
940 -static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc)
941 +static void __devinit ssb_pcicore_init_hostmode(struct ssb_pcicore *pc)
942 {
943 u32 val;
944
945 @@ -374,7 +379,7 @@ static void ssb_pcicore_init_hostmode(st
946 register_pci_controller(&ssb_pcicore_controller);
947 }
948
949 -static int pcicore_is_in_hostmode(struct ssb_pcicore *pc)
950 +static int __devinit pcicore_is_in_hostmode(struct ssb_pcicore *pc)
951 {
952 struct ssb_bus *bus = pc->dev->bus;
953 u16 chipid_top;
954 @@ -403,25 +408,133 @@ static int pcicore_is_in_hostmode(struct
955 }
956 #endif /* CONFIG_SSB_PCICORE_HOSTMODE */
957
958 +/**************************************************
959 + * Workarounds.
960 + **************************************************/
961 +
962 +static void __devinit ssb_pcicore_fix_sprom_core_index(struct ssb_pcicore *pc)
963 +{
964 + u16 tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(0));
965 + if (((tmp & 0xF000) >> 12) != pc->dev->core_index) {
966 + tmp &= ~0xF000;
967 + tmp |= (pc->dev->core_index << 12);
968 + pcicore_write16(pc, SSB_PCICORE_SPROM(0), tmp);
969 + }
970 +}
971 +
972 +static u8 ssb_pcicore_polarity_workaround(struct ssb_pcicore *pc)
973 +{
974 + return (ssb_pcie_read(pc, 0x204) & 0x10) ? 0xC0 : 0x80;
975 +}
976 +
977 +static void ssb_pcicore_serdes_workaround(struct ssb_pcicore *pc)
978 +{
979 + const u8 serdes_pll_device = 0x1D;
980 + const u8 serdes_rx_device = 0x1F;
981 + u16 tmp;
982 +
983 + ssb_pcie_mdio_write(pc, serdes_rx_device, 1 /* Control */,
984 + ssb_pcicore_polarity_workaround(pc));
985 + tmp = ssb_pcie_mdio_read(pc, serdes_pll_device, 1 /* Control */);
986 + if (tmp & 0x4000)
987 + ssb_pcie_mdio_write(pc, serdes_pll_device, 1, tmp & ~0x4000);
988 +}
989 +
990 +static void ssb_pcicore_pci_setup_workarounds(struct ssb_pcicore *pc)
991 +{
992 + struct ssb_device *pdev = pc->dev;
993 + struct ssb_bus *bus = pdev->bus;
994 + u32 tmp;
995 +
996 + tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2);
997 + tmp |= SSB_PCICORE_SBTOPCI_PREF;
998 + tmp |= SSB_PCICORE_SBTOPCI_BURST;
999 + pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp);
1000 +
1001 + if (pdev->id.revision < 5) {
1002 + tmp = ssb_read32(pdev, SSB_IMCFGLO);
1003 + tmp &= ~SSB_IMCFGLO_SERTO;
1004 + tmp |= 2;
1005 + tmp &= ~SSB_IMCFGLO_REQTO;
1006 + tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT;
1007 + ssb_write32(pdev, SSB_IMCFGLO, tmp);
1008 + ssb_commit_settings(bus);
1009 + } else if (pdev->id.revision >= 11) {
1010 + tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2);
1011 + tmp |= SSB_PCICORE_SBTOPCI_MRM;
1012 + pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp);
1013 + }
1014 +}
1015 +
1016 +static void ssb_pcicore_pcie_setup_workarounds(struct ssb_pcicore *pc)
1017 +{
1018 + u32 tmp;
1019 + u8 rev = pc->dev->id.revision;
1020 +
1021 + if (rev == 0 || rev == 1) {
1022 + /* TLP Workaround register. */
1023 + tmp = ssb_pcie_read(pc, 0x4);
1024 + tmp |= 0x8;
1025 + ssb_pcie_write(pc, 0x4, tmp);
1026 + }
1027 + if (rev == 1) {
1028 + /* DLLP Link Control register. */
1029 + tmp = ssb_pcie_read(pc, 0x100);
1030 + tmp |= 0x40;
1031 + ssb_pcie_write(pc, 0x100, tmp);
1032 + }
1033 +
1034 + if (rev == 0) {
1035 + const u8 serdes_rx_device = 0x1F;
1036 +
1037 + ssb_pcie_mdio_write(pc, serdes_rx_device,
1038 + 2 /* Timer */, 0x8128);
1039 + ssb_pcie_mdio_write(pc, serdes_rx_device,
1040 + 6 /* CDR */, 0x0100);
1041 + ssb_pcie_mdio_write(pc, serdes_rx_device,
1042 + 7 /* CDR BW */, 0x1466);
1043 + } else if (rev == 3 || rev == 4 || rev == 5) {
1044 + /* TODO: DLLP Power Management Threshold */
1045 + ssb_pcicore_serdes_workaround(pc);
1046 + /* TODO: ASPM */
1047 + } else if (rev == 7) {
1048 + /* TODO: No PLL down */
1049 + }
1050 +
1051 + if (rev >= 6) {
1052 + /* Miscellaneous Configuration Fixup */
1053 + tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(5));
1054 + if (!(tmp & 0x8000))
1055 + pcicore_write16(pc, SSB_PCICORE_SPROM(5),
1056 + tmp | 0x8000);
1057 + }
1058 +}
1059
1060 /**************************************************
1061 * Generic and Clientmode operation code.
1062 **************************************************/
1063
1064 -static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc)
1065 +static void __devinit ssb_pcicore_init_clientmode(struct ssb_pcicore *pc)
1066 {
1067 + ssb_pcicore_fix_sprom_core_index(pc);
1068 +
1069 /* Disable PCI interrupts. */
1070 ssb_write32(pc->dev, SSB_INTVEC, 0);
1071 +
1072 + /* Additional PCIe always once-executed workarounds */
1073 + if (pc->dev->id.coreid == SSB_DEV_PCIE) {
1074 + ssb_pcicore_serdes_workaround(pc);
1075 + /* TODO: ASPM */
1076 + /* TODO: Clock Request Update */
1077 + }
1078 }
1079
1080 -void ssb_pcicore_init(struct ssb_pcicore *pc)
1081 +void __devinit ssb_pcicore_init(struct ssb_pcicore *pc)
1082 {
1083 struct ssb_device *dev = pc->dev;
1084 - struct ssb_bus *bus;
1085
1086 if (!dev)
1087 return;
1088 - bus = dev->bus;
1089 if (!ssb_device_is_enabled(dev))
1090 ssb_device_enable(dev, 0);
1091
1092 @@ -446,11 +559,35 @@ static void ssb_pcie_write(struct ssb_pc
1093 pcicore_write32(pc, 0x134, data);
1094 }
1095
1096 -static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device,
1097 - u8 address, u16 data)
1098 +static void ssb_pcie_mdio_set_phy(struct ssb_pcicore *pc, u8 phy)
1099 +{
1100 + const u16 mdio_control = 0x128;
1101 + const u16 mdio_data = 0x12C;
1102 + u32 v;
1103 + int i;
1104 +
1105 + v = (1 << 30); /* Start of Transaction */
1106 + v |= (1 << 28); /* Write Transaction */
1107 + v |= (1 << 17); /* Turnaround */
1108 + v |= (0x1F << 18);
1109 + v |= (phy << 4);
1110 + pcicore_write32(pc, mdio_data, v);
1111 +
1112 + udelay(10);
1113 + for (i = 0; i < 200; i++) {
1114 + v = pcicore_read32(pc, mdio_control);
1115 + if (v & 0x100 /* Trans complete */)
1116 + break;
1117 + msleep(1);
1118 + }
1119 +}
1120 +
1121 +static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address)
1122 {
1123 const u16 mdio_control = 0x128;
1124 const u16 mdio_data = 0x12C;
1125 + int max_retries = 10;
1126 + u16 ret = 0;
1127 u32 v;
1128 int i;
1129
1130 @@ -458,46 +595,68 @@ static void ssb_pcie_mdio_write(struct s
1131 v |= 0x2; /* MDIO Clock Divisor */
1132 pcicore_write32(pc, mdio_control, v);
1133
1134 + if (pc->dev->id.revision >= 10) {
1135 + max_retries = 200;
1136 + ssb_pcie_mdio_set_phy(pc, device);
1137 + }
1138 +
1139 v = (1 << 30); /* Start of Transaction */
1140 - v |= (1 << 28); /* Write Transaction */
1141 + v |= (1 << 29); /* Read Transaction */
1142 v |= (1 << 17); /* Turnaround */
1143 - v |= (u32)device << 22;
1144 + if (pc->dev->id.revision < 10)
1145 + v |= (u32)device << 22;
1146 v |= (u32)address << 18;
1147 - v |= data;
1148 pcicore_write32(pc, mdio_data, v);
1149 /* Wait for the device to complete the transaction */
1150 udelay(10);
1151 - for (i = 0; i < 10; i++) {
1152 + for (i = 0; i < max_retries; i++) {
1153 v = pcicore_read32(pc, mdio_control);
1154 - if (v & 0x100 /* Trans complete */)
1155 + if (v & 0x100 /* Trans complete */) {
1156 + udelay(10);
1157 + ret = pcicore_read32(pc, mdio_data);
1158 break;
1159 + }
1160 msleep(1);
1161 }
1162 pcicore_write32(pc, mdio_control, 0);
1163 + return ret;
1164 }
1165
1166 -static void ssb_broadcast_value(struct ssb_device *dev,
1167 - u32 address, u32 data)
1168 +static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device,
1169 + u8 address, u16 data)
1170 {
1171 - /* This is used for both, PCI and ChipCommon core, so be careful. */
1172 - BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR);
1173 - BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA);
1174 + const u16 mdio_control = 0x128;
1175 + const u16 mdio_data = 0x12C;
1176 + int max_retries = 10;
1177 + u32 v;
1178 + int i;
1179
1180 - ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address);
1181 - ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */
1182 - ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data);
1183 - ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */
1184 -}
1185 + v = 0x80; /* Enable Preamble Sequence */
1186 + v |= 0x2; /* MDIO Clock Divisor */
1187 + pcicore_write32(pc, mdio_control, v);
1188
1189 -static void ssb_commit_settings(struct ssb_bus *bus)
1190 -{
1191 - struct ssb_device *dev;
1192 + if (pc->dev->id.revision >= 10) {
1193 + max_retries = 200;
1194 + ssb_pcie_mdio_set_phy(pc, device);
1195 + }
1196
1197 - dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev;
1198 - if (WARN_ON(!dev))
1199 - return;
1200 - /* This forces an update of the cached registers. */
1201 - ssb_broadcast_value(dev, 0xFD8, 0);
1202 + v = (1 << 30); /* Start of Transaction */
1203 + v |= (1 << 28); /* Write Transaction */
1204 + v |= (1 << 17); /* Turnaround */
1205 + if (pc->dev->id.revision < 10)
1206 + v |= (u32)device << 22;
1207 + v |= (u32)address << 18;
1208 + v |= data;
1209 + pcicore_write32(pc, mdio_data, v);
1210 + /* Wait for the device to complete the transaction */
1211 + udelay(10);
1212 + for (i = 0; i < max_retries; i++) {
1213 + v = pcicore_read32(pc, mdio_control);
1214 + if (v & 0x100 /* Trans complete */)
1215 + break;
1216 + msleep(1);
1217 + }
1218 + pcicore_write32(pc, mdio_control, 0);
1219 }
1220
1221 int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc,
1222 @@ -550,48 +709,10 @@ int ssb_pcicore_dev_irqvecs_enable(struc
1223 if (pc->setup_done)
1224 goto out;
1225 if (pdev->id.coreid == SSB_DEV_PCI) {
1226 - tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2);
1227 - tmp |= SSB_PCICORE_SBTOPCI_PREF;
1228 - tmp |= SSB_PCICORE_SBTOPCI_BURST;
1229 - pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp);
1230 -
1231 - if (pdev->id.revision < 5) {
1232 - tmp = ssb_read32(pdev, SSB_IMCFGLO);
1233 - tmp &= ~SSB_IMCFGLO_SERTO;
1234 - tmp |= 2;
1235 - tmp &= ~SSB_IMCFGLO_REQTO;
1236 - tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT;
1237 - ssb_write32(pdev, SSB_IMCFGLO, tmp);
1238 - ssb_commit_settings(bus);
1239 - } else if (pdev->id.revision >= 11) {
1240 - tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2);
1241 - tmp |= SSB_PCICORE_SBTOPCI_MRM;
1242 - pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp);
1243 - }
1244 + ssb_pcicore_pci_setup_workarounds(pc);
1245 } else {
1246 WARN_ON(pdev->id.coreid != SSB_DEV_PCIE);
1247 - //TODO: Better make defines for all these magic PCIE values.
1248 - if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) {
1249 - /* TLP Workaround register. */
1250 - tmp = ssb_pcie_read(pc, 0x4);
1251 - tmp |= 0x8;
1252 - ssb_pcie_write(pc, 0x4, tmp);
1253 - }
1254 - if (pdev->id.revision == 0) {
1255 - const u8 serdes_rx_device = 0x1F;
1256 -
1257 - ssb_pcie_mdio_write(pc, serdes_rx_device,
1258 - 2 /* Timer */, 0x8128);
1259 - ssb_pcie_mdio_write(pc, serdes_rx_device,
1260 - 6 /* CDR */, 0x0100);
1261 - ssb_pcie_mdio_write(pc, serdes_rx_device,
1262 - 7 /* CDR BW */, 0x1466);
1263 - } else if (pdev->id.revision == 1) {
1264 - /* DLLP Link Control register. */
1265 - tmp = ssb_pcie_read(pc, 0x100);
1266 - tmp |= 0x40;
1267 - ssb_pcie_write(pc, 0x100, tmp);
1268 - }
1269 + ssb_pcicore_pcie_setup_workarounds(pc);
1270 }
1271 pc->setup_done = 1;
1272 out:
1273 --- a/drivers/ssb/sprom.c
1274 +++ b/drivers/ssb/sprom.c
1275 @@ -17,7 +17,7 @@
1276 #include <linux/slab.h>
1277
1278
1279 -static const struct ssb_sprom *fallback_sprom;
1280 +static int(*get_fallback_sprom)(struct ssb_bus *dev, struct ssb_sprom *out);
1281
1282
1283 static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len,
1284 @@ -145,36 +145,43 @@ out:
1285 }
1286
1287 /**
1288 - * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found.
1289 + * ssb_arch_register_fallback_sprom - Registers a method providing a
1290 + * fallback SPROM if no SPROM is found.
1291 *
1292 - * @sprom: The SPROM data structure to register.
1293 + * @sprom_callback: The callback function.
1294 *
1295 - * With this function the architecture implementation may register a fallback
1296 - * SPROM data structure. The fallback is only used for PCI based SSB devices,
1297 - * where no valid SPROM can be found in the shadow registers.
1298 + * With this function the architecture implementation may register a
1299 + * callback handler which fills the SPROM data structure. The fallback is
1300 + * only used for PCI based SSB devices, where no valid SPROM can be found
1301 + * in the shadow registers.
1302 *
1303 - * This function is useful for weird architectures that have a half-assed SSB device
1304 - * hardwired to their PCI bus.
1305 + * This function is useful for weird architectures that have a half-assed
1306 + * SSB device hardwired to their PCI bus.
1307 *
1308 - * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently
1309 - * don't use this fallback.
1310 - * Architectures must provide the SPROM for native SSB devices anyway,
1311 - * so the fallback also isn't used for native devices.
1312 + * Note that it does only work with PCI attached SSB devices. PCMCIA
1313 + * devices currently don't use this fallback.
1314 + * Architectures must provide the SPROM for native SSB devices anyway, so
1315 + * the fallback also isn't used for native devices.
1316 *
1317 - * This function is available for architecture code, only. So it is not exported.
1318 + * This function is available for architecture code, only. So it is not
1319 + * exported.
1320 */
1321 -int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom)
1322 +int ssb_arch_register_fallback_sprom(int (*sprom_callback)(struct ssb_bus *bus,
1323 + struct ssb_sprom *out))
1324 {
1325 - if (fallback_sprom)
1326 + if (get_fallback_sprom)
1327 return -EEXIST;
1328 - fallback_sprom = sprom;
1329 + get_fallback_sprom = sprom_callback;
1330
1331 return 0;
1332 }
1333
1334 -const struct ssb_sprom *ssb_get_fallback_sprom(void)
1335 +int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, struct ssb_sprom *out)
1336 {
1337 - return fallback_sprom;
1338 + if (!get_fallback_sprom)
1339 + return -ENOENT;
1340 +
1341 + return get_fallback_sprom(bus, out);
1342 }
1343
1344 /* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */
1345 @@ -185,7 +192,7 @@ bool ssb_is_sprom_available(struct ssb_b
1346 /* this routine differs from specs as we do not access SPROM directly
1347 on PCMCIA */
1348 if (bus->bustype == SSB_BUSTYPE_PCI &&
1349 - bus->chipco.dev && /* can be unavailible! */
1350 + bus->chipco.dev && /* can be unavailable! */
1351 bus->chipco.dev->id.revision >= 31)
1352 return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM;
1353
1354 --- a/drivers/ssb/ssb_private.h
1355 +++ b/drivers/ssb/ssb_private.h
1356 @@ -171,7 +171,8 @@ ssize_t ssb_attr_sprom_store(struct ssb_
1357 const char *buf, size_t count,
1358 int (*sprom_check_crc)(const u16 *sprom, size_t size),
1359 int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom));
1360 -extern const struct ssb_sprom *ssb_get_fallback_sprom(void);
1361 +extern int ssb_fill_sprom_with_fallback(struct ssb_bus *bus,
1362 + struct ssb_sprom *out);
1363
1364
1365 /* core.c */
1366 --- a/include/linux/ssb/ssb_driver_chipcommon.h
1367 +++ b/include/linux/ssb/ssb_driver_chipcommon.h
1368 @@ -123,6 +123,8 @@
1369 #define SSB_CHIPCO_FLASHDATA 0x0048
1370 #define SSB_CHIPCO_BCAST_ADDR 0x0050
1371 #define SSB_CHIPCO_BCAST_DATA 0x0054
1372 +#define SSB_CHIPCO_GPIOPULLUP 0x0058 /* Rev >= 20 only */
1373 +#define SSB_CHIPCO_GPIOPULLDOWN 0x005C /* Rev >= 20 only */
1374 #define SSB_CHIPCO_GPIOIN 0x0060
1375 #define SSB_CHIPCO_GPIOOUT 0x0064
1376 #define SSB_CHIPCO_GPIOOUTEN 0x0068
1377 @@ -131,6 +133,9 @@
1378 #define SSB_CHIPCO_GPIOIRQ 0x0074
1379 #define SSB_CHIPCO_WATCHDOG 0x0080
1380 #define SSB_CHIPCO_GPIOTIMER 0x0088 /* LED powersave (corerev >= 16) */
1381 +#define SSB_CHIPCO_GPIOTIMER_OFFTIME 0x0000FFFF
1382 +#define SSB_CHIPCO_GPIOTIMER_OFFTIME_SHIFT 0
1383 +#define SSB_CHIPCO_GPIOTIMER_ONTIME 0xFFFF0000
1384 #define SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT 16
1385 #define SSB_CHIPCO_GPIOTOUTM 0x008C /* LED powersave (corerev >= 16) */
1386 #define SSB_CHIPCO_CLOCK_N 0x0090
1387 @@ -189,8 +194,10 @@
1388 #define SSB_CHIPCO_CLKCTLST_HAVEALPREQ 0x00000008 /* ALP available request */
1389 #define SSB_CHIPCO_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */
1390 #define SSB_CHIPCO_CLKCTLST_HWCROFF 0x00000020 /* Force HW clock request off */
1391 -#define SSB_CHIPCO_CLKCTLST_HAVEHT 0x00010000 /* HT available */
1392 -#define SSB_CHIPCO_CLKCTLST_HAVEALP 0x00020000 /* APL available */
1393 +#define SSB_CHIPCO_CLKCTLST_HAVEALP 0x00010000 /* ALP available */
1394 +#define SSB_CHIPCO_CLKCTLST_HAVEHT 0x00020000 /* HT available */
1395 +#define SSB_CHIPCO_CLKCTLST_4328A0_HAVEHT 0x00010000 /* 4328a0 has reversed bits */
1396 +#define SSB_CHIPCO_CLKCTLST_4328A0_HAVEALP 0x00020000 /* 4328a0 has reversed bits */
1397 #define SSB_CHIPCO_HW_WORKAROUND 0x01E4 /* Hardware workaround (rev >= 20) */
1398 #define SSB_CHIPCO_UART0_DATA 0x0300
1399 #define SSB_CHIPCO_UART0_IMR 0x0304
Personal OpenWRT clone
This page took 0.106533 seconds and 3 git commands to generate.