projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ramips: add support for unbranded XDX-RN502J board
[openwrt.git] / target / linux / generic / patches-3.0 / 025-bcma_backport.patch
1 --- a/drivers/bcma/Kconfig
2 +++ b/drivers/bcma/Kconfig
3 @@ -13,6 +13,11 @@ config BCMA
4 Bus driver for Broadcom specific Advanced Microcontroller Bus
5 Architecture.
6
7 +# Support for Block-I/O. SELECT this from the driver that needs it.
8 +config BCMA_BLOCKIO
9 + bool
10 + depends on BCMA
11 +
12 config BCMA_HOST_PCI_POSSIBLE
13 bool
14 depends on BCMA && PCI = y
15 @@ -22,6 +27,25 @@ config BCMA_HOST_PCI
16 bool "Support for BCMA on PCI-host bus"
17 depends on BCMA_HOST_PCI_POSSIBLE
18
19 +config BCMA_DRIVER_PCI_HOSTMODE
20 + bool "Driver for PCI core working in hostmode"
21 + depends on BCMA && MIPS
22 + help
23 + PCI core hostmode operation (external PCI bus).
24 +
25 +config BCMA_HOST_SOC
26 + bool
27 + depends on BCMA_DRIVER_MIPS
28 +
29 +config BCMA_DRIVER_MIPS
30 + bool "BCMA Broadcom MIPS core driver"
31 + depends on BCMA && MIPS
32 + help
33 + Driver for the Broadcom MIPS core attached to Broadcom specific
34 + Advanced Microcontroller Bus.
35 +
36 + If unsure, say N
37 +
38 config BCMA_DEBUG
39 bool "BCMA debugging"
40 depends on BCMA
41 --- a/drivers/bcma/Makefile
42 +++ b/drivers/bcma/Makefile
43 @@ -1,7 +1,10 @@
44 -bcma-y += main.o scan.o core.o
45 +bcma-y += main.o scan.o core.o sprom.o
46 bcma-y += driver_chipcommon.o driver_chipcommon_pmu.o
47 bcma-y += driver_pci.o
48 +bcma-$(CONFIG_BCMA_DRIVER_PCI_HOSTMODE) += driver_pci_host.o
49 +bcma-$(CONFIG_BCMA_DRIVER_MIPS) += driver_mips.o
50 bcma-$(CONFIG_BCMA_HOST_PCI) += host_pci.o
51 +bcma-$(CONFIG_BCMA_HOST_SOC) += host_soc.o
52 obj-$(CONFIG_BCMA) += bcma.o
53
54 ccflags-$(CONFIG_BCMA_DEBUG) := -DDEBUG
55 --- a/drivers/bcma/bcma_private.h
56 +++ b/drivers/bcma/bcma_private.h
57 @@ -13,11 +13,33 @@
58 struct bcma_bus;
59
60 /* main.c */
61 -extern int bcma_bus_register(struct bcma_bus *bus);
62 -extern void bcma_bus_unregister(struct bcma_bus *bus);
63 +int bcma_bus_register(struct bcma_bus *bus);
64 +void bcma_bus_unregister(struct bcma_bus *bus);
65 +int __init bcma_bus_early_register(struct bcma_bus *bus,
66 + struct bcma_device *core_cc,
67 + struct bcma_device *core_mips);
68 +#ifdef CONFIG_PM
69 +int bcma_bus_resume(struct bcma_bus *bus);
70 +#endif
71
72 /* scan.c */
73 int bcma_bus_scan(struct bcma_bus *bus);
74 +int __init bcma_bus_scan_early(struct bcma_bus *bus,
75 + struct bcma_device_id *match,
76 + struct bcma_device *core);
77 +void bcma_init_bus(struct bcma_bus *bus);
78 +
79 +/* sprom.c */
80 +int bcma_sprom_get(struct bcma_bus *bus);
81 +
82 +/* driver_chipcommon.c */
83 +#ifdef CONFIG_BCMA_DRIVER_MIPS
84 +void bcma_chipco_serial_init(struct bcma_drv_cc *cc);
85 +#endif /* CONFIG_BCMA_DRIVER_MIPS */
86 +
87 +/* driver_chipcommon_pmu.c */
88 +u32 bcma_pmu_alp_clock(struct bcma_drv_cc *cc);
89 +u32 bcma_pmu_get_clockcpu(struct bcma_drv_cc *cc);
90
91 #ifdef CONFIG_BCMA_HOST_PCI
92 /* host_pci.c */
93 @@ -25,4 +47,8 @@ extern int __init bcma_host_pci_init(voi
94 extern void __exit bcma_host_pci_exit(void);
95 #endif /* CONFIG_BCMA_HOST_PCI */
96
97 +#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
98 +void bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc);
99 +#endif /* CONFIG_BCMA_DRIVER_PCI_HOSTMODE */
100 +
101 #endif
102 --- a/drivers/bcma/core.c
103 +++ b/drivers/bcma/core.c
104 @@ -19,7 +19,7 @@ bool bcma_core_is_enabled(struct bcma_de
105 }
106 EXPORT_SYMBOL_GPL(bcma_core_is_enabled);
107
108 -static void bcma_core_disable(struct bcma_device *core, u32 flags)
109 +void bcma_core_disable(struct bcma_device *core, u32 flags)
110 {
111 if (bcma_aread32(core, BCMA_RESET_CTL) & BCMA_RESET_CTL_RESET)
112 return;
113 @@ -31,6 +31,7 @@ static void bcma_core_disable(struct bcm
114 bcma_awrite32(core, BCMA_RESET_CTL, BCMA_RESET_CTL_RESET);
115 udelay(1);
116 }
117 +EXPORT_SYMBOL_GPL(bcma_core_disable);
118
119 int bcma_core_enable(struct bcma_device *core, u32 flags)
120 {
121 @@ -49,3 +50,77 @@ int bcma_core_enable(struct bcma_device
122 return 0;
123 }
124 EXPORT_SYMBOL_GPL(bcma_core_enable);
125 +
126 +void bcma_core_set_clockmode(struct bcma_device *core,
127 + enum bcma_clkmode clkmode)
128 +{
129 + u16 i;
130 +
131 + WARN_ON(core->id.id != BCMA_CORE_CHIPCOMMON &&
132 + core->id.id != BCMA_CORE_PCIE &&
133 + core->id.id != BCMA_CORE_80211);
134 +
135 + switch (clkmode) {
136 + case BCMA_CLKMODE_FAST:
137 + bcma_set32(core, BCMA_CLKCTLST, BCMA_CLKCTLST_FORCEHT);
138 + udelay(64);
139 + for (i = 0; i < 1500; i++) {
140 + if (bcma_read32(core, BCMA_CLKCTLST) &
141 + BCMA_CLKCTLST_HAVEHT) {
142 + i = 0;
143 + break;
144 + }
145 + udelay(10);
146 + }
147 + if (i)
148 + pr_err("HT force timeout\n");
149 + break;
150 + case BCMA_CLKMODE_DYNAMIC:
151 + pr_warn("Dynamic clockmode not supported yet!\n");
152 + break;
153 + }
154 +}
155 +EXPORT_SYMBOL_GPL(bcma_core_set_clockmode);
156 +
157 +void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status, bool on)
158 +{
159 + u16 i;
160 +
161 + WARN_ON(req & ~BCMA_CLKCTLST_EXTRESREQ);
162 + WARN_ON(status & ~BCMA_CLKCTLST_EXTRESST);
163 +
164 + if (on) {
165 + bcma_set32(core, BCMA_CLKCTLST, req);
166 + for (i = 0; i < 10000; i++) {
167 + if ((bcma_read32(core, BCMA_CLKCTLST) & status) ==
168 + status) {
169 + i = 0;
170 + break;
171 + }
172 + udelay(10);
173 + }
174 + if (i)
175 + pr_err("PLL enable timeout\n");
176 + } else {
177 + pr_warn("Disabling PLL not supported yet!\n");
178 + }
179 +}
180 +EXPORT_SYMBOL_GPL(bcma_core_pll_ctl);
181 +
182 +u32 bcma_core_dma_translation(struct bcma_device *core)
183 +{
184 + switch (core->bus->hosttype) {
185 + case BCMA_HOSTTYPE_SOC:
186 + return 0;
187 + case BCMA_HOSTTYPE_PCI:
188 + if (bcma_aread32(core, BCMA_IOST) & BCMA_IOST_DMA64)
189 + return BCMA_DMA_TRANSLATION_DMA64_CMT;
190 + else
191 + return BCMA_DMA_TRANSLATION_DMA32_CMT;
192 + default:
193 + pr_err("DMA translation unknown for host %d\n",
194 + core->bus->hosttype);
195 + }
196 + return BCMA_DMA_TRANSLATION_NONE;
197 +}
198 +EXPORT_SYMBOL(bcma_core_dma_translation);
199 --- a/drivers/bcma/driver_chipcommon.c
200 +++ b/drivers/bcma/driver_chipcommon.c
201 @@ -3,7 +3,7 @@
202 * ChipCommon core driver
203 *
204 * Copyright 2005, Broadcom Corporation
205 - * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
206 + * Copyright 2006, 2007, Michael Buesch <m@bues.ch>
207 *
208 * Licensed under the GNU/GPL. See COPYING for details.
209 */
210 @@ -23,6 +23,12 @@ static inline u32 bcma_cc_write32_masked
211
212 void bcma_core_chipcommon_init(struct bcma_drv_cc *cc)
213 {
214 + u32 leddc_on = 10;
215 + u32 leddc_off = 90;
216 +
217 + if (cc->setup_done)
218 + return;
219 +
220 if (cc->core->id.rev >= 11)
221 cc->status = bcma_cc_read32(cc, BCMA_CC_CHIPSTAT);
222 cc->capabilities = bcma_cc_read32(cc, BCMA_CC_CAP);
223 @@ -38,6 +44,19 @@ void bcma_core_chipcommon_init(struct bc
224 bcma_pmu_init(cc);
225 if (cc->capabilities & BCMA_CC_CAP_PCTL)
226 pr_err("Power control not implemented!\n");
227 +
228 + if (cc->core->id.rev >= 16) {
229 + if (cc->core->bus->sprom.leddc_on_time &&
230 + cc->core->bus->sprom.leddc_off_time) {
231 + leddc_on = cc->core->bus->sprom.leddc_on_time;
232 + leddc_off = cc->core->bus->sprom.leddc_off_time;
233 + }
234 + bcma_cc_write32(cc, BCMA_CC_GPIOTIMER,
235 + ((leddc_on << BCMA_CC_GPIOTIMER_ONTIME_SHIFT) |
236 + (leddc_off << BCMA_CC_GPIOTIMER_OFFTIME_SHIFT)));
237 + }
238 +
239 + cc->setup_done = true;
240 }
241
242 /* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */
243 @@ -87,3 +106,51 @@ u32 bcma_chipco_gpio_polarity(struct bcm
244 {
245 return bcma_cc_write32_masked(cc, BCMA_CC_GPIOPOL, mask, value);
246 }
247 +
248 +#ifdef CONFIG_BCMA_DRIVER_MIPS
249 +void bcma_chipco_serial_init(struct bcma_drv_cc *cc)
250 +{
251 + unsigned int irq;
252 + u32 baud_base;
253 + u32 i;
254 + unsigned int ccrev = cc->core->id.rev;
255 + struct bcma_serial_port *ports = cc->serial_ports;
256 +
257 + if (ccrev >= 11 && ccrev != 15) {
258 + /* Fixed ALP clock */
259 + baud_base = bcma_pmu_alp_clock(cc);
260 + if (ccrev >= 21) {
261 + /* Turn off UART clock before switching clocksource. */
262 + bcma_cc_write32(cc, BCMA_CC_CORECTL,
263 + bcma_cc_read32(cc, BCMA_CC_CORECTL)
264 + & ~BCMA_CC_CORECTL_UARTCLKEN);
265 + }
266 + /* Set the override bit so we don't divide it */
267 + bcma_cc_write32(cc, BCMA_CC_CORECTL,
268 + bcma_cc_read32(cc, BCMA_CC_CORECTL)
269 + | BCMA_CC_CORECTL_UARTCLK0);
270 + if (ccrev >= 21) {
271 + /* Re-enable the UART clock. */
272 + bcma_cc_write32(cc, BCMA_CC_CORECTL,
273 + bcma_cc_read32(cc, BCMA_CC_CORECTL)
274 + | BCMA_CC_CORECTL_UARTCLKEN);
275 + }
276 + } else {
277 + pr_err("serial not supported on this device ccrev: 0x%x\n",
278 + ccrev);
279 + return;
280 + }
281 +
282 + irq = bcma_core_mips_irq(cc->core);
283 +
284 + /* Determine the registers of the UARTs */
285 + cc->nr_serial_ports = (cc->capabilities & BCMA_CC_CAP_NRUART);
286 + for (i = 0; i < cc->nr_serial_ports; i++) {
287 + ports[i].regs = cc->core->io_addr + BCMA_CC_UART0_DATA +
288 + (i * 256);
289 + ports[i].irq = irq;
290 + ports[i].baud_base = baud_base;
291 + ports[i].reg_shift = 0;
292 + }
293 +}
294 +#endif /* CONFIG_BCMA_DRIVER_MIPS */
295 --- a/drivers/bcma/driver_chipcommon_pmu.c
296 +++ b/drivers/bcma/driver_chipcommon_pmu.c
297 @@ -2,7 +2,7 @@
298 * Broadcom specific AMBA
299 * ChipCommon Power Management Unit driver
300 *
301 - * Copyright 2009, Michael Buesch <mb@bu3sch.de>
302 + * Copyright 2009, Michael Buesch <m@bues.ch>
303 * Copyright 2007, Broadcom Corporation
304 *
305 * Licensed under the GNU/GPL. See COPYING for details.
306 @@ -11,20 +11,47 @@
307 #include "bcma_private.h"
308 #include <linux/bcma/bcma.h>
309
310 -static void bcma_chipco_chipctl_maskset(struct bcma_drv_cc *cc,
311 - u32 offset, u32 mask, u32 set)
312 +static u32 bcma_chipco_pll_read(struct bcma_drv_cc *cc, u32 offset)
313 {
314 - u32 value;
315 + bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR, offset);
316 + bcma_cc_read32(cc, BCMA_CC_PLLCTL_ADDR);
317 + return bcma_cc_read32(cc, BCMA_CC_PLLCTL_DATA);
318 +}
319
320 - bcma_cc_read32(cc, BCMA_CC_CHIPCTL_ADDR);
321 +void bcma_chipco_pll_write(struct bcma_drv_cc *cc, u32 offset, u32 value)
322 +{
323 + bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR, offset);
324 + bcma_cc_read32(cc, BCMA_CC_PLLCTL_ADDR);
325 + bcma_cc_write32(cc, BCMA_CC_PLLCTL_DATA, value);
326 +}
327 +EXPORT_SYMBOL_GPL(bcma_chipco_pll_write);
328 +
329 +void bcma_chipco_pll_maskset(struct bcma_drv_cc *cc, u32 offset, u32 mask,
330 + u32 set)
331 +{
332 + bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR, offset);
333 + bcma_cc_read32(cc, BCMA_CC_PLLCTL_ADDR);
334 + bcma_cc_maskset32(cc, BCMA_CC_PLLCTL_DATA, mask, set);
335 +}
336 +EXPORT_SYMBOL_GPL(bcma_chipco_pll_maskset);
337 +
338 +void bcma_chipco_chipctl_maskset(struct bcma_drv_cc *cc,
339 + u32 offset, u32 mask, u32 set)
340 +{
341 bcma_cc_write32(cc, BCMA_CC_CHIPCTL_ADDR, offset);
342 bcma_cc_read32(cc, BCMA_CC_CHIPCTL_ADDR);
343 - value = bcma_cc_read32(cc, BCMA_CC_CHIPCTL_DATA);
344 - value &= mask;
345 - value |= set;
346 - bcma_cc_write32(cc, BCMA_CC_CHIPCTL_DATA, value);
347 - bcma_cc_read32(cc, BCMA_CC_CHIPCTL_DATA);
348 + bcma_cc_maskset32(cc, BCMA_CC_CHIPCTL_DATA, mask, set);
349 +}
350 +EXPORT_SYMBOL_GPL(bcma_chipco_chipctl_maskset);
351 +
352 +void bcma_chipco_regctl_maskset(struct bcma_drv_cc *cc, u32 offset, u32 mask,
353 + u32 set)
354 +{
355 + bcma_cc_write32(cc, BCMA_CC_REGCTL_ADDR, offset);
356 + bcma_cc_read32(cc, BCMA_CC_REGCTL_ADDR);
357 + bcma_cc_maskset32(cc, BCMA_CC_REGCTL_DATA, mask, set);
358 }
359 +EXPORT_SYMBOL_GPL(bcma_chipco_regctl_maskset);
360
361 static void bcma_pmu_pll_init(struct bcma_drv_cc *cc)
362 {
363 @@ -53,6 +80,7 @@ static void bcma_pmu_resources_init(stru
364 max_msk = 0xFFFF;
365 break;
366 case 43224:
367 + case 43225:
368 break;
369 default:
370 pr_err("PMU resource config unknown for device 0x%04X\n",
371 @@ -74,6 +102,7 @@ void bcma_pmu_swreg_init(struct bcma_drv
372 case 0x4313:
373 case 0x4331:
374 case 43224:
375 + case 43225:
376 break;
377 default:
378 pr_err("PMU switch/regulators init unknown for device "
379 @@ -81,6 +110,24 @@ void bcma_pmu_swreg_init(struct bcma_drv
380 }
381 }
382
383 +/* Disable to allow reading SPROM. Don't know the adventages of enabling it. */
384 +void bcma_chipco_bcm4331_ext_pa_lines_ctl(struct bcma_drv_cc *cc, bool enable)
385 +{
386 + struct bcma_bus *bus = cc->core->bus;
387 + u32 val;
388 +
389 + val = bcma_cc_read32(cc, BCMA_CC_CHIPCTL);
390 + if (enable) {
391 + val |= BCMA_CHIPCTL_4331_EXTPA_EN;
392 + if (bus->chipinfo.pkg == 9 || bus->chipinfo.pkg == 11)
393 + val |= BCMA_CHIPCTL_4331_EXTPA_ON_GPIO2_5;
394 + } else {
395 + val &= ~BCMA_CHIPCTL_4331_EXTPA_EN;
396 + val &= ~BCMA_CHIPCTL_4331_EXTPA_ON_GPIO2_5;
397 + }
398 + bcma_cc_write32(cc, BCMA_CC_CHIPCTL, val);
399 +}
400 +
401 void bcma_pmu_workarounds(struct bcma_drv_cc *cc)
402 {
403 struct bcma_bus *bus = cc->core->bus;
404 @@ -90,17 +137,19 @@ void bcma_pmu_workarounds(struct bcma_dr
405 bcma_chipco_chipctl_maskset(cc, 0, ~0, 0x7);
406 break;
407 case 0x4331:
408 - pr_err("Enabling Ext PA lines not implemented\n");
409 + /* BCM4331 workaround is SPROM-related, we put it in sprom.c */
410 break;
411 case 43224:
412 if (bus->chipinfo.rev == 0) {
413 pr_err("Workarounds for 43224 rev 0 not fully "
414 "implemented\n");
415 - bcma_chipco_chipctl_maskset(cc, 0, ~0, 0xF0);
416 + bcma_chipco_chipctl_maskset(cc, 0, ~0, 0x00F000F0);
417 } else {
418 bcma_chipco_chipctl_maskset(cc, 0, ~0, 0xF0);
419 }
420 break;
421 + case 43225:
422 + break;
423 default:
424 pr_err("Workarounds unknown for device 0x%04X\n",
425 bus->chipinfo.id);
426 @@ -132,3 +181,129 @@ void bcma_pmu_init(struct bcma_drv_cc *c
427 bcma_pmu_swreg_init(cc);
428 bcma_pmu_workarounds(cc);
429 }
430 +
431 +u32 bcma_pmu_alp_clock(struct bcma_drv_cc *cc)
432 +{
433 + struct bcma_bus *bus = cc->core->bus;
434 +
435 + switch (bus->chipinfo.id) {
436 + case 0x4716:
437 + case 0x4748:
438 + case 47162:
439 + case 0x4313:
440 + case 0x5357:
441 + case 0x4749:
442 + case 53572:
443 + /* always 20Mhz */
444 + return 20000 * 1000;
445 + case 0x5356:
446 + case 0x5300:
447 + /* always 25Mhz */
448 + return 25000 * 1000;
449 + default:
450 + pr_warn("No ALP clock specified for %04X device, "
451 + "pmu rev. %d, using default %d Hz\n",
452 + bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_ALP_CLOCK);
453 + }
454 + return BCMA_CC_PMU_ALP_CLOCK;
455 +}
456 +
457 +/* Find the output of the "m" pll divider given pll controls that start with
458 + * pllreg "pll0" i.e. 12 for main 6 for phy, 0 for misc.
459 + */
460 +static u32 bcma_pmu_clock(struct bcma_drv_cc *cc, u32 pll0, u32 m)
461 +{
462 + u32 tmp, div, ndiv, p1, p2, fc;
463 + struct bcma_bus *bus = cc->core->bus;
464 +
465 + BUG_ON((pll0 & 3) || (pll0 > BCMA_CC_PMU4716_MAINPLL_PLL0));
466 +
467 + BUG_ON(!m || m > 4);
468 +
469 + if (bus->chipinfo.id == 0x5357 || bus->chipinfo.id == 0x4749) {
470 + /* Detect failure in clock setting */
471 + tmp = bcma_cc_read32(cc, BCMA_CC_CHIPSTAT);
472 + if (tmp & 0x40000)
473 + return 133 * 1000000;
474 + }
475 +
476 + tmp = bcma_chipco_pll_read(cc, pll0 + BCMA_CC_PPL_P1P2_OFF);
477 + p1 = (tmp & BCMA_CC_PPL_P1_MASK) >> BCMA_CC_PPL_P1_SHIFT;
478 + p2 = (tmp & BCMA_CC_PPL_P2_MASK) >> BCMA_CC_PPL_P2_SHIFT;
479 +
480 + tmp = bcma_chipco_pll_read(cc, pll0 + BCMA_CC_PPL_M14_OFF);
481 + div = (tmp >> ((m - 1) * BCMA_CC_PPL_MDIV_WIDTH)) &
482 + BCMA_CC_PPL_MDIV_MASK;
483 +
484 + tmp = bcma_chipco_pll_read(cc, pll0 + BCMA_CC_PPL_NM5_OFF);
485 + ndiv = (tmp & BCMA_CC_PPL_NDIV_MASK) >> BCMA_CC_PPL_NDIV_SHIFT;
486 +
487 + /* Do calculation in Mhz */
488 + fc = bcma_pmu_alp_clock(cc) / 1000000;
489 + fc = (p1 * ndiv * fc) / p2;
490 +
491 + /* Return clock in Hertz */
492 + return (fc / div) * 1000000;
493 +}
494 +
495 +/* query bus clock frequency for PMU-enabled chipcommon */
496 +u32 bcma_pmu_get_clockcontrol(struct bcma_drv_cc *cc)
497 +{
498 + struct bcma_bus *bus = cc->core->bus;
499 +
500 + switch (bus->chipinfo.id) {
501 + case 0x4716:
502 + case 0x4748:
503 + case 47162:
504 + return bcma_pmu_clock(cc, BCMA_CC_PMU4716_MAINPLL_PLL0,
505 + BCMA_CC_PMU5_MAINPLL_SSB);
506 + case 0x5356:
507 + return bcma_pmu_clock(cc, BCMA_CC_PMU5356_MAINPLL_PLL0,
508 + BCMA_CC_PMU5_MAINPLL_SSB);
509 + case 0x5357:
510 + case 0x4749:
511 + return bcma_pmu_clock(cc, BCMA_CC_PMU5357_MAINPLL_PLL0,
512 + BCMA_CC_PMU5_MAINPLL_SSB);
513 + case 0x5300:
514 + return bcma_pmu_clock(cc, BCMA_CC_PMU4706_MAINPLL_PLL0,
515 + BCMA_CC_PMU5_MAINPLL_SSB);
516 + case 53572:
517 + return 75000000;
518 + default:
519 + pr_warn("No backplane clock specified for %04X device, "
520 + "pmu rev. %d, using default %d Hz\n",
521 + bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_HT_CLOCK);
522 + }
523 + return BCMA_CC_PMU_HT_CLOCK;
524 +}
525 +
526 +/* query cpu clock frequency for PMU-enabled chipcommon */
527 +u32 bcma_pmu_get_clockcpu(struct bcma_drv_cc *cc)
528 +{
529 + struct bcma_bus *bus = cc->core->bus;
530 +
531 + if (bus->chipinfo.id == 53572)
532 + return 300000000;
533 +
534 + if (cc->pmu.rev >= 5) {
535 + u32 pll;
536 + switch (bus->chipinfo.id) {
537 + case 0x5356:
538 + pll = BCMA_CC_PMU5356_MAINPLL_PLL0;
539 + break;
540 + case 0x5357:
541 + case 0x4749:
542 + pll = BCMA_CC_PMU5357_MAINPLL_PLL0;
543 + break;
544 + default:
545 + pll = BCMA_CC_PMU4716_MAINPLL_PLL0;
546 + break;
547 + }
548 +
549 + /* TODO: if (bus->chipinfo.id == 0x5300)
550 + return si_4706_pmu_clock(sih, osh, cc, PMU4706_MAINPLL_PLL0, PMU5_MAINPLL_CPU); */
551 + return bcma_pmu_clock(cc, pll, BCMA_CC_PMU5_MAINPLL_CPU);
552 + }
553 +
554 + return bcma_pmu_get_clockcontrol(cc);
555 +}
556 --- /dev/null
557 +++ b/drivers/bcma/driver_mips.c
558 @@ -0,0 +1,256 @@
559 +/*
560 + * Broadcom specific AMBA
561 + * Broadcom MIPS32 74K core driver
562 + *
563 + * Copyright 2009, Broadcom Corporation
564 + * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
565 + * Copyright 2010, Bernhard Loos <bernhardloos@googlemail.com>
566 + * Copyright 2011, Hauke Mehrtens <hauke@hauke-m.de>
567 + *
568 + * Licensed under the GNU/GPL. See COPYING for details.
569 + */
570 +
571 +#include "bcma_private.h"
572 +
573 +#include <linux/bcma/bcma.h>
574 +
575 +#include <linux/serial.h>
576 +#include <linux/serial_core.h>
577 +#include <linux/serial_reg.h>
578 +#include <linux/time.h>
579 +
580 +/* The 47162a0 hangs when reading MIPS DMP registers registers */
581 +static inline bool bcma_core_mips_bcm47162a0_quirk(struct bcma_device *dev)
582 +{
583 + return dev->bus->chipinfo.id == 47162 && dev->bus->chipinfo.rev == 0 &&
584 + dev->id.id == BCMA_CORE_MIPS_74K;
585 +}
586 +
587 +/* The 5357b0 hangs when reading USB20H DMP registers */
588 +static inline bool bcma_core_mips_bcm5357b0_quirk(struct bcma_device *dev)
589 +{
590 + return (dev->bus->chipinfo.id == 0x5357 ||
591 + dev->bus->chipinfo.id == 0x4749) &&
592 + dev->bus->chipinfo.pkg == 11 &&
593 + dev->id.id == BCMA_CORE_USB20_HOST;
594 +}
595 +
596 +static inline u32 mips_read32(struct bcma_drv_mips *mcore,
597 + u16 offset)
598 +{
599 + return bcma_read32(mcore->core, offset);
600 +}
601 +
602 +static inline void mips_write32(struct bcma_drv_mips *mcore,
603 + u16 offset,
604 + u32 value)
605 +{
606 + bcma_write32(mcore->core, offset, value);
607 +}
608 +
609 +static const u32 ipsflag_irq_mask[] = {
610 + 0,
611 + BCMA_MIPS_IPSFLAG_IRQ1,
612 + BCMA_MIPS_IPSFLAG_IRQ2,
613 + BCMA_MIPS_IPSFLAG_IRQ3,
614 + BCMA_MIPS_IPSFLAG_IRQ4,
615 +};
616 +
617 +static const u32 ipsflag_irq_shift[] = {
618 + 0,
619 + BCMA_MIPS_IPSFLAG_IRQ1_SHIFT,
620 + BCMA_MIPS_IPSFLAG_IRQ2_SHIFT,
621 + BCMA_MIPS_IPSFLAG_IRQ3_SHIFT,
622 + BCMA_MIPS_IPSFLAG_IRQ4_SHIFT,
623 +};
624 +
625 +static u32 bcma_core_mips_irqflag(struct bcma_device *dev)
626 +{
627 + u32 flag;
628 +
629 + if (bcma_core_mips_bcm47162a0_quirk(dev))
630 + return dev->core_index;
631 + if (bcma_core_mips_bcm5357b0_quirk(dev))
632 + return dev->core_index;
633 + flag = bcma_aread32(dev, BCMA_MIPS_OOBSELOUTA30);
634 +
635 + return flag & 0x1F;
636 +}
637 +
638 +/* Get the MIPS IRQ assignment for a specified device.
639 + * If unassigned, 0 is returned.
640 + */
641 +unsigned int bcma_core_mips_irq(struct bcma_device *dev)
642 +{
643 + struct bcma_device *mdev = dev->bus->drv_mips.core;
644 + u32 irqflag;
645 + unsigned int irq;
646 +
647 + irqflag = bcma_core_mips_irqflag(dev);
648 +
649 + for (irq = 1; irq <= 4; irq++)
650 + if (bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(irq)) &
651 + (1 << irqflag))
652 + return irq;
653 +
654 + return 0;
655 +}
656 +EXPORT_SYMBOL(bcma_core_mips_irq);
657 +
658 +static void bcma_core_mips_set_irq(struct bcma_device *dev, unsigned int irq)
659 +{
660 + unsigned int oldirq = bcma_core_mips_irq(dev);
661 + struct bcma_bus *bus = dev->bus;
662 + struct bcma_device *mdev = bus->drv_mips.core;
663 + u32 irqflag;
664 +
665 + irqflag = bcma_core_mips_irqflag(dev);
666 + BUG_ON(oldirq == 6);
667 +
668 + dev->irq = irq + 2;
669 +
670 + /* clear the old irq */
671 + if (oldirq == 0)
672 + bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0),
673 + bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0)) &
674 + ~(1 << irqflag));
675 + else
676 + bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(irq), 0);
677 +
678 + /* assign the new one */
679 + if (irq == 0) {
680 + bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0),
681 + bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0)) |
682 + (1 << irqflag));
683 + } else {
684 + u32 oldirqflag = bcma_read32(mdev,
685 + BCMA_MIPS_MIPS74K_INTMASK(irq));
686 + if (oldirqflag) {
687 + struct bcma_device *core;
688 +
689 + /* backplane irq line is in use, find out who uses
690 + * it and set user to irq 0
691 + */
692 + list_for_each_entry_reverse(core, &bus->cores, list) {
693 + if ((1 << bcma_core_mips_irqflag(core)) ==
694 + oldirqflag) {
695 + bcma_core_mips_set_irq(core, 0);
696 + break;
697 + }
698 + }
699 + }
700 + bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(irq),
701 + 1 << irqflag);
702 + }
703 +
704 + pr_info("set_irq: core 0x%04x, irq %d => %d\n",
705 + dev->id.id, oldirq + 2, irq + 2);
706 +}
707 +
708 +static void bcma_core_mips_print_irq(struct bcma_device *dev, unsigned int irq)
709 +{
710 + int i;
711 + static const char *irq_name[] = {"2(S)", "3", "4", "5", "6", "D", "I"};
712 + printk(KERN_INFO KBUILD_MODNAME ": core 0x%04x, irq :", dev->id.id);
713 + for (i = 0; i <= 6; i++)
714 + printk(" %s%s", irq_name[i], i == irq ? "*" : " ");
715 + printk("\n");
716 +}
717 +
718 +static void bcma_core_mips_dump_irq(struct bcma_bus *bus)
719 +{
720 + struct bcma_device *core;
721 +
722 + list_for_each_entry_reverse(core, &bus->cores, list) {
723 + bcma_core_mips_print_irq(core, bcma_core_mips_irq(core));
724 + }
725 +}
726 +
727 +u32 bcma_cpu_clock(struct bcma_drv_mips *mcore)
728 +{
729 + struct bcma_bus *bus = mcore->core->bus;
730 +
731 + if (bus->drv_cc.capabilities & BCMA_CC_CAP_PMU)
732 + return bcma_pmu_get_clockcpu(&bus->drv_cc);
733 +
734 + pr_err("No PMU available, need this to get the cpu clock\n");
735 + return 0;
736 +}
737 +EXPORT_SYMBOL(bcma_cpu_clock);
738 +
739 +static void bcma_core_mips_flash_detect(struct bcma_drv_mips *mcore)
740 +{
741 + struct bcma_bus *bus = mcore->core->bus;
742 +
743 + switch (bus->drv_cc.capabilities & BCMA_CC_CAP_FLASHT) {
744 + case BCMA_CC_FLASHT_STSER:
745 + case BCMA_CC_FLASHT_ATSER:
746 + pr_err("Serial flash not supported.\n");
747 + break;
748 + case BCMA_CC_FLASHT_PARA:
749 + pr_info("found parallel flash.\n");
750 + bus->drv_cc.pflash.window = 0x1c000000;
751 + bus->drv_cc.pflash.window_size = 0x02000000;
752 +
753 + if ((bcma_read32(bus->drv_cc.core, BCMA_CC_FLASH_CFG) &
754 + BCMA_CC_FLASH_CFG_DS) == 0)
755 + bus->drv_cc.pflash.buswidth = 1;
756 + else
757 + bus->drv_cc.pflash.buswidth = 2;
758 + break;
759 + default:
760 + pr_err("flash not supported.\n");
761 + }
762 +}
763 +
764 +void bcma_core_mips_init(struct bcma_drv_mips *mcore)
765 +{
766 + struct bcma_bus *bus;
767 + struct bcma_device *core;
768 + bus = mcore->core->bus;
769 +
770 + pr_info("Initializing MIPS core...\n");
771 +
772 + if (!mcore->setup_done)
773 + mcore->assigned_irqs = 1;
774 +
775 + /* Assign IRQs to all cores on the bus */
776 + list_for_each_entry_reverse(core, &bus->cores, list) {
777 + int mips_irq;
778 + if (core->irq)
779 + continue;
780 +
781 + mips_irq = bcma_core_mips_irq(core);
782 + if (mips_irq > 4)
783 + core->irq = 0;
784 + else
785 + core->irq = mips_irq + 2;
786 + if (core->irq > 5)
787 + continue;
788 + switch (core->id.id) {
789 + case BCMA_CORE_PCI:
790 + case BCMA_CORE_PCIE:
791 + case BCMA_CORE_ETHERNET:
792 + case BCMA_CORE_ETHERNET_GBIT:
793 + case BCMA_CORE_MAC_GBIT:
794 + case BCMA_CORE_80211:
795 + case BCMA_CORE_USB20_HOST:
796 + /* These devices get their own IRQ line if available,
797 + * the rest goes on IRQ0
798 + */
799 + if (mcore->assigned_irqs <= 4)
800 + bcma_core_mips_set_irq(core,
801 + mcore->assigned_irqs++);
802 + break;
803 + }
804 + }
805 + pr_info("IRQ reconfiguration done\n");
806 + bcma_core_mips_dump_irq(bus);
807 +
808 + if (mcore->setup_done)
809 + return;
810 +
811 + bcma_chipco_serial_init(&bus->drv_cc);
812 + bcma_core_mips_flash_detect(mcore);
813 + mcore->setup_done = true;
814 +}
815 --- a/drivers/bcma/driver_pci.c
816 +++ b/drivers/bcma/driver_pci.c
817 @@ -3,7 +3,7 @@
818 * PCI Core
819 *
820 * Copyright 2005, Broadcom Corporation
821 - * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
822 + * Copyright 2006, 2007, Michael Buesch <m@bues.ch>
823 *
824 * Licensed under the GNU/GPL. See COPYING for details.
825 */
826 @@ -157,7 +157,81 @@ static void bcma_pcicore_serdes_workarou
827 * Init.
828 **************************************************/
829
830 -void bcma_core_pci_init(struct bcma_drv_pci *pc)
831 +static void bcma_core_pci_clientmode_init(struct bcma_drv_pci *pc)
832 {
833 bcma_pcicore_serdes_workaround(pc);
834 }
835 +
836 +static bool bcma_core_pci_is_in_hostmode(struct bcma_drv_pci *pc)
837 +{
838 + struct bcma_bus *bus = pc->core->bus;
839 + u16 chipid_top;
840 +
841 + chipid_top = (bus->chipinfo.id & 0xFF00);
842 + if (chipid_top != 0x4700 &&
843 + chipid_top != 0x5300)
844 + return false;
845 +
846 +#ifdef CONFIG_SSB_DRIVER_PCICORE
847 + if (bus->sprom.boardflags_lo & SSB_BFL_NOPCI)
848 + return false;
849 +#endif /* CONFIG_SSB_DRIVER_PCICORE */
850 +
851 +#if 0
852 + /* TODO: on BCMA we use address from EROM instead of magic formula */
853 + u32 tmp;
854 + return !mips_busprobe32(tmp, (bus->mmio +
855 + (pc->core->core_index * BCMA_CORE_SIZE)));
856 +#endif
857 +
858 + return true;
859 +}
860 +
861 +void bcma_core_pci_init(struct bcma_drv_pci *pc)
862 +{
863 + if (pc->setup_done)
864 + return;
865 +
866 + if (bcma_core_pci_is_in_hostmode(pc)) {
867 +#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
868 + bcma_core_pci_hostmode_init(pc);
869 +#else
870 + pr_err("Driver compiled without support for hostmode PCI\n");
871 +#endif /* CONFIG_BCMA_DRIVER_PCI_HOSTMODE */
872 + } else {
873 + bcma_core_pci_clientmode_init(pc);
874 + }
875 +
876 + pc->setup_done = true;
877 +}
878 +
879 +int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc, struct bcma_device *core,
880 + bool enable)
881 +{
882 + struct pci_dev *pdev = pc->core->bus->host_pci;
883 + u32 coremask, tmp;
884 + int err = 0;
885 +
886 + if (core->bus->hosttype != BCMA_HOSTTYPE_PCI) {
887 + /* This bcma device is not on a PCI host-bus. So the IRQs are
888 + * not routed through the PCI core.
889 + * So we must not enable routing through the PCI core. */
890 + goto out;
891 + }
892 +
893 + err = pci_read_config_dword(pdev, BCMA_PCI_IRQMASK, &tmp);
894 + if (err)
895 + goto out;
896 +
897 + coremask = BIT(core->core_index) << 8;
898 + if (enable)
899 + tmp |= coremask;
900 + else
901 + tmp &= ~coremask;
902 +
903 + err = pci_write_config_dword(pdev, BCMA_PCI_IRQMASK, tmp);
904 +
905 +out:
906 + return err;
907 +}
908 +EXPORT_SYMBOL_GPL(bcma_core_pci_irq_ctl);
909 --- /dev/null
910 +++ b/drivers/bcma/driver_pci_host.c
911 @@ -0,0 +1,14 @@
912 +/*
913 + * Broadcom specific AMBA
914 + * PCI Core in hostmode
915 + *
916 + * Licensed under the GNU/GPL. See COPYING for details.
917 + */
918 +
919 +#include "bcma_private.h"
920 +#include <linux/bcma/bcma.h>
921 +
922 +void bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc)
923 +{
924 + pr_err("No support for PCI core in hostmode yet\n");
925 +}
926 --- a/drivers/bcma/host_pci.c
927 +++ b/drivers/bcma/host_pci.c
928 @@ -9,6 +9,7 @@
929 #include <linux/slab.h>
930 #include <linux/bcma/bcma.h>
931 #include <linux/pci.h>
932 +#include <linux/module.h>
933
934 static void bcma_host_pci_switch_core(struct bcma_device *core)
935 {
936 @@ -20,50 +21,108 @@ static void bcma_host_pci_switch_core(st
937 pr_debug("Switched to core: 0x%X\n", core->id.id);
938 }
939
940 -static u8 bcma_host_pci_read8(struct bcma_device *core, u16 offset)
941 -{
942 +/* Provides access to the requested core. Returns base offset that has to be
943 + * used. It makes use of fixed windows when possible. */
944 +static u16 bcma_host_pci_provide_access_to_core(struct bcma_device *core)
945 +{
946 + switch (core->id.id) {
947 + case BCMA_CORE_CHIPCOMMON:
948 + return 3 * BCMA_CORE_SIZE;
949 + case BCMA_CORE_PCIE:
950 + return 2 * BCMA_CORE_SIZE;
951 + }
952 +
953 if (core->bus->mapped_core != core)
954 bcma_host_pci_switch_core(core);
955 + return 0;
956 +}
957 +
958 +static u8 bcma_host_pci_read8(struct bcma_device *core, u16 offset)
959 +{
960 + offset += bcma_host_pci_provide_access_to_core(core);
961 return ioread8(core->bus->mmio + offset);
962 }
963
964 static u16 bcma_host_pci_read16(struct bcma_device *core, u16 offset)
965 {
966 - if (core->bus->mapped_core != core)
967 - bcma_host_pci_switch_core(core);
968 + offset += bcma_host_pci_provide_access_to_core(core);
969 return ioread16(core->bus->mmio + offset);
970 }
971
972 static u32 bcma_host_pci_read32(struct bcma_device *core, u16 offset)
973 {
974 - if (core->bus->mapped_core != core)
975 - bcma_host_pci_switch_core(core);
976 + offset += bcma_host_pci_provide_access_to_core(core);
977 return ioread32(core->bus->mmio + offset);
978 }
979
980 static void bcma_host_pci_write8(struct bcma_device *core, u16 offset,
981 u8 value)
982 {
983 - if (core->bus->mapped_core != core)
984 - bcma_host_pci_switch_core(core);
985 + offset += bcma_host_pci_provide_access_to_core(core);
986 iowrite8(value, core->bus->mmio + offset);
987 }
988
989 static void bcma_host_pci_write16(struct bcma_device *core, u16 offset,
990 u16 value)
991 {
992 - if (core->bus->mapped_core != core)
993 - bcma_host_pci_switch_core(core);
994 + offset += bcma_host_pci_provide_access_to_core(core);
995 iowrite16(value, core->bus->mmio + offset);
996 }
997
998 static void bcma_host_pci_write32(struct bcma_device *core, u16 offset,
999 u32 value)
1000 {
1001 + offset += bcma_host_pci_provide_access_to_core(core);
1002 + iowrite32(value, core->bus->mmio + offset);
1003 +}
1004 +
1005 +#ifdef CONFIG_BCMA_BLOCKIO
1006 +void bcma_host_pci_block_read(struct bcma_device *core, void *buffer,
1007 + size_t count, u16 offset, u8 reg_width)
1008 +{
1009 + void __iomem *addr = core->bus->mmio + offset;
1010 if (core->bus->mapped_core != core)
1011 bcma_host_pci_switch_core(core);
1012 - iowrite32(value, core->bus->mmio + offset);
1013 + switch (reg_width) {
1014 + case sizeof(u8):
1015 + ioread8_rep(addr, buffer, count);
1016 + break;
1017 + case sizeof(u16):
1018 + WARN_ON(count & 1);
1019 + ioread16_rep(addr, buffer, count >> 1);
1020 + break;
1021 + case sizeof(u32):
1022 + WARN_ON(count & 3);
1023 + ioread32_rep(addr, buffer, count >> 2);
1024 + break;
1025 + default:
1026 + WARN_ON(1);
1027 + }
1028 +}
1029 +
1030 +void bcma_host_pci_block_write(struct bcma_device *core, const void *buffer,
1031 + size_t count, u16 offset, u8 reg_width)
1032 +{
1033 + void __iomem *addr = core->bus->mmio + offset;
1034 + if (core->bus->mapped_core != core)
1035 + bcma_host_pci_switch_core(core);
1036 + switch (reg_width) {
1037 + case sizeof(u8):
1038 + iowrite8_rep(addr, buffer, count);
1039 + break;
1040 + case sizeof(u16):
1041 + WARN_ON(count & 1);
1042 + iowrite16_rep(addr, buffer, count >> 1);
1043 + break;
1044 + case sizeof(u32):
1045 + WARN_ON(count & 3);
1046 + iowrite32_rep(addr, buffer, count >> 2);
1047 + break;
1048 + default:
1049 + WARN_ON(1);
1050 + }
1051 }
1052 +#endif
1053
1054 static u32 bcma_host_pci_aread32(struct bcma_device *core, u16 offset)
1055 {
1056 @@ -87,6 +146,10 @@ const struct bcma_host_ops bcma_host_pci
1057 .write8 = bcma_host_pci_write8,
1058 .write16 = bcma_host_pci_write16,
1059 .write32 = bcma_host_pci_write32,
1060 +#ifdef CONFIG_BCMA_BLOCKIO
1061 + .block_read = bcma_host_pci_block_read,
1062 + .block_write = bcma_host_pci_block_write,
1063 +#endif
1064 .aread32 = bcma_host_pci_aread32,
1065 .awrite32 = bcma_host_pci_awrite32,
1066 };
1067 @@ -171,10 +234,46 @@ static void bcma_host_pci_remove(struct
1068 pci_set_drvdata(dev, NULL);
1069 }
1070
1071 +#ifdef CONFIG_PM
1072 +static int bcma_host_pci_suspend(struct pci_dev *dev, pm_message_t state)
1073 +{
1074 + /* Host specific */
1075 + pci_save_state(dev);
1076 + pci_disable_device(dev);
1077 + pci_set_power_state(dev, pci_choose_state(dev, state));
1078 +
1079 + return 0;
1080 +}
1081 +
1082 +static int bcma_host_pci_resume(struct pci_dev *dev)
1083 +{
1084 + struct bcma_bus *bus = pci_get_drvdata(dev);
1085 + int err;
1086 +
1087 + /* Host specific */
1088 + pci_set_power_state(dev, 0);
1089 + err = pci_enable_device(dev);
1090 + if (err)
1091 + return err;
1092 + pci_restore_state(dev);
1093 +
1094 + /* Bus specific */
1095 + err = bcma_bus_resume(bus);
1096 + if (err)
1097 + return err;
1098 +
1099 + return 0;
1100 +}
1101 +#else /* CONFIG_PM */
1102 +# define bcma_host_pci_suspend NULL
1103 +# define bcma_host_pci_resume NULL
1104 +#endif /* CONFIG_PM */
1105 +
1106 static DEFINE_PCI_DEVICE_TABLE(bcma_pci_bridge_tbl) = {
1107 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x0576) },
1108 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4331) },
1109 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4353) },
1110 + { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4357) },
1111 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4727) },
1112 { 0, },
1113 };
1114 @@ -185,6 +284,8 @@ static struct pci_driver bcma_pci_bridge
1115 .id_table = bcma_pci_bridge_tbl,
1116 .probe = bcma_host_pci_probe,
1117 .remove = bcma_host_pci_remove,
1118 + .suspend = bcma_host_pci_suspend,
1119 + .resume = bcma_host_pci_resume,
1120 };
1121
1122 int __init bcma_host_pci_init(void)
1123 --- /dev/null
1124 +++ b/drivers/bcma/host_soc.c
1125 @@ -0,0 +1,183 @@
1126 +/*
1127 + * Broadcom specific AMBA
1128 + * System on Chip (SoC) Host
1129 + *
1130 + * Licensed under the GNU/GPL. See COPYING for details.
1131 + */
1132 +
1133 +#include "bcma_private.h"
1134 +#include "scan.h"
1135 +#include <linux/bcma/bcma.h>
1136 +#include <linux/bcma/bcma_soc.h>
1137 +
1138 +static u8 bcma_host_soc_read8(struct bcma_device *core, u16 offset)
1139 +{
1140 + return readb(core->io_addr + offset);
1141 +}
1142 +
1143 +static u16 bcma_host_soc_read16(struct bcma_device *core, u16 offset)
1144 +{
1145 + return readw(core->io_addr + offset);
1146 +}
1147 +
1148 +static u32 bcma_host_soc_read32(struct bcma_device *core, u16 offset)
1149 +{
1150 + return readl(core->io_addr + offset);
1151 +}
1152 +
1153 +static void bcma_host_soc_write8(struct bcma_device *core, u16 offset,
1154 + u8 value)
1155 +{
1156 + writeb(value, core->io_addr + offset);
1157 +}
1158 +
1159 +static void bcma_host_soc_write16(struct bcma_device *core, u16 offset,
1160 + u16 value)
1161 +{
1162 + writew(value, core->io_addr + offset);
1163 +}
1164 +
1165 +static void bcma_host_soc_write32(struct bcma_device *core, u16 offset,
1166 + u32 value)
1167 +{
1168 + writel(value, core->io_addr + offset);
1169 +}
1170 +
1171 +#ifdef CONFIG_BCMA_BLOCKIO
1172 +static void bcma_host_soc_block_read(struct bcma_device *core, void *buffer,
1173 + size_t count, u16 offset, u8 reg_width)
1174 +{
1175 + void __iomem *addr = core->io_addr + offset;
1176 +
1177 + switch (reg_width) {
1178 + case sizeof(u8): {
1179 + u8 *buf = buffer;
1180 +
1181 + while (count) {
1182 + *buf = __raw_readb(addr);
1183 + buf++;
1184 + count--;
1185 + }
1186 + break;
1187 + }
1188 + case sizeof(u16): {
1189 + __le16 *buf = buffer;
1190 +
1191 + WARN_ON(count & 1);
1192 + while (count) {
1193 + *buf = (__force __le16)__raw_readw(addr);
1194 + buf++;
1195 + count -= 2;
1196 + }
1197 + break;
1198 + }
1199 + case sizeof(u32): {
1200 + __le32 *buf = buffer;
1201 +
1202 + WARN_ON(count & 3);
1203 + while (count) {
1204 + *buf = (__force __le32)__raw_readl(addr);
1205 + buf++;
1206 + count -= 4;
1207 + }
1208 + break;
1209 + }
1210 + default:
1211 + WARN_ON(1);
1212 + }
1213 +}
1214 +
1215 +static void bcma_host_soc_block_write(struct bcma_device *core,
1216 + const void *buffer,
1217 + size_t count, u16 offset, u8 reg_width)
1218 +{
1219 + void __iomem *addr = core->io_addr + offset;
1220 +
1221 + switch (reg_width) {
1222 + case sizeof(u8): {
1223 + const u8 *buf = buffer;
1224 +
1225 + while (count) {
1226 + __raw_writeb(*buf, addr);
1227 + buf++;
1228 + count--;
1229 + }
1230 + break;
1231 + }
1232 + case sizeof(u16): {
1233 + const __le16 *buf = buffer;
1234 +
1235 + WARN_ON(count & 1);
1236 + while (count) {
1237 + __raw_writew((__force u16)(*buf), addr);
1238 + buf++;
1239 + count -= 2;
1240 + }
1241 + break;
1242 + }
1243 + case sizeof(u32): {
1244 + const __le32 *buf = buffer;
1245 +
1246 + WARN_ON(count & 3);
1247 + while (count) {
1248 + __raw_writel((__force u32)(*buf), addr);
1249 + buf++;
1250 + count -= 4;
1251 + }
1252 + break;
1253 + }
1254 + default:
1255 + WARN_ON(1);
1256 + }
1257 +}
1258 +#endif /* CONFIG_BCMA_BLOCKIO */
1259 +
1260 +static u32 bcma_host_soc_aread32(struct bcma_device *core, u16 offset)
1261 +{
1262 + return readl(core->io_wrap + offset);
1263 +}
1264 +
1265 +static void bcma_host_soc_awrite32(struct bcma_device *core, u16 offset,
1266 + u32 value)
1267 +{
1268 + writel(value, core->io_wrap + offset);
1269 +}
1270 +
1271 +const struct bcma_host_ops bcma_host_soc_ops = {
1272 + .read8 = bcma_host_soc_read8,
1273 + .read16 = bcma_host_soc_read16,
1274 + .read32 = bcma_host_soc_read32,
1275 + .write8 = bcma_host_soc_write8,
1276 + .write16 = bcma_host_soc_write16,
1277 + .write32 = bcma_host_soc_write32,
1278 +#ifdef CONFIG_BCMA_BLOCKIO
1279 + .block_read = bcma_host_soc_block_read,
1280 + .block_write = bcma_host_soc_block_write,
1281 +#endif
1282 + .aread32 = bcma_host_soc_aread32,
1283 + .awrite32 = bcma_host_soc_awrite32,
1284 +};
1285 +
1286 +int __init bcma_host_soc_register(struct bcma_soc *soc)
1287 +{
1288 + struct bcma_bus *bus = &soc->bus;
1289 + int err;
1290 +
1291 + /* iomap only first core. We have to read some register on this core
1292 + * to scan the bus.
1293 + */
1294 + bus->mmio = ioremap_nocache(BCMA_ADDR_BASE, BCMA_CORE_SIZE * 1);
1295 + if (!bus->mmio)
1296 + return -ENOMEM;
1297 +
1298 + /* Host specific */
1299 + bus->hosttype = BCMA_HOSTTYPE_SOC;
1300 + bus->ops = &bcma_host_soc_ops;
1301 +
1302 + /* Register */
1303 + err = bcma_bus_early_register(bus, &soc->core_cc, &soc->core_mips);
1304 + if (err)
1305 + iounmap(bus->mmio);
1306 +
1307 + return err;
1308 +}
1309 --- a/drivers/bcma/main.c
1310 +++ b/drivers/bcma/main.c
1311 @@ -6,7 +6,9 @@
1312 */
1313
1314 #include "bcma_private.h"
1315 +#include <linux/module.h>
1316 #include <linux/bcma/bcma.h>
1317 +#include <linux/slab.h>
1318
1319 MODULE_DESCRIPTION("Broadcom's specific AMBA driver");
1320 MODULE_LICENSE("GPL");
1321 @@ -14,6 +16,7 @@ MODULE_LICENSE("GPL");
1322 static int bcma_bus_match(struct device *dev, struct device_driver *drv);
1323 static int bcma_device_probe(struct device *dev);
1324 static int bcma_device_remove(struct device *dev);
1325 +static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env);
1326
1327 static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
1328 {
1329 @@ -48,6 +51,7 @@ static struct bus_type bcma_bus_type = {
1330 .match = bcma_bus_match,
1331 .probe = bcma_device_probe,
1332 .remove = bcma_device_remove,
1333 + .uevent = bcma_device_uevent,
1334 .dev_attrs = bcma_device_attrs,
1335 };
1336
1337 @@ -65,6 +69,10 @@ static struct bcma_device *bcma_find_cor
1338 static void bcma_release_core_dev(struct device *dev)
1339 {
1340 struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1341 + if (core->io_addr)
1342 + iounmap(core->io_addr);
1343 + if (core->io_wrap)
1344 + iounmap(core->io_wrap);
1345 kfree(core);
1346 }
1347
1348 @@ -79,6 +87,7 @@ static int bcma_register_cores(struct bc
1349 case BCMA_CORE_CHIPCOMMON:
1350 case BCMA_CORE_PCI:
1351 case BCMA_CORE_PCIE:
1352 + case BCMA_CORE_MIPS_74K:
1353 continue;
1354 }
1355
1356 @@ -89,8 +98,13 @@ static int bcma_register_cores(struct bc
1357 switch (bus->hosttype) {
1358 case BCMA_HOSTTYPE_PCI:
1359 core->dev.parent = &bus->host_pci->dev;
1360 + core->dma_dev = &bus->host_pci->dev;
1361 + core->irq = bus->host_pci->irq;
1362 + break;
1363 + case BCMA_HOSTTYPE_SOC:
1364 + core->dev.dma_mask = &core->dev.coherent_dma_mask;
1365 + core->dma_dev = &core->dev;
1366 break;
1367 - case BCMA_HOSTTYPE_NONE:
1368 case BCMA_HOSTTYPE_SDIO:
1369 break;
1370 }
1371 @@ -137,6 +151,13 @@ int bcma_bus_register(struct bcma_bus *b
1372 bcma_core_chipcommon_init(&bus->drv_cc);
1373 }
1374
1375 + /* Init MIPS core */
1376 + core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
1377 + if (core) {
1378 + bus->drv_mips.core = core;
1379 + bcma_core_mips_init(&bus->drv_mips);
1380 + }
1381 +
1382 /* Init PCIE core */
1383 core = bcma_find_core(bus, BCMA_CORE_PCIE);
1384 if (core) {
1385 @@ -144,6 +165,15 @@ int bcma_bus_register(struct bcma_bus *b
1386 bcma_core_pci_init(&bus->drv_pci);
1387 }
1388
1389 + /* Try to get SPROM */
1390 + err = bcma_sprom_get(bus);
1391 + if (err == -ENOENT) {
1392 + pr_err("No SPROM available\n");
1393 + } else if (err) {
1394 + pr_err("Failed to get SPROM: %d\n", err);
1395 + return -ENOENT;
1396 + }
1397 +
1398 /* Register found cores */
1399 bcma_register_cores(bus);
1400
1401 @@ -151,13 +181,80 @@ int bcma_bus_register(struct bcma_bus *b
1402
1403 return 0;
1404 }
1405 -EXPORT_SYMBOL_GPL(bcma_bus_register);
1406
1407 void bcma_bus_unregister(struct bcma_bus *bus)
1408 {
1409 bcma_unregister_cores(bus);
1410 }
1411 -EXPORT_SYMBOL_GPL(bcma_bus_unregister);
1412 +
1413 +int __init bcma_bus_early_register(struct bcma_bus *bus,
1414 + struct bcma_device *core_cc,
1415 + struct bcma_device *core_mips)
1416 +{
1417 + int err;
1418 + struct bcma_device *core;
1419 + struct bcma_device_id match;
1420 +
1421 + bcma_init_bus(bus);
1422 +
1423 + match.manuf = BCMA_MANUF_BCM;
1424 + match.id = BCMA_CORE_CHIPCOMMON;
1425 + match.class = BCMA_CL_SIM;
1426 + match.rev = BCMA_ANY_REV;
1427 +
1428 + /* Scan for chip common core */
1429 + err = bcma_bus_scan_early(bus, &match, core_cc);
1430 + if (err) {
1431 + pr_err("Failed to scan for common core: %d\n", err);
1432 + return -1;
1433 + }
1434 +
1435 + match.manuf = BCMA_MANUF_MIPS;
1436 + match.id = BCMA_CORE_MIPS_74K;
1437 + match.class = BCMA_CL_SIM;
1438 + match.rev = BCMA_ANY_REV;
1439 +
1440 + /* Scan for mips core */
1441 + err = bcma_bus_scan_early(bus, &match, core_mips);
1442 + if (err) {
1443 + pr_err("Failed to scan for mips core: %d\n", err);
1444 + return -1;
1445 + }
1446 +
1447 + /* Init CC core */
1448 + core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
1449 + if (core) {
1450 + bus->drv_cc.core = core;
1451 + bcma_core_chipcommon_init(&bus->drv_cc);
1452 + }
1453 +
1454 + /* Init MIPS core */
1455 + core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
1456 + if (core) {
1457 + bus->drv_mips.core = core;
1458 + bcma_core_mips_init(&bus->drv_mips);
1459 + }
1460 +
1461 + pr_info("Early bus registered\n");
1462 +
1463 + return 0;
1464 +}
1465 +
1466 +#ifdef CONFIG_PM
1467 +int bcma_bus_resume(struct bcma_bus *bus)
1468 +{
1469 + struct bcma_device *core;
1470 +
1471 + /* Init CC core */
1472 + core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
1473 + if (core) {
1474 + bus->drv_cc.setup_done = false;
1475 + bcma_core_chipcommon_init(&bus->drv_cc);
1476 + }
1477 +
1478 + return 0;
1479 +}
1480 +#endif
1481
1482 int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
1483 {
1484 @@ -217,6 +314,16 @@ static int bcma_device_remove(struct dev
1485 return 0;
1486 }
1487
1488 +static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
1489 +{
1490 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1491 +
1492 + return add_uevent_var(env,
1493 + "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
1494 + core->id.manuf, core->id.id,
1495 + core->id.rev, core->id.class);
1496 +}
1497 +
1498 static int __init bcma_modinit(void)
1499 {
1500 int err;
1501 --- a/drivers/bcma/scan.c
1502 +++ b/drivers/bcma/scan.c
1503 @@ -200,18 +200,162 @@ static s32 bcma_erom_get_addr_desc(struc
1504 return addrl;
1505 }
1506
1507 -int bcma_bus_scan(struct bcma_bus *bus)
1508 +static struct bcma_device *bcma_find_core_by_index(struct bcma_bus *bus,
1509 + u16 index)
1510 {
1511 - u32 erombase;
1512 - u32 __iomem *eromptr, *eromend;
1513 + struct bcma_device *core;
1514
1515 + list_for_each_entry(core, &bus->cores, list) {
1516 + if (core->core_index == index)
1517 + return core;
1518 + }
1519 + return NULL;
1520 +}
1521 +
1522 +static int bcma_get_next_core(struct bcma_bus *bus, u32 __iomem **eromptr,
1523 + struct bcma_device_id *match, int core_num,
1524 + struct bcma_device *core)
1525 +{
1526 + s32 tmp;
1527 + u8 i, j;
1528 s32 cia, cib;
1529 u8 ports[2], wrappers[2];
1530
1531 + /* get CIs */
1532 + cia = bcma_erom_get_ci(bus, eromptr);
1533 + if (cia < 0) {
1534 + bcma_erom_push_ent(eromptr);
1535 + if (bcma_erom_is_end(bus, eromptr))
1536 + return -ESPIPE;
1537 + return -EILSEQ;
1538 + }
1539 + cib = bcma_erom_get_ci(bus, eromptr);
1540 + if (cib < 0)
1541 + return -EILSEQ;
1542 +
1543 + /* parse CIs */
1544 + core->id.class = (cia & SCAN_CIA_CLASS) >> SCAN_CIA_CLASS_SHIFT;
1545 + core->id.id = (cia & SCAN_CIA_ID) >> SCAN_CIA_ID_SHIFT;
1546 + core->id.manuf = (cia & SCAN_CIA_MANUF) >> SCAN_CIA_MANUF_SHIFT;
1547 + ports[0] = (cib & SCAN_CIB_NMP) >> SCAN_CIB_NMP_SHIFT;
1548 + ports[1] = (cib & SCAN_CIB_NSP) >> SCAN_CIB_NSP_SHIFT;
1549 + wrappers[0] = (cib & SCAN_CIB_NMW) >> SCAN_CIB_NMW_SHIFT;
1550 + wrappers[1] = (cib & SCAN_CIB_NSW) >> SCAN_CIB_NSW_SHIFT;
1551 + core->id.rev = (cib & SCAN_CIB_REV) >> SCAN_CIB_REV_SHIFT;
1552 +
1553 + if (((core->id.manuf == BCMA_MANUF_ARM) &&
1554 + (core->id.id == 0xFFF)) ||
1555 + (ports[1] == 0)) {
1556 + bcma_erom_skip_component(bus, eromptr);
1557 + return -ENXIO;
1558 + }
1559 +
1560 + /* check if component is a core at all */
1561 + if (wrappers[0] + wrappers[1] == 0) {
1562 + /* we could save addrl of the router
1563 + if (cid == BCMA_CORE_OOB_ROUTER)
1564 + */
1565 + bcma_erom_skip_component(bus, eromptr);
1566 + return -ENXIO;
1567 + }
1568 +
1569 + if (bcma_erom_is_bridge(bus, eromptr)) {
1570 + bcma_erom_skip_component(bus, eromptr);
1571 + return -ENXIO;
1572 + }
1573 +
1574 + if (bcma_find_core_by_index(bus, core_num)) {
1575 + bcma_erom_skip_component(bus, eromptr);
1576 + return -ENODEV;
1577 + }
1578 +
1579 + if (match && ((match->manuf != BCMA_ANY_MANUF &&
1580 + match->manuf != core->id.manuf) ||
1581 + (match->id != BCMA_ANY_ID && match->id != core->id.id) ||
1582 + (match->rev != BCMA_ANY_REV && match->rev != core->id.rev) ||
1583 + (match->class != BCMA_ANY_CLASS && match->class != core->id.class)
1584 + )) {
1585 + bcma_erom_skip_component(bus, eromptr);
1586 + return -ENODEV;
1587 + }
1588 +
1589 + /* get & parse master ports */
1590 + for (i = 0; i < ports[0]; i++) {
1591 + s32 mst_port_d = bcma_erom_get_mst_port(bus, eromptr);
1592 + if (mst_port_d < 0)
1593 + return -EILSEQ;
1594 + }
1595 +
1596 + /* get & parse slave ports */
1597 + for (i = 0; i < ports[1]; i++) {
1598 + for (j = 0; ; j++) {
1599 + tmp = bcma_erom_get_addr_desc(bus, eromptr,
1600 + SCAN_ADDR_TYPE_SLAVE, i);
1601 + if (tmp < 0) {
1602 + /* no more entries for port _i_ */
1603 + /* pr_debug("erom: slave port %d "
1604 + * "has %d descriptors\n", i, j); */
1605 + break;
1606 + } else {
1607 + if (i == 0 && j == 0)
1608 + core->addr = tmp;
1609 + }
1610 + }
1611 + }
1612 +
1613 + /* get & parse master wrappers */
1614 + for (i = 0; i < wrappers[0]; i++) {
1615 + for (j = 0; ; j++) {
1616 + tmp = bcma_erom_get_addr_desc(bus, eromptr,
1617 + SCAN_ADDR_TYPE_MWRAP, i);
1618 + if (tmp < 0) {
1619 + /* no more entries for port _i_ */
1620 + /* pr_debug("erom: master wrapper %d "
1621 + * "has %d descriptors\n", i, j); */
1622 + break;
1623 + } else {
1624 + if (i == 0 && j == 0)
1625 + core->wrap = tmp;
1626 + }
1627 + }
1628 + }
1629 +
1630 + /* get & parse slave wrappers */
1631 + for (i = 0; i < wrappers[1]; i++) {
1632 + u8 hack = (ports[1] == 1) ? 0 : 1;
1633 + for (j = 0; ; j++) {
1634 + tmp = bcma_erom_get_addr_desc(bus, eromptr,
1635 + SCAN_ADDR_TYPE_SWRAP, i + hack);
1636 + if (tmp < 0) {
1637 + /* no more entries for port _i_ */
1638 + /* pr_debug("erom: master wrapper %d "
1639 + * has %d descriptors\n", i, j); */
1640 + break;
1641 + } else {
1642 + if (wrappers[0] == 0 && !i && !j)
1643 + core->wrap = tmp;
1644 + }
1645 + }
1646 + }
1647 + if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
1648 + core->io_addr = ioremap_nocache(core->addr, BCMA_CORE_SIZE);
1649 + if (!core->io_addr)
1650 + return -ENOMEM;
1651 + core->io_wrap = ioremap_nocache(core->wrap, BCMA_CORE_SIZE);
1652 + if (!core->io_wrap) {
1653 + iounmap(core->io_addr);
1654 + return -ENOMEM;
1655 + }
1656 + }
1657 + return 0;
1658 +}
1659 +
1660 +void bcma_init_bus(struct bcma_bus *bus)
1661 +{
1662 s32 tmp;
1663 - u8 i, j;
1664
1665 - int err;
1666 + if (bus->init_done)
1667 + return;
1668
1669 INIT_LIST_HEAD(&bus->cores);
1670 bus->nr_cores = 0;
1671 @@ -222,9 +366,27 @@ int bcma_bus_scan(struct bcma_bus *bus)
1672 bus->chipinfo.id = (tmp & BCMA_CC_ID_ID) >> BCMA_CC_ID_ID_SHIFT;
1673 bus->chipinfo.rev = (tmp & BCMA_CC_ID_REV) >> BCMA_CC_ID_REV_SHIFT;
1674 bus->chipinfo.pkg = (tmp & BCMA_CC_ID_PKG) >> BCMA_CC_ID_PKG_SHIFT;
1675 + bus->init_done = true;
1676 +}
1677 +
1678 +int bcma_bus_scan(struct bcma_bus *bus)
1679 +{
1680 + u32 erombase;
1681 + u32 __iomem *eromptr, *eromend;
1682 +
1683 + int err, core_num = 0;
1684 +
1685 + bcma_init_bus(bus);
1686
1687 erombase = bcma_scan_read32(bus, 0, BCMA_CC_EROM);
1688 - eromptr = bus->mmio;
1689 + if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
1690 + eromptr = ioremap_nocache(erombase, BCMA_CORE_SIZE);
1691 + if (!eromptr)
1692 + return -ENOMEM;
1693 + } else {
1694 + eromptr = bus->mmio;
1695 + }
1696 +
1697 eromend = eromptr + BCMA_CORE_SIZE / sizeof(u32);
1698
1699 bcma_scan_switch_core(bus, erombase);
1700 @@ -236,125 +398,89 @@ int bcma_bus_scan(struct bcma_bus *bus)
1701 INIT_LIST_HEAD(&core->list);
1702 core->bus = bus;
1703
1704 - /* get CIs */
1705 - cia = bcma_erom_get_ci(bus, &eromptr);
1706 - if (cia < 0) {
1707 - bcma_erom_push_ent(&eromptr);
1708 - if (bcma_erom_is_end(bus, &eromptr))
1709 - break;
1710 - err= -EILSEQ;
1711 - goto out;
1712 - }
1713 - cib = bcma_erom_get_ci(bus, &eromptr);
1714 - if (cib < 0) {
1715 - err= -EILSEQ;
1716 - goto out;
1717 - }
1718 -
1719 - /* parse CIs */
1720 - core->id.class = (cia & SCAN_CIA_CLASS) >> SCAN_CIA_CLASS_SHIFT;
1721 - core->id.id = (cia & SCAN_CIA_ID) >> SCAN_CIA_ID_SHIFT;
1722 - core->id.manuf = (cia & SCAN_CIA_MANUF) >> SCAN_CIA_MANUF_SHIFT;
1723 - ports[0] = (cib & SCAN_CIB_NMP) >> SCAN_CIB_NMP_SHIFT;
1724 - ports[1] = (cib & SCAN_CIB_NSP) >> SCAN_CIB_NSP_SHIFT;
1725 - wrappers[0] = (cib & SCAN_CIB_NMW) >> SCAN_CIB_NMW_SHIFT;
1726 - wrappers[1] = (cib & SCAN_CIB_NSW) >> SCAN_CIB_NSW_SHIFT;
1727 - core->id.rev = (cib & SCAN_CIB_REV) >> SCAN_CIB_REV_SHIFT;
1728 -
1729 - if (((core->id.manuf == BCMA_MANUF_ARM) &&
1730 - (core->id.id == 0xFFF)) ||
1731 - (ports[1] == 0)) {
1732 - bcma_erom_skip_component(bus, &eromptr);
1733 + err = bcma_get_next_core(bus, &eromptr, NULL, core_num, core);
1734 + if (err == -ENODEV) {
1735 + core_num++;
1736 continue;
1737 - }
1738 -
1739 - /* check if component is a core at all */
1740 - if (wrappers[0] + wrappers[1] == 0) {
1741 - /* we could save addrl of the router
1742 - if (cid == BCMA_CORE_OOB_ROUTER)
1743 - */
1744 - bcma_erom_skip_component(bus, &eromptr);
1745 + } else if (err == -ENXIO)
1746 continue;
1747 - }
1748 + else if (err == -ESPIPE)
1749 + break;
1750 + else if (err < 0)
1751 + return err;
1752
1753 - if (bcma_erom_is_bridge(bus, &eromptr)) {
1754 - bcma_erom_skip_component(bus, &eromptr);
1755 - continue;
1756 - }
1757 + core->core_index = core_num++;
1758 + bus->nr_cores++;
1759
1760 - /* get & parse master ports */
1761 - for (i = 0; i < ports[0]; i++) {
1762 - u32 mst_port_d = bcma_erom_get_mst_port(bus, &eromptr);
1763 - if (mst_port_d < 0) {
1764 - err= -EILSEQ;
1765 - goto out;
1766 - }
1767 - }
1768 + pr_info("Core %d found: %s "
1769 + "(manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
1770 + core->core_index, bcma_device_name(&core->id),
1771 + core->id.manuf, core->id.id, core->id.rev,
1772 + core->id.class);
1773
1774 - /* get & parse slave ports */
1775 - for (i = 0; i < ports[1]; i++) {
1776 - for (j = 0; ; j++) {
1777 - tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1778 - SCAN_ADDR_TYPE_SLAVE, i);
1779 - if (tmp < 0) {
1780 - /* no more entries for port _i_ */
1781 - /* pr_debug("erom: slave port %d "
1782 - * "has %d descriptors\n", i, j); */
1783 - break;
1784 - } else {
1785 - if (i == 0 && j == 0)
1786 - core->addr = tmp;
1787 - }
1788 - }
1789 - }
1790 + list_add(&core->list, &bus->cores);
1791 + }
1792
1793 - /* get & parse master wrappers */
1794 - for (i = 0; i < wrappers[0]; i++) {
1795 - for (j = 0; ; j++) {
1796 - tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1797 - SCAN_ADDR_TYPE_MWRAP, i);
1798 - if (tmp < 0) {
1799 - /* no more entries for port _i_ */
1800 - /* pr_debug("erom: master wrapper %d "
1801 - * "has %d descriptors\n", i, j); */
1802 - break;
1803 - } else {
1804 - if (i == 0 && j == 0)
1805 - core->wrap = tmp;
1806 - }
1807 - }
1808 - }
1809 + if (bus->hosttype == BCMA_HOSTTYPE_SOC)
1810 + iounmap(eromptr);
1811
1812 - /* get & parse slave wrappers */
1813 - for (i = 0; i < wrappers[1]; i++) {
1814 - u8 hack = (ports[1] == 1) ? 0 : 1;
1815 - for (j = 0; ; j++) {
1816 - tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1817 - SCAN_ADDR_TYPE_SWRAP, i + hack);
1818 - if (tmp < 0) {
1819 - /* no more entries for port _i_ */
1820 - /* pr_debug("erom: master wrapper %d "
1821 - * has %d descriptors\n", i, j); */
1822 - break;
1823 - } else {
1824 - if (wrappers[0] == 0 && !i && !j)
1825 - core->wrap = tmp;
1826 - }
1827 - }
1828 - }
1829 + return 0;
1830 +}
1831 +
1832 +int __init bcma_bus_scan_early(struct bcma_bus *bus,
1833 + struct bcma_device_id *match,
1834 + struct bcma_device *core)
1835 +{
1836 + u32 erombase;
1837 + u32 __iomem *eromptr, *eromend;
1838
1839 + int err = -ENODEV;
1840 + int core_num = 0;
1841 +
1842 + erombase = bcma_scan_read32(bus, 0, BCMA_CC_EROM);
1843 + if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
1844 + eromptr = ioremap_nocache(erombase, BCMA_CORE_SIZE);
1845 + if (!eromptr)
1846 + return -ENOMEM;
1847 + } else {
1848 + eromptr = bus->mmio;
1849 + }
1850 +
1851 + eromend = eromptr + BCMA_CORE_SIZE / sizeof(u32);
1852 +
1853 + bcma_scan_switch_core(bus, erombase);
1854 +
1855 + while (eromptr < eromend) {
1856 + memset(core, 0, sizeof(*core));
1857 + INIT_LIST_HEAD(&core->list);
1858 + core->bus = bus;
1859 +
1860 + err = bcma_get_next_core(bus, &eromptr, match, core_num, core);
1861 + if (err == -ENODEV) {
1862 + core_num++;
1863 + continue;
1864 + } else if (err == -ENXIO)
1865 + continue;
1866 + else if (err == -ESPIPE)
1867 + break;
1868 + else if (err < 0)
1869 + return err;
1870 +
1871 + core->core_index = core_num++;
1872 + bus->nr_cores++;
1873 pr_info("Core %d found: %s "
1874 "(manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
1875 - bus->nr_cores, bcma_device_name(&core->id),
1876 + core->core_index, bcma_device_name(&core->id),
1877 core->id.manuf, core->id.id, core->id.rev,
1878 core->id.class);
1879
1880 - core->core_index = bus->nr_cores++;
1881 list_add(&core->list, &bus->cores);
1882 - continue;
1883 -out:
1884 - return err;
1885 + err = 0;
1886 + break;
1887 }
1888
1889 - return 0;
1890 + if (bus->hosttype == BCMA_HOSTTYPE_SOC)
1891 + iounmap(eromptr);
1892 +
1893 + return err;
1894 }
1895 --- /dev/null
1896 +++ b/drivers/bcma/sprom.c
1897 @@ -0,0 +1,247 @@
1898 +/*
1899 + * Broadcom specific AMBA
1900 + * SPROM reading
1901 + *
1902 + * Licensed under the GNU/GPL. See COPYING for details.
1903 + */
1904 +
1905 +#include "bcma_private.h"
1906 +
1907 +#include <linux/bcma/bcma.h>
1908 +#include <linux/bcma/bcma_regs.h>
1909 +#include <linux/pci.h>
1910 +#include <linux/io.h>
1911 +#include <linux/dma-mapping.h>
1912 +#include <linux/slab.h>
1913 +
1914 +#define SPOFF(offset) ((offset) / sizeof(u16))
1915 +
1916 +/**************************************************
1917 + * R/W ops.
1918 + **************************************************/
1919 +
1920 +static void bcma_sprom_read(struct bcma_bus *bus, u16 offset, u16 *sprom)
1921 +{
1922 + int i;
1923 + for (i = 0; i < SSB_SPROMSIZE_WORDS_R4; i++)
1924 + sprom[i] = bcma_read16(bus->drv_cc.core,
1925 + offset + (i * 2));
1926 +}
1927 +
1928 +/**************************************************
1929 + * Validation.
1930 + **************************************************/
1931 +
1932 +static inline u8 bcma_crc8(u8 crc, u8 data)
1933 +{
1934 + /* Polynomial: x^8 + x^7 + x^6 + x^4 + x^2 + 1 */
1935 + static const u8 t[] = {
1936 + 0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
1937 + 0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
1938 + 0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
1939 + 0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
1940 + 0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
1941 + 0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
1942 + 0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
1943 + 0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
1944 + 0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
1945 + 0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
1946 + 0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
1947 + 0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
1948 + 0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
1949 + 0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
1950 + 0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
1951 + 0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
1952 + 0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
1953 + 0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
1954 + 0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
1955 + 0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
1956 + 0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
1957 + 0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
1958 + 0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
1959 + 0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
1960 + 0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
1961 + 0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
1962 + 0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
1963 + 0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
1964 + 0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
1965 + 0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
1966 + 0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
1967 + 0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F,
1968 + };
1969 + return t[crc ^ data];
1970 +}
1971 +
1972 +static u8 bcma_sprom_crc(const u16 *sprom)
1973 +{
1974 + int word;
1975 + u8 crc = 0xFF;
1976 +
1977 + for (word = 0; word < SSB_SPROMSIZE_WORDS_R4 - 1; word++) {
1978 + crc = bcma_crc8(crc, sprom[word] & 0x00FF);
1979 + crc = bcma_crc8(crc, (sprom[word] & 0xFF00) >> 8);
1980 + }
1981 + crc = bcma_crc8(crc, sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & 0x00FF);
1982 + crc ^= 0xFF;
1983 +
1984 + return crc;
1985 +}
1986 +
1987 +static int bcma_sprom_check_crc(const u16 *sprom)
1988 +{
1989 + u8 crc;
1990 + u8 expected_crc;
1991 + u16 tmp;
1992 +
1993 + crc = bcma_sprom_crc(sprom);
1994 + tmp = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & SSB_SPROM_REVISION_CRC;
1995 + expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
1996 + if (crc != expected_crc)
1997 + return -EPROTO;
1998 +
1999 + return 0;
2000 +}
2001 +
2002 +static int bcma_sprom_valid(const u16 *sprom)
2003 +{
2004 + u16 revision;
2005 + int err;
2006 +
2007 + err = bcma_sprom_check_crc(sprom);
2008 + if (err)
2009 + return err;
2010 +
2011 + revision = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & SSB_SPROM_REVISION_REV;
2012 + if (revision != 8 && revision != 9) {
2013 + pr_err("Unsupported SPROM revision: %d\n", revision);
2014 + return -ENOENT;
2015 + }
2016 +
2017 + return 0;
2018 +}
2019 +
2020 +/**************************************************
2021 + * SPROM extraction.
2022 + **************************************************/
2023 +
2024 +static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom)
2025 +{
2026 + u16 v;
2027 + int i;
2028 +
2029 + bus->sprom.revision = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] &
2030 + SSB_SPROM_REVISION_REV;
2031 +
2032 + for (i = 0; i < 3; i++) {
2033 + v = sprom[SPOFF(SSB_SPROM8_IL0MAC) + i];
2034 + *(((__be16 *)bus->sprom.il0mac) + i) = cpu_to_be16(v);
2035 + }
2036 +
2037 + bus->sprom.board_rev = sprom[SPOFF(SSB_SPROM8_BOARDREV)];
2038 +
2039 + bus->sprom.txpid2g[0] = (sprom[SPOFF(SSB_SPROM4_TXPID2G01)] &
2040 + SSB_SPROM4_TXPID2G0) >> SSB_SPROM4_TXPID2G0_SHIFT;
2041 + bus->sprom.txpid2g[1] = (sprom[SPOFF(SSB_SPROM4_TXPID2G01)] &
2042 + SSB_SPROM4_TXPID2G1) >> SSB_SPROM4_TXPID2G1_SHIFT;
2043 + bus->sprom.txpid2g[2] = (sprom[SPOFF(SSB_SPROM4_TXPID2G23)] &
2044 + SSB_SPROM4_TXPID2G2) >> SSB_SPROM4_TXPID2G2_SHIFT;
2045 + bus->sprom.txpid2g[3] = (sprom[SPOFF(SSB_SPROM4_TXPID2G23)] &
2046 + SSB_SPROM4_TXPID2G3) >> SSB_SPROM4_TXPID2G3_SHIFT;
2047 +
2048 + bus->sprom.txpid5gl[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL01)] &
2049 + SSB_SPROM4_TXPID5GL0) >> SSB_SPROM4_TXPID5GL0_SHIFT;
2050 + bus->sprom.txpid5gl[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL01)] &
2051 + SSB_SPROM4_TXPID5GL1) >> SSB_SPROM4_TXPID5GL1_SHIFT;
2052 + bus->sprom.txpid5gl[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL23)] &
2053 + SSB_SPROM4_TXPID5GL2) >> SSB_SPROM4_TXPID5GL2_SHIFT;
2054 + bus->sprom.txpid5gl[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL23)] &
2055 + SSB_SPROM4_TXPID5GL3) >> SSB_SPROM4_TXPID5GL3_SHIFT;
2056 +
2057 + bus->sprom.txpid5g[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5G01)] &
2058 + SSB_SPROM4_TXPID5G0) >> SSB_SPROM4_TXPID5G0_SHIFT;
2059 + bus->sprom.txpid5g[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5G01)] &
2060 + SSB_SPROM4_TXPID5G1) >> SSB_SPROM4_TXPID5G1_SHIFT;
2061 + bus->sprom.txpid5g[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5G23)] &
2062 + SSB_SPROM4_TXPID5G2) >> SSB_SPROM4_TXPID5G2_SHIFT;
2063 + bus->sprom.txpid5g[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5G23)] &
2064 + SSB_SPROM4_TXPID5G3) >> SSB_SPROM4_TXPID5G3_SHIFT;
2065 +
2066 + bus->sprom.txpid5gh[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH01)] &
2067 + SSB_SPROM4_TXPID5GH0) >> SSB_SPROM4_TXPID5GH0_SHIFT;
2068 + bus->sprom.txpid5gh[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH01)] &
2069 + SSB_SPROM4_TXPID5GH1) >> SSB_SPROM4_TXPID5GH1_SHIFT;
2070 + bus->sprom.txpid5gh[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH23)] &
2071 + SSB_SPROM4_TXPID5GH2) >> SSB_SPROM4_TXPID5GH2_SHIFT;
2072 + bus->sprom.txpid5gh[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH23)] &
2073 + SSB_SPROM4_TXPID5GH3) >> SSB_SPROM4_TXPID5GH3_SHIFT;
2074 +
2075 + bus->sprom.boardflags_lo = sprom[SPOFF(SSB_SPROM8_BFLLO)];
2076 + bus->sprom.boardflags_hi = sprom[SPOFF(SSB_SPROM8_BFLHI)];
2077 + bus->sprom.boardflags2_lo = sprom[SPOFF(SSB_SPROM8_BFL2LO)];
2078 + bus->sprom.boardflags2_hi = sprom[SPOFF(SSB_SPROM8_BFL2HI)];
2079 +
2080 + bus->sprom.country_code = sprom[SPOFF(SSB_SPROM8_CCODE)];
2081 +
2082 + bus->sprom.fem.ghz2.tssipos = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
2083 + SSB_SROM8_FEM_TSSIPOS) >> SSB_SROM8_FEM_TSSIPOS_SHIFT;
2084 + bus->sprom.fem.ghz2.extpa_gain = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
2085 + SSB_SROM8_FEM_EXTPA_GAIN) >> SSB_SROM8_FEM_EXTPA_GAIN_SHIFT;
2086 + bus->sprom.fem.ghz2.pdet_range = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
2087 + SSB_SROM8_FEM_PDET_RANGE) >> SSB_SROM8_FEM_PDET_RANGE_SHIFT;
2088 + bus->sprom.fem.ghz2.tr_iso = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
2089 + SSB_SROM8_FEM_TR_ISO) >> SSB_SROM8_FEM_TR_ISO_SHIFT;
2090 + bus->sprom.fem.ghz2.antswlut = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
2091 + SSB_SROM8_FEM_ANTSWLUT) >> SSB_SROM8_FEM_ANTSWLUT_SHIFT;
2092 +
2093 + bus->sprom.fem.ghz5.tssipos = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
2094 + SSB_SROM8_FEM_TSSIPOS) >> SSB_SROM8_FEM_TSSIPOS_SHIFT;
2095 + bus->sprom.fem.ghz5.extpa_gain = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
2096 + SSB_SROM8_FEM_EXTPA_GAIN) >> SSB_SROM8_FEM_EXTPA_GAIN_SHIFT;
2097 + bus->sprom.fem.ghz5.pdet_range = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
2098 + SSB_SROM8_FEM_PDET_RANGE) >> SSB_SROM8_FEM_PDET_RANGE_SHIFT;
2099 + bus->sprom.fem.ghz5.tr_iso = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
2100 + SSB_SROM8_FEM_TR_ISO) >> SSB_SROM8_FEM_TR_ISO_SHIFT;
2101 + bus->sprom.fem.ghz5.antswlut = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
2102 + SSB_SROM8_FEM_ANTSWLUT) >> SSB_SROM8_FEM_ANTSWLUT_SHIFT;
2103 +}
2104 +
2105 +int bcma_sprom_get(struct bcma_bus *bus)
2106 +{
2107 + u16 offset;
2108 + u16 *sprom;
2109 + int err = 0;
2110 +
2111 + if (!bus->drv_cc.core)
2112 + return -EOPNOTSUPP;
2113 +
2114 + if (!(bus->drv_cc.capabilities & BCMA_CC_CAP_SPROM))
2115 + return -ENOENT;
2116 +
2117 + sprom = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
2118 + GFP_KERNEL);
2119 + if (!sprom)
2120 + return -ENOMEM;
2121 +
2122 + if (bus->chipinfo.id == 0x4331)
2123 + bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, false);
2124 +
2125 + /* Most cards have SPROM moved by additional offset 0x30 (48 dwords).
2126 + * According to brcm80211 this applies to cards with PCIe rev >= 6
2127 + * TODO: understand this condition and use it */
2128 + offset = (bus->chipinfo.id == 0x4331) ? BCMA_CC_SPROM :
2129 + BCMA_CC_SPROM_PCIE6;
2130 + bcma_sprom_read(bus, offset, sprom);
2131 +
2132 + if (bus->chipinfo.id == 0x4331)
2133 + bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, true);
2134 +
2135 + err = bcma_sprom_valid(sprom);
2136 + if (err)
2137 + goto out;
2138 +
2139 + bcma_sprom_extract_r8(bus, sprom);
2140 +
2141 +out:
2142 + kfree(sprom);
2143 + return err;
2144 +}
2145 --- a/include/linux/bcma/bcma.h
2146 +++ b/include/linux/bcma/bcma.h
2147 @@ -6,6 +6,8 @@
2148
2149 #include <linux/bcma/bcma_driver_chipcommon.h>
2150 #include <linux/bcma/bcma_driver_pci.h>
2151 +#include <linux/bcma/bcma_driver_mips.h>
2152 +#include <linux/ssb/ssb.h> /* SPROM sharing */
2153
2154 #include "bcma_regs.h"
2155
2156 @@ -13,9 +15,9 @@ struct bcma_device;
2157 struct bcma_bus;
2158
2159 enum bcma_hosttype {
2160 - BCMA_HOSTTYPE_NONE,
2161 BCMA_HOSTTYPE_PCI,
2162 BCMA_HOSTTYPE_SDIO,
2163 + BCMA_HOSTTYPE_SOC,
2164 };
2165
2166 struct bcma_chipinfo {
2167 @@ -24,6 +26,11 @@ struct bcma_chipinfo {
2168 u8 pkg;
2169 };
2170
2171 +enum bcma_clkmode {
2172 + BCMA_CLKMODE_FAST,
2173 + BCMA_CLKMODE_DYNAMIC,
2174 +};
2175 +
2176 struct bcma_host_ops {
2177 u8 (*read8)(struct bcma_device *core, u16 offset);
2178 u16 (*read16)(struct bcma_device *core, u16 offset);
2179 @@ -31,6 +38,12 @@ struct bcma_host_ops {
2180 void (*write8)(struct bcma_device *core, u16 offset, u8 value);
2181 void (*write16)(struct bcma_device *core, u16 offset, u16 value);
2182 void (*write32)(struct bcma_device *core, u16 offset, u32 value);
2183 +#ifdef CONFIG_BCMA_BLOCKIO
2184 + void (*block_read)(struct bcma_device *core, void *buffer,
2185 + size_t count, u16 offset, u8 reg_width);
2186 + void (*block_write)(struct bcma_device *core, const void *buffer,
2187 + size_t count, u16 offset, u8 reg_width);
2188 +#endif
2189 /* Agent ops */
2190 u32 (*aread32)(struct bcma_device *core, u16 offset);
2191 void (*awrite32)(struct bcma_device *core, u16 offset, u32 value);
2192 @@ -117,6 +130,9 @@ struct bcma_device {
2193 struct bcma_device_id id;
2194
2195 struct device dev;
2196 + struct device *dma_dev;
2197 +
2198 + unsigned int irq;
2199 bool dev_registered;
2200
2201 u8 core_index;
2202 @@ -124,6 +140,9 @@ struct bcma_device {
2203 u32 addr;
2204 u32 wrap;
2205
2206 + void __iomem *io_addr;
2207 + void __iomem *io_wrap;
2208 +
2209 void *drvdata;
2210 struct list_head list;
2211 };
2212 @@ -151,10 +170,9 @@ struct bcma_driver {
2213 };
2214 extern
2215 int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
2216 -static inline int bcma_driver_register(struct bcma_driver *drv)
2217 -{
2218 - return __bcma_driver_register(drv, THIS_MODULE);
2219 -}
2220 +#define bcma_driver_register(drv) \
2221 + __bcma_driver_register(drv, THIS_MODULE)
2222 +
2223 extern void bcma_driver_unregister(struct bcma_driver *drv);
2224
2225 struct bcma_bus {
2226 @@ -176,49 +194,105 @@ struct bcma_bus {
2227 struct bcma_device *mapped_core;
2228 struct list_head cores;
2229 u8 nr_cores;
2230 + u8 init_done:1;
2231
2232 struct bcma_drv_cc drv_cc;
2233 struct bcma_drv_pci drv_pci;
2234 + struct bcma_drv_mips drv_mips;
2235 +
2236 + /* We decided to share SPROM struct with SSB as long as we do not need
2237 + * any hacks for BCMA. This simplifies drivers code. */
2238 + struct ssb_sprom sprom;
2239 };
2240
2241 -extern inline u32 bcma_read8(struct bcma_device *core, u16 offset)
2242 +static inline u32 bcma_read8(struct bcma_device *core, u16 offset)
2243 {
2244 return core->bus->ops->read8(core, offset);
2245 }
2246 -extern inline u32 bcma_read16(struct bcma_device *core, u16 offset)
2247 +static inline u32 bcma_read16(struct bcma_device *core, u16 offset)
2248 {
2249 return core->bus->ops->read16(core, offset);
2250 }
2251 -extern inline u32 bcma_read32(struct bcma_device *core, u16 offset)
2252 +static inline u32 bcma_read32(struct bcma_device *core, u16 offset)
2253 {
2254 return core->bus->ops->read32(core, offset);
2255 }
2256 -extern inline
2257 +static inline
2258 void bcma_write8(struct bcma_device *core, u16 offset, u32 value)
2259 {
2260 core->bus->ops->write8(core, offset, value);
2261 }
2262 -extern inline
2263 +static inline
2264 void bcma_write16(struct bcma_device *core, u16 offset, u32 value)
2265 {
2266 core->bus->ops->write16(core, offset, value);
2267 }
2268 -extern inline
2269 +static inline
2270 void bcma_write32(struct bcma_device *core, u16 offset, u32 value)
2271 {
2272 core->bus->ops->write32(core, offset, value);
2273 }
2274 -extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
2275 +#ifdef CONFIG_BCMA_BLOCKIO
2276 +static inline void bcma_block_read(struct bcma_device *core, void *buffer,
2277 + size_t count, u16 offset, u8 reg_width)
2278 +{
2279 + core->bus->ops->block_read(core, buffer, count, offset, reg_width);
2280 +}
2281 +static inline void bcma_block_write(struct bcma_device *core,
2282 + const void *buffer, size_t count,
2283 + u16 offset, u8 reg_width)
2284 +{
2285 + core->bus->ops->block_write(core, buffer, count, offset, reg_width);
2286 +}
2287 +#endif
2288 +static inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
2289 {
2290 return core->bus->ops->aread32(core, offset);
2291 }
2292 -extern inline
2293 +static inline
2294 void bcma_awrite32(struct bcma_device *core, u16 offset, u32 value)
2295 {
2296 core->bus->ops->awrite32(core, offset, value);
2297 }
2298
2299 +static inline void bcma_mask32(struct bcma_device *cc, u16 offset, u32 mask)
2300 +{
2301 + bcma_write32(cc, offset, bcma_read32(cc, offset) & mask);
2302 +}
2303 +static inline void bcma_set32(struct bcma_device *cc, u16 offset, u32 set)
2304 +{
2305 + bcma_write32(cc, offset, bcma_read32(cc, offset) | set);
2306 +}
2307 +static inline void bcma_maskset32(struct bcma_device *cc,
2308 + u16 offset, u32 mask, u32 set)
2309 +{
2310 + bcma_write32(cc, offset, (bcma_read32(cc, offset) & mask) | set);
2311 +}
2312 +static inline void bcma_mask16(struct bcma_device *cc, u16 offset, u16 mask)
2313 +{
2314 + bcma_write16(cc, offset, bcma_read16(cc, offset) & mask);
2315 +}
2316 +static inline void bcma_set16(struct bcma_device *cc, u16 offset, u16 set)
2317 +{
2318 + bcma_write16(cc, offset, bcma_read16(cc, offset) | set);
2319 +}
2320 +static inline void bcma_maskset16(struct bcma_device *cc,
2321 + u16 offset, u16 mask, u16 set)
2322 +{
2323 + bcma_write16(cc, offset, (bcma_read16(cc, offset) & mask) | set);
2324 +}
2325 +
2326 extern bool bcma_core_is_enabled(struct bcma_device *core);
2327 +extern void bcma_core_disable(struct bcma_device *core, u32 flags);
2328 extern int bcma_core_enable(struct bcma_device *core, u32 flags);
2329 +extern void bcma_core_set_clockmode(struct bcma_device *core,
2330 + enum bcma_clkmode clkmode);
2331 +extern void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status,
2332 + bool on);
2333 +#define BCMA_DMA_TRANSLATION_MASK 0xC0000000
2334 +#define BCMA_DMA_TRANSLATION_NONE 0x00000000
2335 +#define BCMA_DMA_TRANSLATION_DMA32_CMT 0x40000000 /* Client Mode Translation for 32-bit DMA */
2336 +#define BCMA_DMA_TRANSLATION_DMA64_CMT 0x80000000 /* Client Mode Translation for 64-bit DMA */
2337 +extern u32 bcma_core_dma_translation(struct bcma_device *core);
2338
2339 #endif /* LINUX_BCMA_H_ */
2340 --- a/include/linux/bcma/bcma_driver_chipcommon.h
2341 +++ b/include/linux/bcma/bcma_driver_chipcommon.h
2342 @@ -24,6 +24,7 @@
2343 #define BCMA_CC_FLASHT_NONE 0x00000000 /* No flash */
2344 #define BCMA_CC_FLASHT_STSER 0x00000100 /* ST serial flash */
2345 #define BCMA_CC_FLASHT_ATSER 0x00000200 /* Atmel serial flash */
2346 +#define BCMA_CC_FLASHT_NFLASH 0x00000200
2347 #define BCMA_CC_FLASHT_PARA 0x00000700 /* Parallel flash */
2348 #define BCMA_CC_CAP_PLLT 0x00038000 /* PLL Type */
2349 #define BCMA_PLLTYPE_NONE 0x00000000
2350 @@ -178,16 +179,9 @@
2351 #define BCMA_CC_PROG_CFG 0x0120
2352 #define BCMA_CC_PROG_WAITCNT 0x0124
2353 #define BCMA_CC_FLASH_CFG 0x0128
2354 +#define BCMA_CC_FLASH_CFG_DS 0x0010 /* Data size, 0=8bit, 1=16bit */
2355 #define BCMA_CC_FLASH_WAITCNT 0x012C
2356 -#define BCMA_CC_CLKCTLST 0x01E0 /* Clock control and status (rev >= 20) */
2357 -#define BCMA_CC_CLKCTLST_FORCEALP 0x00000001 /* Force ALP request */
2358 -#define BCMA_CC_CLKCTLST_FORCEHT 0x00000002 /* Force HT request */
2359 -#define BCMA_CC_CLKCTLST_FORCEILP 0x00000004 /* Force ILP request */
2360 -#define BCMA_CC_CLKCTLST_HAVEALPREQ 0x00000008 /* ALP available request */
2361 -#define BCMA_CC_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */
2362 -#define BCMA_CC_CLKCTLST_HWCROFF 0x00000020 /* Force HW clock request off */
2363 -#define BCMA_CC_CLKCTLST_HAVEHT 0x00010000 /* HT available */
2364 -#define BCMA_CC_CLKCTLST_HAVEALP 0x00020000 /* APL available */
2365 +/* 0x1E0 is defined as shared BCMA_CLKCTLST */
2366 #define BCMA_CC_HW_WORKAROUND 0x01E4 /* Hardware workaround (rev >= 20) */
2367 #define BCMA_CC_UART0_DATA 0x0300
2368 #define BCMA_CC_UART0_IMR 0x0304
2369 @@ -209,6 +203,7 @@
2370 #define BCMA_CC_PMU_CTL 0x0600 /* PMU control */
2371 #define BCMA_CC_PMU_CTL_ILP_DIV 0xFFFF0000 /* ILP div mask */
2372 #define BCMA_CC_PMU_CTL_ILP_DIV_SHIFT 16
2373 +#define BCMA_CC_PMU_CTL_PLL_UPD 0x00000400
2374 #define BCMA_CC_PMU_CTL_NOILPONW 0x00000200 /* No ILP on wait */
2375 #define BCMA_CC_PMU_CTL_HTREQEN 0x00000100 /* HT req enable */
2376 #define BCMA_CC_PMU_CTL_ALPREQEN 0x00000080 /* ALP req enable */
2377 @@ -244,6 +239,66 @@
2378 #define BCMA_CC_REGCTL_DATA 0x065C
2379 #define BCMA_CC_PLLCTL_ADDR 0x0660
2380 #define BCMA_CC_PLLCTL_DATA 0x0664
2381 +#define BCMA_CC_SPROM 0x0800 /* SPROM beginning */
2382 +#define BCMA_CC_SPROM_PCIE6 0x0830 /* SPROM beginning on PCIe rev >= 6 */
2383 +
2384 +/* Divider allocation in 4716/47162/5356 */
2385 +#define BCMA_CC_PMU5_MAINPLL_CPU 1
2386 +#define BCMA_CC_PMU5_MAINPLL_MEM 2
2387 +#define BCMA_CC_PMU5_MAINPLL_SSB 3
2388 +
2389 +/* PLL usage in 4716/47162 */
2390 +#define BCMA_CC_PMU4716_MAINPLL_PLL0 12
2391 +
2392 +/* PLL usage in 5356/5357 */
2393 +#define BCMA_CC_PMU5356_MAINPLL_PLL0 0
2394 +#define BCMA_CC_PMU5357_MAINPLL_PLL0 0
2395 +
2396 +/* 4706 PMU */
2397 +#define BCMA_CC_PMU4706_MAINPLL_PLL0 0
2398 +
2399 +/* ALP clock on pre-PMU chips */
2400 +#define BCMA_CC_PMU_ALP_CLOCK 20000000
2401 +/* HT clock for systems with PMU-enabled chipcommon */
2402 +#define BCMA_CC_PMU_HT_CLOCK 80000000
2403 +
2404 +/* PMU rev 5 (& 6) */
2405 +#define BCMA_CC_PPL_P1P2_OFF 0
2406 +#define BCMA_CC_PPL_P1_MASK 0x0f000000
2407 +#define BCMA_CC_PPL_P1_SHIFT 24
2408 +#define BCMA_CC_PPL_P2_MASK 0x00f00000
2409 +#define BCMA_CC_PPL_P2_SHIFT 20
2410 +#define BCMA_CC_PPL_M14_OFF 1
2411 +#define BCMA_CC_PPL_MDIV_MASK 0x000000ff
2412 +#define BCMA_CC_PPL_MDIV_WIDTH 8
2413 +#define BCMA_CC_PPL_NM5_OFF 2
2414 +#define BCMA_CC_PPL_NDIV_MASK 0xfff00000
2415 +#define BCMA_CC_PPL_NDIV_SHIFT 20
2416 +#define BCMA_CC_PPL_FMAB_OFF 3
2417 +#define BCMA_CC_PPL_MRAT_MASK 0xf0000000
2418 +#define BCMA_CC_PPL_MRAT_SHIFT 28
2419 +#define BCMA_CC_PPL_ABRAT_MASK 0x08000000
2420 +#define BCMA_CC_PPL_ABRAT_SHIFT 27
2421 +#define BCMA_CC_PPL_FDIV_MASK 0x07ffffff
2422 +#define BCMA_CC_PPL_PLLCTL_OFF 4
2423 +#define BCMA_CC_PPL_PCHI_OFF 5
2424 +#define BCMA_CC_PPL_PCHI_MASK 0x0000003f
2425 +
2426 +/* BCM4331 ChipControl numbers. */
2427 +#define BCMA_CHIPCTL_4331_BT_COEXIST BIT(0) /* 0 disable */
2428 +#define BCMA_CHIPCTL_4331_SECI BIT(1) /* 0 SECI is disabled (JATG functional) */
2429 +#define BCMA_CHIPCTL_4331_EXT_LNA BIT(2) /* 0 disable */
2430 +#define BCMA_CHIPCTL_4331_SPROM_GPIO13_15 BIT(3) /* sprom/gpio13-15 mux */
2431 +#define BCMA_CHIPCTL_4331_EXTPA_EN BIT(4) /* 0 ext pa disable, 1 ext pa enabled */
2432 +#define BCMA_CHIPCTL_4331_GPIOCLK_ON_SPROMCS BIT(5) /* set drive out GPIO_CLK on sprom_cs pin */
2433 +#define BCMA_CHIPCTL_4331_PCIE_MDIO_ON_SPROMCS BIT(6) /* use sprom_cs pin as PCIE mdio interface */
2434 +#define BCMA_CHIPCTL_4331_EXTPA_ON_GPIO2_5 BIT(7) /* aband extpa will be at gpio2/5 and sprom_dout */
2435 +#define BCMA_CHIPCTL_4331_OVR_PIPEAUXCLKEN BIT(8) /* override core control on pipe_AuxClkEnable */
2436 +#define BCMA_CHIPCTL_4331_OVR_PIPEAUXPWRDOWN BIT(9) /* override core control on pipe_AuxPowerDown */
2437 +#define BCMA_CHIPCTL_4331_PCIE_AUXCLKEN BIT(10) /* pcie_auxclkenable */
2438 +#define BCMA_CHIPCTL_4331_PCIE_PIPE_PLLDOWN BIT(11) /* pcie_pipe_pllpowerdown */
2439 +#define BCMA_CHIPCTL_4331_BT_SHD0_ON_GPIO4 BIT(16) /* enable bt_shd0 at gpio4 */
2440 +#define BCMA_CHIPCTL_4331_BT_SHD1_ON_GPIO5 BIT(17) /* enable bt_shd1 at gpio5 */
2441
2442 /* Data for the PMU, if available.
2443 * Check availability with ((struct bcma_chipcommon)->capabilities & BCMA_CC_CAP_PMU)
2444 @@ -253,14 +308,37 @@ struct bcma_chipcommon_pmu {
2445 u32 crystalfreq; /* The active crystal frequency (in kHz) */
2446 };
2447
2448 +#ifdef CONFIG_BCMA_DRIVER_MIPS
2449 +struct bcma_pflash {
2450 + u8 buswidth;
2451 + u32 window;
2452 + u32 window_size;
2453 +};
2454 +
2455 +struct bcma_serial_port {
2456 + void *regs;
2457 + unsigned long clockspeed;
2458 + unsigned int irq;
2459 + unsigned int baud_base;
2460 + unsigned int reg_shift;
2461 +};
2462 +#endif /* CONFIG_BCMA_DRIVER_MIPS */
2463 +
2464 struct bcma_drv_cc {
2465 struct bcma_device *core;
2466 u32 status;
2467 u32 capabilities;
2468 u32 capabilities_ext;
2469 + u8 setup_done:1;
2470 /* Fast Powerup Delay constant */
2471 u16 fast_pwrup_delay;
2472 struct bcma_chipcommon_pmu pmu;
2473 +#ifdef CONFIG_BCMA_DRIVER_MIPS
2474 + struct bcma_pflash pflash;
2475 +
2476 + int nr_serial_ports;
2477 + struct bcma_serial_port serial_ports[4];
2478 +#endif /* CONFIG_BCMA_DRIVER_MIPS */
2479 };
2480
2481 /* Register access */
2482 @@ -281,6 +359,8 @@ extern void bcma_core_chipcommon_init(st
2483 extern void bcma_chipco_suspend(struct bcma_drv_cc *cc);
2484 extern void bcma_chipco_resume(struct bcma_drv_cc *cc);
2485
2486 +void bcma_chipco_bcm4331_ext_pa_lines_ctl(struct bcma_drv_cc *cc, bool enable);
2487 +
2488 extern void bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc,
2489 u32 ticks);
2490
2491 @@ -299,4 +379,13 @@ u32 bcma_chipco_gpio_polarity(struct bcm
2492 /* PMU support */
2493 extern void bcma_pmu_init(struct bcma_drv_cc *cc);
2494
2495 +extern void bcma_chipco_pll_write(struct bcma_drv_cc *cc, u32 offset,
2496 + u32 value);
2497 +extern void bcma_chipco_pll_maskset(struct bcma_drv_cc *cc, u32 offset,
2498 + u32 mask, u32 set);
2499 +extern void bcma_chipco_chipctl_maskset(struct bcma_drv_cc *cc,
2500 + u32 offset, u32 mask, u32 set);
2501 +extern void bcma_chipco_regctl_maskset(struct bcma_drv_cc *cc,
2502 + u32 offset, u32 mask, u32 set);
2503 +
2504 #endif /* LINUX_BCMA_DRIVER_CC_H_ */
2505 --- /dev/null
2506 +++ b/include/linux/bcma/bcma_driver_mips.h
2507 @@ -0,0 +1,51 @@
2508 +#ifndef LINUX_BCMA_DRIVER_MIPS_H_
2509 +#define LINUX_BCMA_DRIVER_MIPS_H_
2510 +
2511 +#define BCMA_MIPS_IPSFLAG 0x0F08
2512 +/* which sbflags get routed to mips interrupt 1 */
2513 +#define BCMA_MIPS_IPSFLAG_IRQ1 0x0000003F
2514 +#define BCMA_MIPS_IPSFLAG_IRQ1_SHIFT 0
2515 +/* which sbflags get routed to mips interrupt 2 */
2516 +#define BCMA_MIPS_IPSFLAG_IRQ2 0x00003F00
2517 +#define BCMA_MIPS_IPSFLAG_IRQ2_SHIFT 8
2518 +/* which sbflags get routed to mips interrupt 3 */
2519 +#define BCMA_MIPS_IPSFLAG_IRQ3 0x003F0000
2520 +#define BCMA_MIPS_IPSFLAG_IRQ3_SHIFT 16
2521 +/* which sbflags get routed to mips interrupt 4 */
2522 +#define BCMA_MIPS_IPSFLAG_IRQ4 0x3F000000
2523 +#define BCMA_MIPS_IPSFLAG_IRQ4_SHIFT 24
2524 +
2525 +/* MIPS 74K core registers */
2526 +#define BCMA_MIPS_MIPS74K_CORECTL 0x0000
2527 +#define BCMA_MIPS_MIPS74K_EXCEPTBASE 0x0004
2528 +#define BCMA_MIPS_MIPS74K_BIST 0x000C
2529 +#define BCMA_MIPS_MIPS74K_INTMASK_INT0 0x0014
2530 +#define BCMA_MIPS_MIPS74K_INTMASK(int) \
2531 + ((int) * 4 + BCMA_MIPS_MIPS74K_INTMASK_INT0)
2532 +#define BCMA_MIPS_MIPS74K_NMIMASK 0x002C
2533 +#define BCMA_MIPS_MIPS74K_GPIOSEL 0x0040
2534 +#define BCMA_MIPS_MIPS74K_GPIOOUT 0x0044
2535 +#define BCMA_MIPS_MIPS74K_GPIOEN 0x0048
2536 +#define BCMA_MIPS_MIPS74K_CLKCTLST 0x01E0
2537 +
2538 +#define BCMA_MIPS_OOBSELOUTA30 0x100
2539 +
2540 +struct bcma_device;
2541 +
2542 +struct bcma_drv_mips {
2543 + struct bcma_device *core;
2544 + u8 setup_done:1;
2545 + unsigned int assigned_irqs;
2546 +};
2547 +
2548 +#ifdef CONFIG_BCMA_DRIVER_MIPS
2549 +extern void bcma_core_mips_init(struct bcma_drv_mips *mcore);
2550 +#else
2551 +static inline void bcma_core_mips_init(struct bcma_drv_mips *mcore) { }
2552 +#endif
2553 +
2554 +extern u32 bcma_cpu_clock(struct bcma_drv_mips *mcore);
2555 +
2556 +extern unsigned int bcma_core_mips_irq(struct bcma_device *dev);
2557 +
2558 +#endif /* LINUX_BCMA_DRIVER_MIPS_H_ */
2559 --- a/include/linux/bcma/bcma_driver_pci.h
2560 +++ b/include/linux/bcma/bcma_driver_pci.h
2561 @@ -85,5 +85,7 @@ struct bcma_drv_pci {
2562 #define pcicore_write32(pc, offset, val) bcma_write32((pc)->core, offset, val)
2563
2564 extern void bcma_core_pci_init(struct bcma_drv_pci *pc);
2565 +extern int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc,
2566 + struct bcma_device *core, bool enable);
2567
2568 #endif /* LINUX_BCMA_DRIVER_PCI_H_ */
2569 --- a/include/linux/bcma/bcma_regs.h
2570 +++ b/include/linux/bcma/bcma_regs.h
2571 @@ -1,13 +1,38 @@
2572 #ifndef LINUX_BCMA_REGS_H_
2573 #define LINUX_BCMA_REGS_H_
2574
2575 +/* Some single registers are shared between many cores */
2576 +/* BCMA_CLKCTLST: ChipCommon (rev >= 20), PCIe, 80211 */
2577 +#define BCMA_CLKCTLST 0x01E0 /* Clock control and status */
2578 +#define BCMA_CLKCTLST_FORCEALP 0x00000001 /* Force ALP request */
2579 +#define BCMA_CLKCTLST_FORCEHT 0x00000002 /* Force HT request */
2580 +#define BCMA_CLKCTLST_FORCEILP 0x00000004 /* Force ILP request */
2581 +#define BCMA_CLKCTLST_HAVEALPREQ 0x00000008 /* ALP available request */
2582 +#define BCMA_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */
2583 +#define BCMA_CLKCTLST_HWCROFF 0x00000020 /* Force HW clock request off */
2584 +#define BCMA_CLKCTLST_EXTRESREQ 0x00000700 /* Mask of external resource requests */
2585 +#define BCMA_CLKCTLST_HAVEALP 0x00010000 /* ALP available */
2586 +#define BCMA_CLKCTLST_HAVEHT 0x00020000 /* HT available */
2587 +#define BCMA_CLKCTLST_BP_ON_ALP 0x00040000 /* RO: running on ALP clock */
2588 +#define BCMA_CLKCTLST_BP_ON_HT 0x00080000 /* RO: running on HT clock */
2589 +#define BCMA_CLKCTLST_EXTRESST 0x07000000 /* Mask of external resource status */
2590 +/* Is there any BCM4328 on BCMA bus? */
2591 +#define BCMA_CLKCTLST_4328A0_HAVEHT 0x00010000 /* 4328a0 has reversed bits */
2592 +#define BCMA_CLKCTLST_4328A0_HAVEALP 0x00020000 /* 4328a0 has reversed bits */
2593 +
2594 /* Agent registers (common for every core) */
2595 -#define BCMA_IOCTL 0x0408
2596 +#define BCMA_IOCTL 0x0408 /* IO control */
2597 #define BCMA_IOCTL_CLK 0x0001
2598 #define BCMA_IOCTL_FGC 0x0002
2599 #define BCMA_IOCTL_CORE_BITS 0x3FFC
2600 #define BCMA_IOCTL_PME_EN 0x4000
2601 #define BCMA_IOCTL_BIST_EN 0x8000
2602 +#define BCMA_IOST 0x0500 /* IO status */
2603 +#define BCMA_IOST_CORE_BITS 0x0FFF
2604 +#define BCMA_IOST_DMA64 0x1000
2605 +#define BCMA_IOST_GATED_CLK 0x2000
2606 +#define BCMA_IOST_BIST_ERROR 0x4000
2607 +#define BCMA_IOST_BIST_DONE 0x8000
2608 #define BCMA_RESET_CTL 0x0800
2609 #define BCMA_RESET_CTL_RESET 0x0001
2610
2611 --- /dev/null
2612 +++ b/include/linux/bcma/bcma_soc.h
2613 @@ -0,0 +1,16 @@
2614 +#ifndef LINUX_BCMA_SOC_H_
2615 +#define LINUX_BCMA_SOC_H_
2616 +
2617 +#include <linux/bcma/bcma.h>
2618 +
2619 +struct bcma_soc {
2620 + struct bcma_bus bus;
2621 + struct bcma_device core_cc;
2622 + struct bcma_device core_mips;
2623 +};
2624 +
2625 +int __init bcma_host_soc_register(struct bcma_soc *soc);
2626 +
2627 +int bcma_bus_register(struct bcma_bus *bus);
2628 +
2629 +#endif /* LINUX_BCMA_SOC_H_ */
Personal OpenWRT clone
This page took 0.1698 seconds and 5 git commands to generate.