projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ar71xx: ag71xx: don't use port 4 of the switch, it is not connected on ar724x
[openwrt.git] / target / linux / generic / patches-2.6.31 / 025-bcma_backport.patch
1 --- /dev/null
2 +++ b/Documentation/ABI/testing/sysfs-bus-bcma
3 @@ -0,0 +1,31 @@
4 +What: /sys/bus/bcma/devices/.../manuf
5 +Date: May 2011
6 +KernelVersion: 2.6.40
7 +Contact: Rafał Miłecki <zajec5@gmail.com>
8 +Description:
9 + Each BCMA core has it's manufacturer id. See
10 + include/linux/bcma/bcma.h for possible values.
11 +
12 +What: /sys/bus/bcma/devices/.../id
13 +Date: May 2011
14 +KernelVersion: 2.6.40
15 +Contact: Rafał Miłecki <zajec5@gmail.com>
16 +Description:
17 + There are a few types of BCMA cores, they can be identified by
18 + id field.
19 +
20 +What: /sys/bus/bcma/devices/.../rev
21 +Date: May 2011
22 +KernelVersion: 2.6.40
23 +Contact: Rafał Miłecki <zajec5@gmail.com>
24 +Description:
25 + BCMA cores of the same type can still slightly differ depending
26 + on their revision. Use it for detailed programming.
27 +
28 +What: /sys/bus/bcma/devices/.../class
29 +Date: May 2011
30 +KernelVersion: 2.6.40
31 +Contact: Rafał Miłecki <zajec5@gmail.com>
32 +Description:
33 + Each BCMA core is identified by few fields, including class it
34 + belongs to. See include/linux/bcma/bcma.h for possible values.
35 --- a/MAINTAINERS
36 +++ b/MAINTAINERS
37 @@ -4716,6 +4716,13 @@ S: Maintained
38 F: drivers/ssb/
39 F: include/linux/ssb/
40
41 +BROADCOM SPECIFIC AMBA DRIVER (BCMA)
42 +M: Rafał Miłecki <zajec5@gmail.com>
43 +L: linux-wireless@vger.kernel.org
44 +S: Maintained
45 +F: drivers/bcma/
46 +F: include/linux/bcma/
47 +
48 SONY VAIO CONTROL DEVICE DRIVER
49 M: Mattia Dongili <malattia@linux.it>
50 L: linux-acpi@vger.kernel.org
51 --- a/drivers/Kconfig
52 +++ b/drivers/Kconfig
53 @@ -68,6 +68,8 @@ source "drivers/watchdog/Kconfig"
54
55 source "drivers/ssb/Kconfig"
56
57 +source "drivers/bcma/Kconfig"
58 +
59 source "drivers/mfd/Kconfig"
60
61 source "drivers/regulator/Kconfig"
62 --- a/drivers/Makefile
63 +++ b/drivers/Makefile
64 @@ -105,6 +105,7 @@ obj-$(CONFIG_HID) += hid/
65 obj-$(CONFIG_PPC_PS3) += ps3/
66 obj-$(CONFIG_OF) += of/
67 obj-$(CONFIG_SSB) += ssb/
68 +obj-$(CONFIG_BCMA) += bcma/
69 obj-$(CONFIG_VIRTIO) += virtio/
70 obj-$(CONFIG_VLYNQ) += vlynq/
71 obj-$(CONFIG_STAGING) += staging/
72 --- /dev/null
73 +++ b/drivers/bcma/Kconfig
74 @@ -0,0 +1,44 @@
75 +config BCMA_POSSIBLE
76 + bool
77 + depends on HAS_IOMEM && HAS_DMA
78 + default y
79 +
80 +menu "Broadcom specific AMBA"
81 + depends on BCMA_POSSIBLE
82 +
83 +config BCMA
84 + tristate "BCMA support"
85 + depends on BCMA_POSSIBLE
86 + help
87 + Bus driver for Broadcom specific Advanced Microcontroller Bus
88 + Architecture.
89 +
90 +# Support for Block-I/O. SELECT this from the driver that needs it.
91 +config BCMA_BLOCKIO
92 + bool
93 + depends on BCMA
94 +
95 +config BCMA_HOST_PCI_POSSIBLE
96 + bool
97 + depends on BCMA && PCI = y
98 + default y
99 +
100 +config BCMA_HOST_PCI
101 + bool "Support for BCMA on PCI-host bus"
102 + depends on BCMA_HOST_PCI_POSSIBLE
103 +
104 +config BCMA_DRIVER_PCI_HOSTMODE
105 + bool "Driver for PCI core working in hostmode"
106 + depends on BCMA && MIPS
107 + help
108 + PCI core hostmode operation (external PCI bus).
109 +
110 +config BCMA_DEBUG
111 + bool "BCMA debugging"
112 + depends on BCMA
113 + help
114 + This turns on additional debugging messages.
115 +
116 + If unsure, say N
117 +
118 +endmenu
119 --- /dev/null
120 +++ b/drivers/bcma/Makefile
121 @@ -0,0 +1,8 @@
122 +bcma-y += main.o scan.o core.o sprom.o
123 +bcma-y += driver_chipcommon.o driver_chipcommon_pmu.o
124 +bcma-y += driver_pci.o
125 +bcma-$(CONFIG_BCMA_DRIVER_PCI_HOSTMODE) += driver_pci_host.o
126 +bcma-$(CONFIG_BCMA_HOST_PCI) += host_pci.o
127 +obj-$(CONFIG_BCMA) += bcma.o
128 +
129 +ccflags-$(CONFIG_BCMA_DEBUG) := -DDEBUG
130 --- /dev/null
131 +++ b/drivers/bcma/README
132 @@ -0,0 +1,19 @@
133 +Broadcom introduced new bus as replacement for older SSB. It is based on AMBA,
134 +however from programming point of view there is nothing AMBA specific we use.
135 +
136 +Standard AMBA drivers are platform specific, have hardcoded addresses and use
137 +AMBA standard fields like CID and PID.
138 +
139 +In case of Broadcom's cards every device consists of:
140 +1) Broadcom specific AMBA device. It is put on AMBA bus, but can not be treated
141 + as standard AMBA device. Reading it's CID or PID can cause machine lockup.
142 +2) AMBA standard devices called ports or wrappers. They have CIDs (AMBA_CID)
143 + and PIDs (0x103BB369), but we do not use that info for anything. One of that
144 + devices is used for managing Broadcom specific core.
145 +
146 +Addresses of AMBA devices are not hardcoded in driver and have to be read from
147 +EPROM.
148 +
149 +In this situation we decided to introduce separated bus. It can contain up to
150 +16 devices identified by Broadcom specific fields: manufacturer, id, revision
151 +and class.
152 --- /dev/null
153 +++ b/drivers/bcma/TODO
154 @@ -0,0 +1,3 @@
155 +- Interrupts
156 +- Defines for PCI core driver
157 +- Create kernel Documentation (use info from README)
158 --- /dev/null
159 +++ b/drivers/bcma/bcma_private.h
160 @@ -0,0 +1,35 @@
161 +#ifndef LINUX_BCMA_PRIVATE_H_
162 +#define LINUX_BCMA_PRIVATE_H_
163 +
164 +#ifndef pr_fmt
165 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
166 +#endif
167 +
168 +#include <linux/bcma/bcma.h>
169 +#include <linux/delay.h>
170 +
171 +#define BCMA_CORE_SIZE 0x1000
172 +
173 +struct bcma_bus;
174 +
175 +/* main.c */
176 +int bcma_bus_register(struct bcma_bus *bus);
177 +void bcma_bus_unregister(struct bcma_bus *bus);
178 +
179 +/* scan.c */
180 +int bcma_bus_scan(struct bcma_bus *bus);
181 +
182 +/* sprom.c */
183 +int bcma_sprom_get(struct bcma_bus *bus);
184 +
185 +#ifdef CONFIG_BCMA_HOST_PCI
186 +/* host_pci.c */
187 +extern int __init bcma_host_pci_init(void);
188 +extern void __exit bcma_host_pci_exit(void);
189 +#endif /* CONFIG_BCMA_HOST_PCI */
190 +
191 +#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
192 +void bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc);
193 +#endif /* CONFIG_BCMA_DRIVER_PCI_HOSTMODE */
194 +
195 +#endif
196 --- /dev/null
197 +++ b/drivers/bcma/core.c
198 @@ -0,0 +1,124 @@
199 +/*
200 + * Broadcom specific AMBA
201 + * Core ops
202 + *
203 + * Licensed under the GNU/GPL. See COPYING for details.
204 + */
205 +
206 +#include "bcma_private.h"
207 +#include <linux/bcma/bcma.h>
208 +
209 +bool bcma_core_is_enabled(struct bcma_device *core)
210 +{
211 + if ((bcma_aread32(core, BCMA_IOCTL) & (BCMA_IOCTL_CLK | BCMA_IOCTL_FGC))
212 + != BCMA_IOCTL_CLK)
213 + return false;
214 + if (bcma_aread32(core, BCMA_RESET_CTL) & BCMA_RESET_CTL_RESET)
215 + return false;
216 + return true;
217 +}
218 +EXPORT_SYMBOL_GPL(bcma_core_is_enabled);
219 +
220 +void bcma_core_disable(struct bcma_device *core, u32 flags)
221 +{
222 + if (bcma_aread32(core, BCMA_RESET_CTL) & BCMA_RESET_CTL_RESET)
223 + return;
224 +
225 + bcma_awrite32(core, BCMA_IOCTL, flags);
226 + bcma_aread32(core, BCMA_IOCTL);
227 + udelay(10);
228 +
229 + bcma_awrite32(core, BCMA_RESET_CTL, BCMA_RESET_CTL_RESET);
230 + udelay(1);
231 +}
232 +EXPORT_SYMBOL_GPL(bcma_core_disable);
233 +
234 +int bcma_core_enable(struct bcma_device *core, u32 flags)
235 +{
236 + bcma_core_disable(core, flags);
237 +
238 + bcma_awrite32(core, BCMA_IOCTL, (BCMA_IOCTL_CLK | BCMA_IOCTL_FGC | flags));
239 + bcma_aread32(core, BCMA_IOCTL);
240 +
241 + bcma_awrite32(core, BCMA_RESET_CTL, 0);
242 + udelay(1);
243 +
244 + bcma_awrite32(core, BCMA_IOCTL, (BCMA_IOCTL_CLK | flags));
245 + bcma_aread32(core, BCMA_IOCTL);
246 + udelay(1);
247 +
248 + return 0;
249 +}
250 +EXPORT_SYMBOL_GPL(bcma_core_enable);
251 +
252 +void bcma_core_set_clockmode(struct bcma_device *core,
253 + enum bcma_clkmode clkmode)
254 +{
255 + u16 i;
256 +
257 + WARN_ON(core->id.id != BCMA_CORE_CHIPCOMMON &&
258 + core->id.id != BCMA_CORE_PCIE &&
259 + core->id.id != BCMA_CORE_80211);
260 +
261 + switch (clkmode) {
262 + case BCMA_CLKMODE_FAST:
263 + bcma_set32(core, BCMA_CLKCTLST, BCMA_CLKCTLST_FORCEHT);
264 + udelay(64);
265 + for (i = 0; i < 1500; i++) {
266 + if (bcma_read32(core, BCMA_CLKCTLST) &
267 + BCMA_CLKCTLST_HAVEHT) {
268 + i = 0;
269 + break;
270 + }
271 + udelay(10);
272 + }
273 + if (i)
274 + pr_err("HT force timeout\n");
275 + break;
276 + case BCMA_CLKMODE_DYNAMIC:
277 + pr_warning("Dynamic clockmode not supported yet!\n");
278 + break;
279 + }
280 +}
281 +EXPORT_SYMBOL_GPL(bcma_core_set_clockmode);
282 +
283 +void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status, bool on)
284 +{
285 + u16 i;
286 +
287 + WARN_ON(req & ~BCMA_CLKCTLST_EXTRESREQ);
288 + WARN_ON(status & ~BCMA_CLKCTLST_EXTRESST);
289 +
290 + if (on) {
291 + bcma_set32(core, BCMA_CLKCTLST, req);
292 + for (i = 0; i < 10000; i++) {
293 + if ((bcma_read32(core, BCMA_CLKCTLST) & status) ==
294 + status) {
295 + i = 0;
296 + break;
297 + }
298 + udelay(10);
299 + }
300 + if (i)
301 + pr_err("PLL enable timeout\n");
302 + } else {
303 + pr_warning("Disabling PLL not supported yet!\n");
304 + }
305 +}
306 +EXPORT_SYMBOL_GPL(bcma_core_pll_ctl);
307 +
308 +u32 bcma_core_dma_translation(struct bcma_device *core)
309 +{
310 + switch (core->bus->hosttype) {
311 + case BCMA_HOSTTYPE_PCI:
312 + if (bcma_aread32(core, BCMA_IOST) & BCMA_IOST_DMA64)
313 + return BCMA_DMA_TRANSLATION_DMA64_CMT;
314 + else
315 + return BCMA_DMA_TRANSLATION_DMA32_CMT;
316 + default:
317 + pr_err("DMA translation unknown for host %d\n",
318 + core->bus->hosttype);
319 + }
320 + return BCMA_DMA_TRANSLATION_NONE;
321 +}
322 +EXPORT_SYMBOL(bcma_core_dma_translation);
323 --- /dev/null
324 +++ b/drivers/bcma/driver_chipcommon.c
325 @@ -0,0 +1,103 @@
326 +/*
327 + * Broadcom specific AMBA
328 + * ChipCommon core driver
329 + *
330 + * Copyright 2005, Broadcom Corporation
331 + * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
332 + *
333 + * Licensed under the GNU/GPL. See COPYING for details.
334 + */
335 +
336 +#include "bcma_private.h"
337 +#include <linux/bcma/bcma.h>
338 +
339 +static inline u32 bcma_cc_write32_masked(struct bcma_drv_cc *cc, u16 offset,
340 + u32 mask, u32 value)
341 +{
342 + value &= mask;
343 + value |= bcma_cc_read32(cc, offset) & ~mask;
344 + bcma_cc_write32(cc, offset, value);
345 +
346 + return value;
347 +}
348 +
349 +void bcma_core_chipcommon_init(struct bcma_drv_cc *cc)
350 +{
351 + u32 leddc_on = 10;
352 + u32 leddc_off = 90;
353 +
354 + if (cc->core->id.rev >= 11)
355 + cc->status = bcma_cc_read32(cc, BCMA_CC_CHIPSTAT);
356 + cc->capabilities = bcma_cc_read32(cc, BCMA_CC_CAP);
357 + if (cc->core->id.rev >= 35)
358 + cc->capabilities_ext = bcma_cc_read32(cc, BCMA_CC_CAP_EXT);
359 +
360 + if (cc->core->id.rev >= 20) {
361 + bcma_cc_write32(cc, BCMA_CC_GPIOPULLUP, 0);
362 + bcma_cc_write32(cc, BCMA_CC_GPIOPULLDOWN, 0);
363 + }
364 +
365 + if (cc->capabilities & BCMA_CC_CAP_PMU)
366 + bcma_pmu_init(cc);
367 + if (cc->capabilities & BCMA_CC_CAP_PCTL)
368 + pr_err("Power control not implemented!\n");
369 +
370 + if (cc->core->id.rev >= 16) {
371 + if (cc->core->bus->sprom.leddc_on_time &&
372 + cc->core->bus->sprom.leddc_off_time) {
373 + leddc_on = cc->core->bus->sprom.leddc_on_time;
374 + leddc_off = cc->core->bus->sprom.leddc_off_time;
375 + }
376 + bcma_cc_write32(cc, BCMA_CC_GPIOTIMER,
377 + ((leddc_on << BCMA_CC_GPIOTIMER_ONTIME_SHIFT) |
378 + (leddc_off << BCMA_CC_GPIOTIMER_OFFTIME_SHIFT)));
379 + }
380 +}
381 +
382 +/* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */
383 +void bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc, u32 ticks)
384 +{
385 + /* instant NMI */
386 + bcma_cc_write32(cc, BCMA_CC_WATCHDOG, ticks);
387 +}
388 +
389 +void bcma_chipco_irq_mask(struct bcma_drv_cc *cc, u32 mask, u32 value)
390 +{
391 + bcma_cc_write32_masked(cc, BCMA_CC_IRQMASK, mask, value);
392 +}
393 +
394 +u32 bcma_chipco_irq_status(struct bcma_drv_cc *cc, u32 mask)
395 +{
396 + return bcma_cc_read32(cc, BCMA_CC_IRQSTAT) & mask;
397 +}
398 +
399 +u32 bcma_chipco_gpio_in(struct bcma_drv_cc *cc, u32 mask)
400 +{
401 + return bcma_cc_read32(cc, BCMA_CC_GPIOIN) & mask;
402 +}
403 +
404 +u32 bcma_chipco_gpio_out(struct bcma_drv_cc *cc, u32 mask, u32 value)
405 +{
406 + return bcma_cc_write32_masked(cc, BCMA_CC_GPIOOUT, mask, value);
407 +}
408 +
409 +u32 bcma_chipco_gpio_outen(struct bcma_drv_cc *cc, u32 mask, u32 value)
410 +{
411 + return bcma_cc_write32_masked(cc, BCMA_CC_GPIOOUTEN, mask, value);
412 +}
413 +
414 +u32 bcma_chipco_gpio_control(struct bcma_drv_cc *cc, u32 mask, u32 value)
415 +{
416 + return bcma_cc_write32_masked(cc, BCMA_CC_GPIOCTL, mask, value);
417 +}
418 +EXPORT_SYMBOL_GPL(bcma_chipco_gpio_control);
419 +
420 +u32 bcma_chipco_gpio_intmask(struct bcma_drv_cc *cc, u32 mask, u32 value)
421 +{
422 + return bcma_cc_write32_masked(cc, BCMA_CC_GPIOIRQ, mask, value);
423 +}
424 +
425 +u32 bcma_chipco_gpio_polarity(struct bcma_drv_cc *cc, u32 mask, u32 value)
426 +{
427 + return bcma_cc_write32_masked(cc, BCMA_CC_GPIOPOL, mask, value);
428 +}
429 --- /dev/null
430 +++ b/drivers/bcma/driver_chipcommon_pmu.c
431 @@ -0,0 +1,138 @@
432 +/*
433 + * Broadcom specific AMBA
434 + * ChipCommon Power Management Unit driver
435 + *
436 + * Copyright 2009, Michael Buesch <mb@bu3sch.de>
437 + * Copyright 2007, Broadcom Corporation
438 + *
439 + * Licensed under the GNU/GPL. See COPYING for details.
440 + */
441 +
442 +#include "bcma_private.h"
443 +#include <linux/bcma/bcma.h>
444 +
445 +static void bcma_chipco_chipctl_maskset(struct bcma_drv_cc *cc,
446 + u32 offset, u32 mask, u32 set)
447 +{
448 + u32 value;
449 +
450 + bcma_cc_read32(cc, BCMA_CC_CHIPCTL_ADDR);
451 + bcma_cc_write32(cc, BCMA_CC_CHIPCTL_ADDR, offset);
452 + bcma_cc_read32(cc, BCMA_CC_CHIPCTL_ADDR);
453 + value = bcma_cc_read32(cc, BCMA_CC_CHIPCTL_DATA);
454 + value &= mask;
455 + value |= set;
456 + bcma_cc_write32(cc, BCMA_CC_CHIPCTL_DATA, value);
457 + bcma_cc_read32(cc, BCMA_CC_CHIPCTL_DATA);
458 +}
459 +
460 +static void bcma_pmu_pll_init(struct bcma_drv_cc *cc)
461 +{
462 + struct bcma_bus *bus = cc->core->bus;
463 +
464 + switch (bus->chipinfo.id) {
465 + case 0x4313:
466 + case 0x4331:
467 + case 43224:
468 + case 43225:
469 + break;
470 + default:
471 + pr_err("PLL init unknown for device 0x%04X\n",
472 + bus->chipinfo.id);
473 + }
474 +}
475 +
476 +static void bcma_pmu_resources_init(struct bcma_drv_cc *cc)
477 +{
478 + struct bcma_bus *bus = cc->core->bus;
479 + u32 min_msk = 0, max_msk = 0;
480 +
481 + switch (bus->chipinfo.id) {
482 + case 0x4313:
483 + min_msk = 0x200D;
484 + max_msk = 0xFFFF;
485 + break;
486 + case 43224:
487 + case 43225:
488 + break;
489 + default:
490 + pr_err("PMU resource config unknown for device 0x%04X\n",
491 + bus->chipinfo.id);
492 + }
493 +
494 + /* Set the resource masks. */
495 + if (min_msk)
496 + bcma_cc_write32(cc, BCMA_CC_PMU_MINRES_MSK, min_msk);
497 + if (max_msk)
498 + bcma_cc_write32(cc, BCMA_CC_PMU_MAXRES_MSK, max_msk);
499 +}
500 +
501 +void bcma_pmu_swreg_init(struct bcma_drv_cc *cc)
502 +{
503 + struct bcma_bus *bus = cc->core->bus;
504 +
505 + switch (bus->chipinfo.id) {
506 + case 0x4313:
507 + case 0x4331:
508 + case 43224:
509 + case 43225:
510 + break;
511 + default:
512 + pr_err("PMU switch/regulators init unknown for device "
513 + "0x%04X\n", bus->chipinfo.id);
514 + }
515 +}
516 +
517 +void bcma_pmu_workarounds(struct bcma_drv_cc *cc)
518 +{
519 + struct bcma_bus *bus = cc->core->bus;
520 +
521 + switch (bus->chipinfo.id) {
522 + case 0x4313:
523 + bcma_chipco_chipctl_maskset(cc, 0, ~0, 0x7);
524 + break;
525 + case 0x4331:
526 + pr_err("Enabling Ext PA lines not implemented\n");
527 + break;
528 + case 43224:
529 + if (bus->chipinfo.rev == 0) {
530 + pr_err("Workarounds for 43224 rev 0 not fully "
531 + "implemented\n");
532 + bcma_chipco_chipctl_maskset(cc, 0, ~0, 0x00F000F0);
533 + } else {
534 + bcma_chipco_chipctl_maskset(cc, 0, ~0, 0xF0);
535 + }
536 + break;
537 + case 43225:
538 + break;
539 + default:
540 + pr_err("Workarounds unknown for device 0x%04X\n",
541 + bus->chipinfo.id);
542 + }
543 +}
544 +
545 +void bcma_pmu_init(struct bcma_drv_cc *cc)
546 +{
547 + u32 pmucap;
548 +
549 + pmucap = bcma_cc_read32(cc, BCMA_CC_PMU_CAP);
550 + cc->pmu.rev = (pmucap & BCMA_CC_PMU_CAP_REVISION);
551 +
552 + pr_debug("Found rev %u PMU (capabilities 0x%08X)\n", cc->pmu.rev,
553 + pmucap);
554 +
555 + if (cc->pmu.rev == 1)
556 + bcma_cc_mask32(cc, BCMA_CC_PMU_CTL,
557 + ~BCMA_CC_PMU_CTL_NOILPONW);
558 + else
559 + bcma_cc_set32(cc, BCMA_CC_PMU_CTL,
560 + BCMA_CC_PMU_CTL_NOILPONW);
561 +
562 + if (cc->core->id.id == 0x4329 && cc->core->id.rev == 2)
563 + pr_err("Fix for 4329b0 bad LPOM state not implemented!\n");
564 +
565 + bcma_pmu_pll_init(cc);
566 + bcma_pmu_resources_init(cc);
567 + bcma_pmu_swreg_init(cc);
568 + bcma_pmu_workarounds(cc);
569 +}
570 --- /dev/null
571 +++ b/drivers/bcma/driver_pci.c
572 @@ -0,0 +1,223 @@
573 +/*
574 + * Broadcom specific AMBA
575 + * PCI Core
576 + *
577 + * Copyright 2005, Broadcom Corporation
578 + * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
579 + *
580 + * Licensed under the GNU/GPL. See COPYING for details.
581 + */
582 +
583 +#include "bcma_private.h"
584 +#include <linux/bcma/bcma.h>
585 +
586 +/**************************************************
587 + * R/W ops.
588 + **************************************************/
589 +
590 +static u32 bcma_pcie_read(struct bcma_drv_pci *pc, u32 address)
591 +{
592 + pcicore_write32(pc, 0x130, address);
593 + pcicore_read32(pc, 0x130);
594 + return pcicore_read32(pc, 0x134);
595 +}
596 +
597 +#if 0
598 +static void bcma_pcie_write(struct bcma_drv_pci *pc, u32 address, u32 data)
599 +{
600 + pcicore_write32(pc, 0x130, address);
601 + pcicore_read32(pc, 0x130);
602 + pcicore_write32(pc, 0x134, data);
603 +}
604 +#endif
605 +
606 +static void bcma_pcie_mdio_set_phy(struct bcma_drv_pci *pc, u8 phy)
607 +{
608 + const u16 mdio_control = 0x128;
609 + const u16 mdio_data = 0x12C;
610 + u32 v;
611 + int i;
612 +
613 + v = (1 << 30); /* Start of Transaction */
614 + v |= (1 << 28); /* Write Transaction */
615 + v |= (1 << 17); /* Turnaround */
616 + v |= (0x1F << 18);
617 + v |= (phy << 4);
618 + pcicore_write32(pc, mdio_data, v);
619 +
620 + udelay(10);
621 + for (i = 0; i < 200; i++) {
622 + v = pcicore_read32(pc, mdio_control);
623 + if (v & 0x100 /* Trans complete */)
624 + break;
625 + msleep(1);
626 + }
627 +}
628 +
629 +static u16 bcma_pcie_mdio_read(struct bcma_drv_pci *pc, u8 device, u8 address)
630 +{
631 + const u16 mdio_control = 0x128;
632 + const u16 mdio_data = 0x12C;
633 + int max_retries = 10;
634 + u16 ret = 0;
635 + u32 v;
636 + int i;
637 +
638 + v = 0x80; /* Enable Preamble Sequence */
639 + v |= 0x2; /* MDIO Clock Divisor */
640 + pcicore_write32(pc, mdio_control, v);
641 +
642 + if (pc->core->id.rev >= 10) {
643 + max_retries = 200;
644 + bcma_pcie_mdio_set_phy(pc, device);
645 + }
646 +
647 + v = (1 << 30); /* Start of Transaction */
648 + v |= (1 << 29); /* Read Transaction */
649 + v |= (1 << 17); /* Turnaround */
650 + if (pc->core->id.rev < 10)
651 + v |= (u32)device << 22;
652 + v |= (u32)address << 18;
653 + pcicore_write32(pc, mdio_data, v);
654 + /* Wait for the device to complete the transaction */
655 + udelay(10);
656 + for (i = 0; i < max_retries; i++) {
657 + v = pcicore_read32(pc, mdio_control);
658 + if (v & 0x100 /* Trans complete */) {
659 + udelay(10);
660 + ret = pcicore_read32(pc, mdio_data);
661 + break;
662 + }
663 + msleep(1);
664 + }
665 + pcicore_write32(pc, mdio_control, 0);
666 + return ret;
667 +}
668 +
669 +static void bcma_pcie_mdio_write(struct bcma_drv_pci *pc, u8 device,
670 + u8 address, u16 data)
671 +{
672 + const u16 mdio_control = 0x128;
673 + const u16 mdio_data = 0x12C;
674 + int max_retries = 10;
675 + u32 v;
676 + int i;
677 +
678 + v = 0x80; /* Enable Preamble Sequence */
679 + v |= 0x2; /* MDIO Clock Divisor */
680 + pcicore_write32(pc, mdio_control, v);
681 +
682 + if (pc->core->id.rev >= 10) {
683 + max_retries = 200;
684 + bcma_pcie_mdio_set_phy(pc, device);
685 + }
686 +
687 + v = (1 << 30); /* Start of Transaction */
688 + v |= (1 << 28); /* Write Transaction */
689 + v |= (1 << 17); /* Turnaround */
690 + if (pc->core->id.rev < 10)
691 + v |= (u32)device << 22;
692 + v |= (u32)address << 18;
693 + v |= data;
694 + pcicore_write32(pc, mdio_data, v);
695 + /* Wait for the device to complete the transaction */
696 + udelay(10);
697 + for (i = 0; i < max_retries; i++) {
698 + v = pcicore_read32(pc, mdio_control);
699 + if (v & 0x100 /* Trans complete */)
700 + break;
701 + msleep(1);
702 + }
703 + pcicore_write32(pc, mdio_control, 0);
704 +}
705 +
706 +/**************************************************
707 + * Workarounds.
708 + **************************************************/
709 +
710 +static u8 bcma_pcicore_polarity_workaround(struct bcma_drv_pci *pc)
711 +{
712 + return (bcma_pcie_read(pc, 0x204) & 0x10) ? 0xC0 : 0x80;
713 +}
714 +
715 +static void bcma_pcicore_serdes_workaround(struct bcma_drv_pci *pc)
716 +{
717 + const u8 serdes_pll_device = 0x1D;
718 + const u8 serdes_rx_device = 0x1F;
719 + u16 tmp;
720 +
721 + bcma_pcie_mdio_write(pc, serdes_rx_device, 1 /* Control */,
722 + bcma_pcicore_polarity_workaround(pc));
723 + tmp = bcma_pcie_mdio_read(pc, serdes_pll_device, 1 /* Control */);
724 + if (tmp & 0x4000)
725 + bcma_pcie_mdio_write(pc, serdes_pll_device, 1, tmp & ~0x4000);
726 +}
727 +
728 +/**************************************************
729 + * Init.
730 + **************************************************/
731 +
732 +static void bcma_core_pci_clientmode_init(struct bcma_drv_pci *pc)
733 +{
734 + bcma_pcicore_serdes_workaround(pc);
735 +}
736 +
737 +static bool bcma_core_pci_is_in_hostmode(struct bcma_drv_pci *pc)
738 +{
739 + struct bcma_bus *bus = pc->core->bus;
740 + u16 chipid_top;
741 +
742 + chipid_top = (bus->chipinfo.id & 0xFF00);
743 + if (chipid_top != 0x4700 &&
744 + chipid_top != 0x5300)
745 + return false;
746 +
747 + if (bus->sprom.boardflags_lo & SSB_PCICORE_BFL_NOPCI)
748 + return false;
749 +
750 +#if 0
751 + /* TODO: on BCMA we use address from EROM instead of magic formula */
752 + u32 tmp;
753 + return !mips_busprobe32(tmp, (bus->mmio +
754 + (pc->core->core_index * BCMA_CORE_SIZE)));
755 +#endif
756 +
757 + return true;
758 +}
759 +
760 +void bcma_core_pci_init(struct bcma_drv_pci *pc)
761 +{
762 + if (bcma_core_pci_is_in_hostmode(pc)) {
763 +#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
764 + bcma_core_pci_hostmode_init(pc);
765 +#else
766 + pr_err("Driver compiled without support for hostmode PCI\n");
767 +#endif /* CONFIG_BCMA_DRIVER_PCI_HOSTMODE */
768 + } else {
769 + bcma_core_pci_clientmode_init(pc);
770 + }
771 +}
772 +
773 +int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc, struct bcma_device *core,
774 + bool enable)
775 +{
776 + struct pci_dev *pdev = pc->core->bus->host_pci;
777 + u32 coremask, tmp;
778 + int err;
779 +
780 + err = pci_read_config_dword(pdev, BCMA_PCI_IRQMASK, &tmp);
781 + if (err)
782 + goto out;
783 +
784 + coremask = BIT(core->core_index) << 8;
785 + if (enable)
786 + tmp |= coremask;
787 + else
788 + tmp &= ~coremask;
789 +
790 + err = pci_write_config_dword(pdev, BCMA_PCI_IRQMASK, tmp);
791 +
792 +out:
793 + return err;
794 +}
795 +EXPORT_SYMBOL_GPL(bcma_core_pci_irq_ctl);
796 --- /dev/null
797 +++ b/drivers/bcma/host_pci.c
798 @@ -0,0 +1,251 @@
799 +/*
800 + * Broadcom specific AMBA
801 + * PCI Host
802 + *
803 + * Licensed under the GNU/GPL. See COPYING for details.
804 + */
805 +
806 +#include "bcma_private.h"
807 +#include <linux/slab.h>
808 +#include <linux/bcma/bcma.h>
809 +#include <linux/pci.h>
810 +
811 +static void bcma_host_pci_switch_core(struct bcma_device *core)
812 +{
813 + pci_write_config_dword(core->bus->host_pci, BCMA_PCI_BAR0_WIN,
814 + core->addr);
815 + pci_write_config_dword(core->bus->host_pci, BCMA_PCI_BAR0_WIN2,
816 + core->wrap);
817 + core->bus->mapped_core = core;
818 + pr_debug("Switched to core: 0x%X\n", core->id.id);
819 +}
820 +
821 +static u8 bcma_host_pci_read8(struct bcma_device *core, u16 offset)
822 +{
823 + if (core->bus->mapped_core != core)
824 + bcma_host_pci_switch_core(core);
825 + return ioread8(core->bus->mmio + offset);
826 +}
827 +
828 +static u16 bcma_host_pci_read16(struct bcma_device *core, u16 offset)
829 +{
830 + if (core->bus->mapped_core != core)
831 + bcma_host_pci_switch_core(core);
832 + return ioread16(core->bus->mmio + offset);
833 +}
834 +
835 +static u32 bcma_host_pci_read32(struct bcma_device *core, u16 offset)
836 +{
837 + if (core->bus->mapped_core != core)
838 + bcma_host_pci_switch_core(core);
839 + return ioread32(core->bus->mmio + offset);
840 +}
841 +
842 +static void bcma_host_pci_write8(struct bcma_device *core, u16 offset,
843 + u8 value)
844 +{
845 + if (core->bus->mapped_core != core)
846 + bcma_host_pci_switch_core(core);
847 + iowrite8(value, core->bus->mmio + offset);
848 +}
849 +
850 +static void bcma_host_pci_write16(struct bcma_device *core, u16 offset,
851 + u16 value)
852 +{
853 + if (core->bus->mapped_core != core)
854 + bcma_host_pci_switch_core(core);
855 + iowrite16(value, core->bus->mmio + offset);
856 +}
857 +
858 +static void bcma_host_pci_write32(struct bcma_device *core, u16 offset,
859 + u32 value)
860 +{
861 + if (core->bus->mapped_core != core)
862 + bcma_host_pci_switch_core(core);
863 + iowrite32(value, core->bus->mmio + offset);
864 +}
865 +
866 +#ifdef CONFIG_BCMA_BLOCKIO
867 +void bcma_host_pci_block_read(struct bcma_device *core, void *buffer,
868 + size_t count, u16 offset, u8 reg_width)
869 +{
870 + void __iomem *addr = core->bus->mmio + offset;
871 + if (core->bus->mapped_core != core)
872 + bcma_host_pci_switch_core(core);
873 + switch (reg_width) {
874 + case sizeof(u8):
875 + ioread8_rep(addr, buffer, count);
876 + break;
877 + case sizeof(u16):
878 + WARN_ON(count & 1);
879 + ioread16_rep(addr, buffer, count >> 1);
880 + break;
881 + case sizeof(u32):
882 + WARN_ON(count & 3);
883 + ioread32_rep(addr, buffer, count >> 2);
884 + break;
885 + default:
886 + WARN_ON(1);
887 + }
888 +}
889 +
890 +void bcma_host_pci_block_write(struct bcma_device *core, const void *buffer,
891 + size_t count, u16 offset, u8 reg_width)
892 +{
893 + void __iomem *addr = core->bus->mmio + offset;
894 + if (core->bus->mapped_core != core)
895 + bcma_host_pci_switch_core(core);
896 + switch (reg_width) {
897 + case sizeof(u8):
898 + iowrite8_rep(addr, buffer, count);
899 + break;
900 + case sizeof(u16):
901 + WARN_ON(count & 1);
902 + iowrite16_rep(addr, buffer, count >> 1);
903 + break;
904 + case sizeof(u32):
905 + WARN_ON(count & 3);
906 + iowrite32_rep(addr, buffer, count >> 2);
907 + break;
908 + default:
909 + WARN_ON(1);
910 + }
911 +}
912 +#endif
913 +
914 +static u32 bcma_host_pci_aread32(struct bcma_device *core, u16 offset)
915 +{
916 + if (core->bus->mapped_core != core)
917 + bcma_host_pci_switch_core(core);
918 + return ioread32(core->bus->mmio + (1 * BCMA_CORE_SIZE) + offset);
919 +}
920 +
921 +static void bcma_host_pci_awrite32(struct bcma_device *core, u16 offset,
922 + u32 value)
923 +{
924 + if (core->bus->mapped_core != core)
925 + bcma_host_pci_switch_core(core);
926 + iowrite32(value, core->bus->mmio + (1 * BCMA_CORE_SIZE) + offset);
927 +}
928 +
929 +const struct bcma_host_ops bcma_host_pci_ops = {
930 + .read8 = bcma_host_pci_read8,
931 + .read16 = bcma_host_pci_read16,
932 + .read32 = bcma_host_pci_read32,
933 + .write8 = bcma_host_pci_write8,
934 + .write16 = bcma_host_pci_write16,
935 + .write32 = bcma_host_pci_write32,
936 +#ifdef CONFIG_BCMA_BLOCKIO
937 + .block_read = bcma_host_pci_block_read,
938 + .block_write = bcma_host_pci_block_write,
939 +#endif
940 + .aread32 = bcma_host_pci_aread32,
941 + .awrite32 = bcma_host_pci_awrite32,
942 +};
943 +
944 +static int bcma_host_pci_probe(struct pci_dev *dev,
945 + const struct pci_device_id *id)
946 +{
947 + struct bcma_bus *bus;
948 + int err = -ENOMEM;
949 + const char *name;
950 + u32 val;
951 +
952 + /* Alloc */
953 + bus = kzalloc(sizeof(*bus), GFP_KERNEL);
954 + if (!bus)
955 + goto out;
956 +
957 + /* Basic PCI configuration */
958 + err = pci_enable_device(dev);
959 + if (err)
960 + goto err_kfree_bus;
961 +
962 + name = dev_name(&dev->dev);
963 + if (dev->driver && dev->driver->name)
964 + name = dev->driver->name;
965 + err = pci_request_regions(dev, name);
966 + if (err)
967 + goto err_pci_disable;
968 + pci_set_master(dev);
969 +
970 + /* Disable the RETRY_TIMEOUT register (0x41) to keep
971 + * PCI Tx retries from interfering with C3 CPU state */
972 + pci_read_config_dword(dev, 0x40, &val);
973 + if ((val & 0x0000ff00) != 0)
974 + pci_write_config_dword(dev, 0x40, val & 0xffff00ff);
975 +
976 + /* SSB needed additional powering up, do we have any AMBA PCI cards? */
977 + if (!dev->is_pcie)
978 + pr_err("PCI card detected, report problems.\n");
979 +
980 + /* Map MMIO */
981 + err = -ENOMEM;
982 + bus->mmio = pci_iomap(dev, 0, ~0UL);
983 + if (!bus->mmio)
984 + goto err_pci_release_regions;
985 +
986 + /* Host specific */
987 + bus->host_pci = dev;
988 + bus->hosttype = BCMA_HOSTTYPE_PCI;
989 + bus->ops = &bcma_host_pci_ops;
990 +
991 + /* Register */
992 + err = bcma_bus_register(bus);
993 + if (err)
994 + goto err_pci_unmap_mmio;
995 +
996 + pci_set_drvdata(dev, bus);
997 +
998 +out:
999 + return err;
1000 +
1001 +err_pci_unmap_mmio:
1002 + pci_iounmap(dev, bus->mmio);
1003 +err_pci_release_regions:
1004 + pci_release_regions(dev);
1005 +err_pci_disable:
1006 + pci_disable_device(dev);
1007 +err_kfree_bus:
1008 + kfree(bus);
1009 + return err;
1010 +}
1011 +
1012 +static void bcma_host_pci_remove(struct pci_dev *dev)
1013 +{
1014 + struct bcma_bus *bus = pci_get_drvdata(dev);
1015 +
1016 + bcma_bus_unregister(bus);
1017 + pci_iounmap(dev, bus->mmio);
1018 + pci_release_regions(dev);
1019 + pci_disable_device(dev);
1020 + kfree(bus);
1021 + pci_set_drvdata(dev, NULL);
1022 +}
1023 +
1024 +static DEFINE_PCI_DEVICE_TABLE(bcma_pci_bridge_tbl) = {
1025 + { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x0576) },
1026 + { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4331) },
1027 + { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4353) },
1028 + { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4357) },
1029 + { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4727) },
1030 + { 0, },
1031 +};
1032 +MODULE_DEVICE_TABLE(pci, bcma_pci_bridge_tbl);
1033 +
1034 +static struct pci_driver bcma_pci_bridge_driver = {
1035 + .name = "bcma-pci-bridge",
1036 + .id_table = bcma_pci_bridge_tbl,
1037 + .probe = bcma_host_pci_probe,
1038 + .remove = bcma_host_pci_remove,
1039 +};
1040 +
1041 +int __init bcma_host_pci_init(void)
1042 +{
1043 + return pci_register_driver(&bcma_pci_bridge_driver);
1044 +}
1045 +
1046 +void __exit bcma_host_pci_exit(void)
1047 +{
1048 + pci_unregister_driver(&bcma_pci_bridge_driver);
1049 +}
1050 --- /dev/null
1051 +++ b/drivers/bcma/main.c
1052 @@ -0,0 +1,257 @@
1053 +/*
1054 + * Broadcom specific AMBA
1055 + * Bus subsystem
1056 + *
1057 + * Licensed under the GNU/GPL. See COPYING for details.
1058 + */
1059 +
1060 +#include "bcma_private.h"
1061 +#include <linux/bcma/bcma.h>
1062 +#include <linux/slab.h>
1063 +
1064 +MODULE_DESCRIPTION("Broadcom's specific AMBA driver");
1065 +MODULE_LICENSE("GPL");
1066 +
1067 +static int bcma_bus_match(struct device *dev, struct device_driver *drv);
1068 +static int bcma_device_probe(struct device *dev);
1069 +static int bcma_device_remove(struct device *dev);
1070 +
1071 +static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
1072 +{
1073 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1074 + return sprintf(buf, "0x%03X\n", core->id.manuf);
1075 +}
1076 +static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf)
1077 +{
1078 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1079 + return sprintf(buf, "0x%03X\n", core->id.id);
1080 +}
1081 +static ssize_t rev_show(struct device *dev, struct device_attribute *attr, char *buf)
1082 +{
1083 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1084 + return sprintf(buf, "0x%02X\n", core->id.rev);
1085 +}
1086 +static ssize_t class_show(struct device *dev, struct device_attribute *attr, char *buf)
1087 +{
1088 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1089 + return sprintf(buf, "0x%X\n", core->id.class);
1090 +}
1091 +static struct device_attribute bcma_device_attrs[] = {
1092 + __ATTR_RO(manuf),
1093 + __ATTR_RO(id),
1094 + __ATTR_RO(rev),
1095 + __ATTR_RO(class),
1096 + __ATTR_NULL,
1097 +};
1098 +
1099 +static struct bus_type bcma_bus_type = {
1100 + .name = "bcma",
1101 + .match = bcma_bus_match,
1102 + .probe = bcma_device_probe,
1103 + .remove = bcma_device_remove,
1104 + .dev_attrs = bcma_device_attrs,
1105 +};
1106 +
1107 +static struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid)
1108 +{
1109 + struct bcma_device *core;
1110 +
1111 + list_for_each_entry(core, &bus->cores, list) {
1112 + if (core->id.id == coreid)
1113 + return core;
1114 + }
1115 + return NULL;
1116 +}
1117 +
1118 +static void bcma_release_core_dev(struct device *dev)
1119 +{
1120 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1121 + kfree(core);
1122 +}
1123 +
1124 +static int bcma_register_cores(struct bcma_bus *bus)
1125 +{
1126 + struct bcma_device *core;
1127 + int err, dev_id = 0;
1128 +
1129 + list_for_each_entry(core, &bus->cores, list) {
1130 + /* We support that cores ourself */
1131 + switch (core->id.id) {
1132 + case BCMA_CORE_CHIPCOMMON:
1133 + case BCMA_CORE_PCI:
1134 + case BCMA_CORE_PCIE:
1135 + continue;
1136 + }
1137 +
1138 + core->dev.release = bcma_release_core_dev;
1139 + core->dev.bus = &bcma_bus_type;
1140 + dev_set_name(&core->dev, "bcma%d:%d", 0/*bus->num*/, dev_id);
1141 +
1142 + switch (bus->hosttype) {
1143 + case BCMA_HOSTTYPE_PCI:
1144 + core->dev.parent = &bus->host_pci->dev;
1145 + core->dma_dev = &bus->host_pci->dev;
1146 + core->irq = bus->host_pci->irq;
1147 + break;
1148 + case BCMA_HOSTTYPE_NONE:
1149 + case BCMA_HOSTTYPE_SDIO:
1150 + break;
1151 + }
1152 +
1153 + err = device_register(&core->dev);
1154 + if (err) {
1155 + pr_err("Could not register dev for core 0x%03X\n",
1156 + core->id.id);
1157 + continue;
1158 + }
1159 + core->dev_registered = true;
1160 + dev_id++;
1161 + }
1162 +
1163 + return 0;
1164 +}
1165 +
1166 +static void bcma_unregister_cores(struct bcma_bus *bus)
1167 +{
1168 + struct bcma_device *core;
1169 +
1170 + list_for_each_entry(core, &bus->cores, list) {
1171 + if (core->dev_registered)
1172 + device_unregister(&core->dev);
1173 + }
1174 +}
1175 +
1176 +int bcma_bus_register(struct bcma_bus *bus)
1177 +{
1178 + int err;
1179 + struct bcma_device *core;
1180 +
1181 + /* Scan for devices (cores) */
1182 + err = bcma_bus_scan(bus);
1183 + if (err) {
1184 + pr_err("Failed to scan: %d\n", err);
1185 + return -1;
1186 + }
1187 +
1188 + /* Init CC core */
1189 + core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
1190 + if (core) {
1191 + bus->drv_cc.core = core;
1192 + bcma_core_chipcommon_init(&bus->drv_cc);
1193 + }
1194 +
1195 + /* Init PCIE core */
1196 + core = bcma_find_core(bus, BCMA_CORE_PCIE);
1197 + if (core) {
1198 + bus->drv_pci.core = core;
1199 + bcma_core_pci_init(&bus->drv_pci);
1200 + }
1201 +
1202 + /* Try to get SPROM */
1203 + err = bcma_sprom_get(bus);
1204 + if (err == -ENOENT) {
1205 + pr_err("No SPROM available\n");
1206 + } else if (err) {
1207 + pr_err("Failed to get SPROM: %d\n", err);
1208 + return -ENOENT;
1209 + }
1210 +
1211 + /* Register found cores */
1212 + bcma_register_cores(bus);
1213 +
1214 + pr_info("Bus registered\n");
1215 +
1216 + return 0;
1217 +}
1218 +
1219 +void bcma_bus_unregister(struct bcma_bus *bus)
1220 +{
1221 + bcma_unregister_cores(bus);
1222 +}
1223 +
1224 +int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
1225 +{
1226 + drv->drv.name = drv->name;
1227 + drv->drv.bus = &bcma_bus_type;
1228 + drv->drv.owner = owner;
1229 +
1230 + return driver_register(&drv->drv);
1231 +}
1232 +EXPORT_SYMBOL_GPL(__bcma_driver_register);
1233 +
1234 +void bcma_driver_unregister(struct bcma_driver *drv)
1235 +{
1236 + driver_unregister(&drv->drv);
1237 +}
1238 +EXPORT_SYMBOL_GPL(bcma_driver_unregister);
1239 +
1240 +static int bcma_bus_match(struct device *dev, struct device_driver *drv)
1241 +{
1242 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1243 + struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
1244 + const struct bcma_device_id *cid = &core->id;
1245 + const struct bcma_device_id *did;
1246 +
1247 + for (did = adrv->id_table; did->manuf || did->id || did->rev; did++) {
1248 + if ((did->manuf == cid->manuf || did->manuf == BCMA_ANY_MANUF) &&
1249 + (did->id == cid->id || did->id == BCMA_ANY_ID) &&
1250 + (did->rev == cid->rev || did->rev == BCMA_ANY_REV) &&
1251 + (did->class == cid->class || did->class == BCMA_ANY_CLASS))
1252 + return 1;
1253 + }
1254 + return 0;
1255 +}
1256 +
1257 +static int bcma_device_probe(struct device *dev)
1258 +{
1259 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1260 + struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
1261 + drv);
1262 + int err = 0;
1263 +
1264 + if (adrv->probe)
1265 + err = adrv->probe(core);
1266 +
1267 + return err;
1268 +}
1269 +
1270 +static int bcma_device_remove(struct device *dev)
1271 +{
1272 + struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1273 + struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
1274 + drv);
1275 +
1276 + if (adrv->remove)
1277 + adrv->remove(core);
1278 +
1279 + return 0;
1280 +}
1281 +
1282 +static int __init bcma_modinit(void)
1283 +{
1284 + int err;
1285 +
1286 + err = bus_register(&bcma_bus_type);
1287 + if (err)
1288 + return err;
1289 +
1290 +#ifdef CONFIG_BCMA_HOST_PCI
1291 + err = bcma_host_pci_init();
1292 + if (err) {
1293 + pr_err("PCI host initialization failed\n");
1294 + err = 0;
1295 + }
1296 +#endif
1297 +
1298 + return err;
1299 +}
1300 +fs_initcall(bcma_modinit);
1301 +
1302 +static void __exit bcma_modexit(void)
1303 +{
1304 +#ifdef CONFIG_BCMA_HOST_PCI
1305 + bcma_host_pci_exit();
1306 +#endif
1307 + bus_unregister(&bcma_bus_type);
1308 +}
1309 +module_exit(bcma_modexit)
1310 --- /dev/null
1311 +++ b/drivers/bcma/scan.c
1312 @@ -0,0 +1,360 @@
1313 +/*
1314 + * Broadcom specific AMBA
1315 + * Bus scanning
1316 + *
1317 + * Licensed under the GNU/GPL. See COPYING for details.
1318 + */
1319 +
1320 +#include "scan.h"
1321 +#include "bcma_private.h"
1322 +
1323 +#include <linux/bcma/bcma.h>
1324 +#include <linux/bcma/bcma_regs.h>
1325 +#include <linux/pci.h>
1326 +#include <linux/io.h>
1327 +#include <linux/dma-mapping.h>
1328 +#include <linux/slab.h>
1329 +
1330 +struct bcma_device_id_name {
1331 + u16 id;
1332 + const char *name;
1333 +};
1334 +struct bcma_device_id_name bcma_device_names[] = {
1335 + { BCMA_CORE_OOB_ROUTER, "OOB Router" },
1336 + { BCMA_CORE_INVALID, "Invalid" },
1337 + { BCMA_CORE_CHIPCOMMON, "ChipCommon" },
1338 + { BCMA_CORE_ILINE20, "ILine 20" },
1339 + { BCMA_CORE_SRAM, "SRAM" },
1340 + { BCMA_CORE_SDRAM, "SDRAM" },
1341 + { BCMA_CORE_PCI, "PCI" },
1342 + { BCMA_CORE_MIPS, "MIPS" },
1343 + { BCMA_CORE_ETHERNET, "Fast Ethernet" },
1344 + { BCMA_CORE_V90, "V90" },
1345 + { BCMA_CORE_USB11_HOSTDEV, "USB 1.1 Hostdev" },
1346 + { BCMA_CORE_ADSL, "ADSL" },
1347 + { BCMA_CORE_ILINE100, "ILine 100" },
1348 + { BCMA_CORE_IPSEC, "IPSEC" },
1349 + { BCMA_CORE_UTOPIA, "UTOPIA" },
1350 + { BCMA_CORE_PCMCIA, "PCMCIA" },
1351 + { BCMA_CORE_INTERNAL_MEM, "Internal Memory" },
1352 + { BCMA_CORE_MEMC_SDRAM, "MEMC SDRAM" },
1353 + { BCMA_CORE_OFDM, "OFDM" },
1354 + { BCMA_CORE_EXTIF, "EXTIF" },
1355 + { BCMA_CORE_80211, "IEEE 802.11" },
1356 + { BCMA_CORE_PHY_A, "PHY A" },
1357 + { BCMA_CORE_PHY_B, "PHY B" },
1358 + { BCMA_CORE_PHY_G, "PHY G" },
1359 + { BCMA_CORE_MIPS_3302, "MIPS 3302" },
1360 + { BCMA_CORE_USB11_HOST, "USB 1.1 Host" },
1361 + { BCMA_CORE_USB11_DEV, "USB 1.1 Device" },
1362 + { BCMA_CORE_USB20_HOST, "USB 2.0 Host" },
1363 + { BCMA_CORE_USB20_DEV, "USB 2.0 Device" },
1364 + { BCMA_CORE_SDIO_HOST, "SDIO Host" },
1365 + { BCMA_CORE_ROBOSWITCH, "Roboswitch" },
1366 + { BCMA_CORE_PARA_ATA, "PATA" },
1367 + { BCMA_CORE_SATA_XORDMA, "SATA XOR-DMA" },
1368 + { BCMA_CORE_ETHERNET_GBIT, "GBit Ethernet" },
1369 + { BCMA_CORE_PCIE, "PCIe" },
1370 + { BCMA_CORE_PHY_N, "PHY N" },
1371 + { BCMA_CORE_SRAM_CTL, "SRAM Controller" },
1372 + { BCMA_CORE_MINI_MACPHY, "Mini MACPHY" },
1373 + { BCMA_CORE_ARM_1176, "ARM 1176" },
1374 + { BCMA_CORE_ARM_7TDMI, "ARM 7TDMI" },
1375 + { BCMA_CORE_PHY_LP, "PHY LP" },
1376 + { BCMA_CORE_PMU, "PMU" },
1377 + { BCMA_CORE_PHY_SSN, "PHY SSN" },
1378 + { BCMA_CORE_SDIO_DEV, "SDIO Device" },
1379 + { BCMA_CORE_ARM_CM3, "ARM CM3" },
1380 + { BCMA_CORE_PHY_HT, "PHY HT" },
1381 + { BCMA_CORE_MIPS_74K, "MIPS 74K" },
1382 + { BCMA_CORE_MAC_GBIT, "GBit MAC" },
1383 + { BCMA_CORE_DDR12_MEM_CTL, "DDR1/DDR2 Memory Controller" },
1384 + { BCMA_CORE_PCIE_RC, "PCIe Root Complex" },
1385 + { BCMA_CORE_OCP_OCP_BRIDGE, "OCP to OCP Bridge" },
1386 + { BCMA_CORE_SHARED_COMMON, "Common Shared" },
1387 + { BCMA_CORE_OCP_AHB_BRIDGE, "OCP to AHB Bridge" },
1388 + { BCMA_CORE_SPI_HOST, "SPI Host" },
1389 + { BCMA_CORE_I2S, "I2S" },
1390 + { BCMA_CORE_SDR_DDR1_MEM_CTL, "SDR/DDR1 Memory Controller" },
1391 + { BCMA_CORE_SHIM, "SHIM" },
1392 + { BCMA_CORE_DEFAULT, "Default" },
1393 +};
1394 +const char *bcma_device_name(struct bcma_device_id *id)
1395 +{
1396 + int i;
1397 +
1398 + if (id->manuf == BCMA_MANUF_BCM) {
1399 + for (i = 0; i < ARRAY_SIZE(bcma_device_names); i++) {
1400 + if (bcma_device_names[i].id == id->id)
1401 + return bcma_device_names[i].name;
1402 + }
1403 + }
1404 + return "UNKNOWN";
1405 +}
1406 +
1407 +static u32 bcma_scan_read32(struct bcma_bus *bus, u8 current_coreidx,
1408 + u16 offset)
1409 +{
1410 + return readl(bus->mmio + offset);
1411 +}
1412 +
1413 +static void bcma_scan_switch_core(struct bcma_bus *bus, u32 addr)
1414 +{
1415 + if (bus->hosttype == BCMA_HOSTTYPE_PCI)
1416 + pci_write_config_dword(bus->host_pci, BCMA_PCI_BAR0_WIN,
1417 + addr);
1418 +}
1419 +
1420 +static u32 bcma_erom_get_ent(struct bcma_bus *bus, u32 **eromptr)
1421 +{
1422 + u32 ent = readl(*eromptr);
1423 + (*eromptr)++;
1424 + return ent;
1425 +}
1426 +
1427 +static void bcma_erom_push_ent(u32 **eromptr)
1428 +{
1429 + (*eromptr)--;
1430 +}
1431 +
1432 +static s32 bcma_erom_get_ci(struct bcma_bus *bus, u32 **eromptr)
1433 +{
1434 + u32 ent = bcma_erom_get_ent(bus, eromptr);
1435 + if (!(ent & SCAN_ER_VALID))
1436 + return -ENOENT;
1437 + if ((ent & SCAN_ER_TAG) != SCAN_ER_TAG_CI)
1438 + return -ENOENT;
1439 + return ent;
1440 +}
1441 +
1442 +static bool bcma_erom_is_end(struct bcma_bus *bus, u32 **eromptr)
1443 +{
1444 + u32 ent = bcma_erom_get_ent(bus, eromptr);
1445 + bcma_erom_push_ent(eromptr);
1446 + return (ent == (SCAN_ER_TAG_END | SCAN_ER_VALID));
1447 +}
1448 +
1449 +static bool bcma_erom_is_bridge(struct bcma_bus *bus, u32 **eromptr)
1450 +{
1451 + u32 ent = bcma_erom_get_ent(bus, eromptr);
1452 + bcma_erom_push_ent(eromptr);
1453 + return (((ent & SCAN_ER_VALID)) &&
1454 + ((ent & SCAN_ER_TAGX) == SCAN_ER_TAG_ADDR) &&
1455 + ((ent & SCAN_ADDR_TYPE) == SCAN_ADDR_TYPE_BRIDGE));
1456 +}
1457 +
1458 +static void bcma_erom_skip_component(struct bcma_bus *bus, u32 **eromptr)
1459 +{
1460 + u32 ent;
1461 + while (1) {
1462 + ent = bcma_erom_get_ent(bus, eromptr);
1463 + if ((ent & SCAN_ER_VALID) &&
1464 + ((ent & SCAN_ER_TAG) == SCAN_ER_TAG_CI))
1465 + break;
1466 + if (ent == (SCAN_ER_TAG_END | SCAN_ER_VALID))
1467 + break;
1468 + }
1469 + bcma_erom_push_ent(eromptr);
1470 +}
1471 +
1472 +static s32 bcma_erom_get_mst_port(struct bcma_bus *bus, u32 **eromptr)
1473 +{
1474 + u32 ent = bcma_erom_get_ent(bus, eromptr);
1475 + if (!(ent & SCAN_ER_VALID))
1476 + return -ENOENT;
1477 + if ((ent & SCAN_ER_TAG) != SCAN_ER_TAG_MP)
1478 + return -ENOENT;
1479 + return ent;
1480 +}
1481 +
1482 +static s32 bcma_erom_get_addr_desc(struct bcma_bus *bus, u32 **eromptr,
1483 + u32 type, u8 port)
1484 +{
1485 + u32 addrl, addrh, sizel, sizeh = 0;
1486 + u32 size;
1487 +
1488 + u32 ent = bcma_erom_get_ent(bus, eromptr);
1489 + if ((!(ent & SCAN_ER_VALID)) ||
1490 + ((ent & SCAN_ER_TAGX) != SCAN_ER_TAG_ADDR) ||
1491 + ((ent & SCAN_ADDR_TYPE) != type) ||
1492 + (((ent & SCAN_ADDR_PORT) >> SCAN_ADDR_PORT_SHIFT) != port)) {
1493 + bcma_erom_push_ent(eromptr);
1494 + return -EINVAL;
1495 + }
1496 +
1497 + addrl = ent & SCAN_ADDR_ADDR;
1498 + if (ent & SCAN_ADDR_AG32)
1499 + addrh = bcma_erom_get_ent(bus, eromptr);
1500 + else
1501 + addrh = 0;
1502 +
1503 + if ((ent & SCAN_ADDR_SZ) == SCAN_ADDR_SZ_SZD) {
1504 + size = bcma_erom_get_ent(bus, eromptr);
1505 + sizel = size & SCAN_SIZE_SZ;
1506 + if (size & SCAN_SIZE_SG32)
1507 + sizeh = bcma_erom_get_ent(bus, eromptr);
1508 + } else
1509 + sizel = SCAN_ADDR_SZ_BASE <<
1510 + ((ent & SCAN_ADDR_SZ) >> SCAN_ADDR_SZ_SHIFT);
1511 +
1512 + return addrl;
1513 +}
1514 +
1515 +int bcma_bus_scan(struct bcma_bus *bus)
1516 +{
1517 + u32 erombase;
1518 + u32 __iomem *eromptr, *eromend;
1519 +
1520 + s32 cia, cib;
1521 + u8 ports[2], wrappers[2];
1522 +
1523 + s32 tmp;
1524 + u8 i, j;
1525 +
1526 + int err;
1527 +
1528 + INIT_LIST_HEAD(&bus->cores);
1529 + bus->nr_cores = 0;
1530 +
1531 + bcma_scan_switch_core(bus, BCMA_ADDR_BASE);
1532 +
1533 + tmp = bcma_scan_read32(bus, 0, BCMA_CC_ID);
1534 + bus->chipinfo.id = (tmp & BCMA_CC_ID_ID) >> BCMA_CC_ID_ID_SHIFT;
1535 + bus->chipinfo.rev = (tmp & BCMA_CC_ID_REV) >> BCMA_CC_ID_REV_SHIFT;
1536 + bus->chipinfo.pkg = (tmp & BCMA_CC_ID_PKG) >> BCMA_CC_ID_PKG_SHIFT;
1537 +
1538 + erombase = bcma_scan_read32(bus, 0, BCMA_CC_EROM);
1539 + eromptr = bus->mmio;
1540 + eromend = eromptr + BCMA_CORE_SIZE / sizeof(u32);
1541 +
1542 + bcma_scan_switch_core(bus, erombase);
1543 +
1544 + while (eromptr < eromend) {
1545 + struct bcma_device *core = kzalloc(sizeof(*core), GFP_KERNEL);
1546 + if (!core)
1547 + return -ENOMEM;
1548 + INIT_LIST_HEAD(&core->list);
1549 + core->bus = bus;
1550 +
1551 + /* get CIs */
1552 + cia = bcma_erom_get_ci(bus, &eromptr);
1553 + if (cia < 0) {
1554 + bcma_erom_push_ent(&eromptr);
1555 + if (bcma_erom_is_end(bus, &eromptr))
1556 + break;
1557 + err= -EILSEQ;
1558 + goto out;
1559 + }
1560 + cib = bcma_erom_get_ci(bus, &eromptr);
1561 + if (cib < 0) {
1562 + err= -EILSEQ;
1563 + goto out;
1564 + }
1565 +
1566 + /* parse CIs */
1567 + core->id.class = (cia & SCAN_CIA_CLASS) >> SCAN_CIA_CLASS_SHIFT;
1568 + core->id.id = (cia & SCAN_CIA_ID) >> SCAN_CIA_ID_SHIFT;
1569 + core->id.manuf = (cia & SCAN_CIA_MANUF) >> SCAN_CIA_MANUF_SHIFT;
1570 + ports[0] = (cib & SCAN_CIB_NMP) >> SCAN_CIB_NMP_SHIFT;
1571 + ports[1] = (cib & SCAN_CIB_NSP) >> SCAN_CIB_NSP_SHIFT;
1572 + wrappers[0] = (cib & SCAN_CIB_NMW) >> SCAN_CIB_NMW_SHIFT;
1573 + wrappers[1] = (cib & SCAN_CIB_NSW) >> SCAN_CIB_NSW_SHIFT;
1574 + core->id.rev = (cib & SCAN_CIB_REV) >> SCAN_CIB_REV_SHIFT;
1575 +
1576 + if (((core->id.manuf == BCMA_MANUF_ARM) &&
1577 + (core->id.id == 0xFFF)) ||
1578 + (ports[1] == 0)) {
1579 + bcma_erom_skip_component(bus, &eromptr);
1580 + continue;
1581 + }
1582 +
1583 + /* check if component is a core at all */
1584 + if (wrappers[0] + wrappers[1] == 0) {
1585 + /* we could save addrl of the router
1586 + if (cid == BCMA_CORE_OOB_ROUTER)
1587 + */
1588 + bcma_erom_skip_component(bus, &eromptr);
1589 + continue;
1590 + }
1591 +
1592 + if (bcma_erom_is_bridge(bus, &eromptr)) {
1593 + bcma_erom_skip_component(bus, &eromptr);
1594 + continue;
1595 + }
1596 +
1597 + /* get & parse master ports */
1598 + for (i = 0; i < ports[0]; i++) {
1599 + u32 mst_port_d = bcma_erom_get_mst_port(bus, &eromptr);
1600 + if (mst_port_d < 0) {
1601 + err= -EILSEQ;
1602 + goto out;
1603 + }
1604 + }
1605 +
1606 + /* get & parse slave ports */
1607 + for (i = 0; i < ports[1]; i++) {
1608 + for (j = 0; ; j++) {
1609 + tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1610 + SCAN_ADDR_TYPE_SLAVE, i);
1611 + if (tmp < 0) {
1612 + /* no more entries for port _i_ */
1613 + /* pr_debug("erom: slave port %d "
1614 + * "has %d descriptors\n", i, j); */
1615 + break;
1616 + } else {
1617 + if (i == 0 && j == 0)
1618 + core->addr = tmp;
1619 + }
1620 + }
1621 + }
1622 +
1623 + /* get & parse master wrappers */
1624 + for (i = 0; i < wrappers[0]; i++) {
1625 + for (j = 0; ; j++) {
1626 + tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1627 + SCAN_ADDR_TYPE_MWRAP, i);
1628 + if (tmp < 0) {
1629 + /* no more entries for port _i_ */
1630 + /* pr_debug("erom: master wrapper %d "
1631 + * "has %d descriptors\n", i, j); */
1632 + break;
1633 + } else {
1634 + if (i == 0 && j == 0)
1635 + core->wrap = tmp;
1636 + }
1637 + }
1638 + }
1639 +
1640 + /* get & parse slave wrappers */
1641 + for (i = 0; i < wrappers[1]; i++) {
1642 + u8 hack = (ports[1] == 1) ? 0 : 1;
1643 + for (j = 0; ; j++) {
1644 + tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1645 + SCAN_ADDR_TYPE_SWRAP, i + hack);
1646 + if (tmp < 0) {
1647 + /* no more entries for port _i_ */
1648 + /* pr_debug("erom: master wrapper %d "
1649 + * has %d descriptors\n", i, j); */
1650 + break;
1651 + } else {
1652 + if (wrappers[0] == 0 && !i && !j)
1653 + core->wrap = tmp;
1654 + }
1655 + }
1656 + }
1657 +
1658 + pr_info("Core %d found: %s "
1659 + "(manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
1660 + bus->nr_cores, bcma_device_name(&core->id),
1661 + core->id.manuf, core->id.id, core->id.rev,
1662 + core->id.class);
1663 +
1664 + core->core_index = bus->nr_cores++;
1665 + list_add(&core->list, &bus->cores);
1666 + continue;
1667 +out:
1668 + return err;
1669 + }
1670 +
1671 + return 0;
1672 +}
1673 --- /dev/null
1674 +++ b/drivers/bcma/scan.h
1675 @@ -0,0 +1,56 @@
1676 +#ifndef BCMA_SCAN_H_
1677 +#define BCMA_SCAN_H_
1678 +
1679 +#define BCMA_ADDR_BASE 0x18000000
1680 +#define BCMA_WRAP_BASE 0x18100000
1681 +
1682 +#define SCAN_ER_VALID 0x00000001
1683 +#define SCAN_ER_TAGX 0x00000006 /* we have to ignore 0x8 bit when checking tag for SCAN_ER_TAG_ADDR */
1684 +#define SCAN_ER_TAG 0x0000000E
1685 +#define SCAN_ER_TAG_CI 0x00000000
1686 +#define SCAN_ER_TAG_MP 0x00000002
1687 +#define SCAN_ER_TAG_ADDR 0x00000004
1688 +#define SCAN_ER_TAG_END 0x0000000E
1689 +#define SCAN_ER_BAD 0xFFFFFFFF
1690 +
1691 +#define SCAN_CIA_CLASS 0x000000F0
1692 +#define SCAN_CIA_CLASS_SHIFT 4
1693 +#define SCAN_CIA_ID 0x000FFF00
1694 +#define SCAN_CIA_ID_SHIFT 8
1695 +#define SCAN_CIA_MANUF 0xFFF00000
1696 +#define SCAN_CIA_MANUF_SHIFT 20
1697 +
1698 +#define SCAN_CIB_NMP 0x000001F0
1699 +#define SCAN_CIB_NMP_SHIFT 4
1700 +#define SCAN_CIB_NSP 0x00003E00
1701 +#define SCAN_CIB_NSP_SHIFT 9
1702 +#define SCAN_CIB_NMW 0x0007C000
1703 +#define SCAN_CIB_NMW_SHIFT 14
1704 +#define SCAN_CIB_NSW 0x00F80000
1705 +#define SCAN_CIB_NSW_SHIFT 17
1706 +#define SCAN_CIB_REV 0xFF000000
1707 +#define SCAN_CIB_REV_SHIFT 24
1708 +
1709 +#define SCAN_ADDR_AG32 0x00000008
1710 +#define SCAN_ADDR_SZ 0x00000030
1711 +#define SCAN_ADDR_SZ_SHIFT 4
1712 +#define SCAN_ADDR_SZ_4K 0x00000000
1713 +#define SCAN_ADDR_SZ_8K 0x00000010
1714 +#define SCAN_ADDR_SZ_16K 0x00000020
1715 +#define SCAN_ADDR_SZ_SZD 0x00000030
1716 +#define SCAN_ADDR_TYPE 0x000000C0
1717 +#define SCAN_ADDR_TYPE_SLAVE 0x00000000
1718 +#define SCAN_ADDR_TYPE_BRIDGE 0x00000040
1719 +#define SCAN_ADDR_TYPE_SWRAP 0x00000080
1720 +#define SCAN_ADDR_TYPE_MWRAP 0x000000C0
1721 +#define SCAN_ADDR_PORT 0x00000F00
1722 +#define SCAN_ADDR_PORT_SHIFT 8
1723 +#define SCAN_ADDR_ADDR 0xFFFFF000
1724 +
1725 +#define SCAN_ADDR_SZ_BASE 0x00001000 /* 4KB */
1726 +
1727 +#define SCAN_SIZE_SZ_ALIGN 0x00000FFF
1728 +#define SCAN_SIZE_SZ 0xFFFFF000
1729 +#define SCAN_SIZE_SG32 0x00000008
1730 +
1731 +#endif /* BCMA_SCAN_H_ */
1732 --- /dev/null
1733 +++ b/include/linux/bcma/bcma.h
1734 @@ -0,0 +1,271 @@
1735 +#ifndef LINUX_BCMA_H_
1736 +#define LINUX_BCMA_H_
1737 +
1738 +#include <linux/pci.h>
1739 +#include <linux/mod_devicetable.h>
1740 +
1741 +#include <linux/bcma/bcma_driver_chipcommon.h>
1742 +#include <linux/bcma/bcma_driver_pci.h>
1743 +#include <linux/ssb/ssb.h> /* SPROM sharing */
1744 +
1745 +#include "bcma_regs.h"
1746 +
1747 +struct bcma_device;
1748 +struct bcma_bus;
1749 +
1750 +enum bcma_hosttype {
1751 + BCMA_HOSTTYPE_NONE,
1752 + BCMA_HOSTTYPE_PCI,
1753 + BCMA_HOSTTYPE_SDIO,
1754 +};
1755 +
1756 +struct bcma_chipinfo {
1757 + u16 id;
1758 + u8 rev;
1759 + u8 pkg;
1760 +};
1761 +
1762 +enum bcma_clkmode {
1763 + BCMA_CLKMODE_FAST,
1764 + BCMA_CLKMODE_DYNAMIC,
1765 +};
1766 +
1767 +struct bcma_host_ops {
1768 + u8 (*read8)(struct bcma_device *core, u16 offset);
1769 + u16 (*read16)(struct bcma_device *core, u16 offset);
1770 + u32 (*read32)(struct bcma_device *core, u16 offset);
1771 + void (*write8)(struct bcma_device *core, u16 offset, u8 value);
1772 + void (*write16)(struct bcma_device *core, u16 offset, u16 value);
1773 + void (*write32)(struct bcma_device *core, u16 offset, u32 value);
1774 +#ifdef CONFIG_BCMA_BLOCKIO
1775 + void (*block_read)(struct bcma_device *core, void *buffer,
1776 + size_t count, u16 offset, u8 reg_width);
1777 + void (*block_write)(struct bcma_device *core, const void *buffer,
1778 + size_t count, u16 offset, u8 reg_width);
1779 +#endif
1780 + /* Agent ops */
1781 + u32 (*aread32)(struct bcma_device *core, u16 offset);
1782 + void (*awrite32)(struct bcma_device *core, u16 offset, u32 value);
1783 +};
1784 +
1785 +/* Core manufacturers */
1786 +#define BCMA_MANUF_ARM 0x43B
1787 +#define BCMA_MANUF_MIPS 0x4A7
1788 +#define BCMA_MANUF_BCM 0x4BF
1789 +
1790 +/* Core class values. */
1791 +#define BCMA_CL_SIM 0x0
1792 +#define BCMA_CL_EROM 0x1
1793 +#define BCMA_CL_CORESIGHT 0x9
1794 +#define BCMA_CL_VERIF 0xB
1795 +#define BCMA_CL_OPTIMO 0xD
1796 +#define BCMA_CL_GEN 0xE
1797 +#define BCMA_CL_PRIMECELL 0xF
1798 +
1799 +/* Core-ID values. */
1800 +#define BCMA_CORE_OOB_ROUTER 0x367 /* Out of band */
1801 +#define BCMA_CORE_INVALID 0x700
1802 +#define BCMA_CORE_CHIPCOMMON 0x800
1803 +#define BCMA_CORE_ILINE20 0x801
1804 +#define BCMA_CORE_SRAM 0x802
1805 +#define BCMA_CORE_SDRAM 0x803
1806 +#define BCMA_CORE_PCI 0x804
1807 +#define BCMA_CORE_MIPS 0x805
1808 +#define BCMA_CORE_ETHERNET 0x806
1809 +#define BCMA_CORE_V90 0x807
1810 +#define BCMA_CORE_USB11_HOSTDEV 0x808
1811 +#define BCMA_CORE_ADSL 0x809
1812 +#define BCMA_CORE_ILINE100 0x80A
1813 +#define BCMA_CORE_IPSEC 0x80B
1814 +#define BCMA_CORE_UTOPIA 0x80C
1815 +#define BCMA_CORE_PCMCIA 0x80D
1816 +#define BCMA_CORE_INTERNAL_MEM 0x80E
1817 +#define BCMA_CORE_MEMC_SDRAM 0x80F
1818 +#define BCMA_CORE_OFDM 0x810
1819 +#define BCMA_CORE_EXTIF 0x811
1820 +#define BCMA_CORE_80211 0x812
1821 +#define BCMA_CORE_PHY_A 0x813
1822 +#define BCMA_CORE_PHY_B 0x814
1823 +#define BCMA_CORE_PHY_G 0x815
1824 +#define BCMA_CORE_MIPS_3302 0x816
1825 +#define BCMA_CORE_USB11_HOST 0x817
1826 +#define BCMA_CORE_USB11_DEV 0x818
1827 +#define BCMA_CORE_USB20_HOST 0x819
1828 +#define BCMA_CORE_USB20_DEV 0x81A
1829 +#define BCMA_CORE_SDIO_HOST 0x81B
1830 +#define BCMA_CORE_ROBOSWITCH 0x81C
1831 +#define BCMA_CORE_PARA_ATA 0x81D
1832 +#define BCMA_CORE_SATA_XORDMA 0x81E
1833 +#define BCMA_CORE_ETHERNET_GBIT 0x81F
1834 +#define BCMA_CORE_PCIE 0x820
1835 +#define BCMA_CORE_PHY_N 0x821
1836 +#define BCMA_CORE_SRAM_CTL 0x822
1837 +#define BCMA_CORE_MINI_MACPHY 0x823
1838 +#define BCMA_CORE_ARM_1176 0x824
1839 +#define BCMA_CORE_ARM_7TDMI 0x825
1840 +#define BCMA_CORE_PHY_LP 0x826
1841 +#define BCMA_CORE_PMU 0x827
1842 +#define BCMA_CORE_PHY_SSN 0x828
1843 +#define BCMA_CORE_SDIO_DEV 0x829
1844 +#define BCMA_CORE_ARM_CM3 0x82A
1845 +#define BCMA_CORE_PHY_HT 0x82B
1846 +#define BCMA_CORE_MIPS_74K 0x82C
1847 +#define BCMA_CORE_MAC_GBIT 0x82D
1848 +#define BCMA_CORE_DDR12_MEM_CTL 0x82E
1849 +#define BCMA_CORE_PCIE_RC 0x82F /* PCIe Root Complex */
1850 +#define BCMA_CORE_OCP_OCP_BRIDGE 0x830
1851 +#define BCMA_CORE_SHARED_COMMON 0x831
1852 +#define BCMA_CORE_OCP_AHB_BRIDGE 0x832
1853 +#define BCMA_CORE_SPI_HOST 0x833
1854 +#define BCMA_CORE_I2S 0x834
1855 +#define BCMA_CORE_SDR_DDR1_MEM_CTL 0x835 /* SDR/DDR1 memory controller core */
1856 +#define BCMA_CORE_SHIM 0x837 /* SHIM component in ubus/6362 */
1857 +#define BCMA_CORE_DEFAULT 0xFFF
1858 +
1859 +#define BCMA_MAX_NR_CORES 16
1860 +
1861 +struct bcma_device {
1862 + struct bcma_bus *bus;
1863 + struct bcma_device_id id;
1864 +
1865 + struct device dev;
1866 + struct device *dma_dev;
1867 + unsigned int irq;
1868 + bool dev_registered;
1869 +
1870 + u8 core_index;
1871 +
1872 + u32 addr;
1873 + u32 wrap;
1874 +
1875 + void *drvdata;
1876 + struct list_head list;
1877 +};
1878 +
1879 +static inline void *bcma_get_drvdata(struct bcma_device *core)
1880 +{
1881 + return core->drvdata;
1882 +}
1883 +static inline void bcma_set_drvdata(struct bcma_device *core, void *drvdata)
1884 +{
1885 + core->drvdata = drvdata;
1886 +}
1887 +
1888 +struct bcma_driver {
1889 + const char *name;
1890 + const struct bcma_device_id *id_table;
1891 +
1892 + int (*probe)(struct bcma_device *dev);
1893 + void (*remove)(struct bcma_device *dev);
1894 + int (*suspend)(struct bcma_device *dev, pm_message_t state);
1895 + int (*resume)(struct bcma_device *dev);
1896 + void (*shutdown)(struct bcma_device *dev);
1897 +
1898 + struct device_driver drv;
1899 +};
1900 +extern
1901 +int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
1902 +static inline int bcma_driver_register(struct bcma_driver *drv)
1903 +{
1904 + return __bcma_driver_register(drv, THIS_MODULE);
1905 +}
1906 +extern void bcma_driver_unregister(struct bcma_driver *drv);
1907 +
1908 +struct bcma_bus {
1909 + /* The MMIO area. */
1910 + void __iomem *mmio;
1911 +
1912 + const struct bcma_host_ops *ops;
1913 +
1914 + enum bcma_hosttype hosttype;
1915 + union {
1916 + /* Pointer to the PCI bus (only for BCMA_HOSTTYPE_PCI) */
1917 + struct pci_dev *host_pci;
1918 + /* Pointer to the SDIO device (only for BCMA_HOSTTYPE_SDIO) */
1919 + struct sdio_func *host_sdio;
1920 + };
1921 +
1922 + struct bcma_chipinfo chipinfo;
1923 +
1924 + struct bcma_device *mapped_core;
1925 + struct list_head cores;
1926 + u8 nr_cores;
1927 +
1928 + struct bcma_drv_cc drv_cc;
1929 + struct bcma_drv_pci drv_pci;
1930 +
1931 + /* We decided to share SPROM struct with SSB as long as we do not need
1932 + * any hacks for BCMA. This simplifies drivers code. */
1933 + struct ssb_sprom sprom;
1934 +};
1935 +
1936 +extern inline u32 bcma_read8(struct bcma_device *core, u16 offset)
1937 +{
1938 + return core->bus->ops->read8(core, offset);
1939 +}
1940 +extern inline u32 bcma_read16(struct bcma_device *core, u16 offset)
1941 +{
1942 + return core->bus->ops->read16(core, offset);
1943 +}
1944 +extern inline u32 bcma_read32(struct bcma_device *core, u16 offset)
1945 +{
1946 + return core->bus->ops->read32(core, offset);
1947 +}
1948 +extern inline
1949 +void bcma_write8(struct bcma_device *core, u16 offset, u32 value)
1950 +{
1951 + core->bus->ops->write8(core, offset, value);
1952 +}
1953 +extern inline
1954 +void bcma_write16(struct bcma_device *core, u16 offset, u32 value)
1955 +{
1956 + core->bus->ops->write16(core, offset, value);
1957 +}
1958 +extern inline
1959 +void bcma_write32(struct bcma_device *core, u16 offset, u32 value)
1960 +{
1961 + core->bus->ops->write32(core, offset, value);
1962 +}
1963 +#ifdef CONFIG_BCMA_BLOCKIO
1964 +extern inline void bcma_block_read(struct bcma_device *core, void *buffer,
1965 + size_t count, u16 offset, u8 reg_width)
1966 +{
1967 + core->bus->ops->block_read(core, buffer, count, offset, reg_width);
1968 +}
1969 +extern inline void bcma_block_write(struct bcma_device *core, const void *buffer,
1970 + size_t count, u16 offset, u8 reg_width)
1971 +{
1972 + core->bus->ops->block_write(core, buffer, count, offset, reg_width);
1973 +}
1974 +#endif
1975 +extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
1976 +{
1977 + return core->bus->ops->aread32(core, offset);
1978 +}
1979 +extern inline
1980 +void bcma_awrite32(struct bcma_device *core, u16 offset, u32 value)
1981 +{
1982 + core->bus->ops->awrite32(core, offset, value);
1983 +}
1984 +
1985 +#define bcma_mask32(cc, offset, mask) \
1986 + bcma_write32(cc, offset, bcma_read32(cc, offset) & (mask))
1987 +#define bcma_set32(cc, offset, set) \
1988 + bcma_write32(cc, offset, bcma_read32(cc, offset) | (set))
1989 +#define bcma_maskset32(cc, offset, mask, set) \
1990 + bcma_write32(cc, offset, (bcma_read32(cc, offset) & (mask)) | (set))
1991 +
1992 +extern bool bcma_core_is_enabled(struct bcma_device *core);
1993 +extern void bcma_core_disable(struct bcma_device *core, u32 flags);
1994 +extern int bcma_core_enable(struct bcma_device *core, u32 flags);
1995 +extern void bcma_core_set_clockmode(struct bcma_device *core,
1996 + enum bcma_clkmode clkmode);
1997 +extern void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status,
1998 + bool on);
1999 +#define BCMA_DMA_TRANSLATION_MASK 0xC0000000
2000 +#define BCMA_DMA_TRANSLATION_NONE 0x00000000
2001 +#define BCMA_DMA_TRANSLATION_DMA32_CMT 0x40000000 /* Client Mode Translation for 32-bit DMA */
2002 +#define BCMA_DMA_TRANSLATION_DMA64_CMT 0x80000000 /* Client Mode Translation for 64-bit DMA */
2003 +extern u32 bcma_core_dma_translation(struct bcma_device *core);
2004 +
2005 +#endif /* LINUX_BCMA_H_ */
2006 --- /dev/null
2007 +++ b/include/linux/bcma/bcma_driver_chipcommon.h
2008 @@ -0,0 +1,296 @@
2009 +#ifndef LINUX_BCMA_DRIVER_CC_H_
2010 +#define LINUX_BCMA_DRIVER_CC_H_
2011 +
2012 +/** ChipCommon core registers. **/
2013 +#define BCMA_CC_ID 0x0000
2014 +#define BCMA_CC_ID_ID 0x0000FFFF
2015 +#define BCMA_CC_ID_ID_SHIFT 0
2016 +#define BCMA_CC_ID_REV 0x000F0000
2017 +#define BCMA_CC_ID_REV_SHIFT 16
2018 +#define BCMA_CC_ID_PKG 0x00F00000
2019 +#define BCMA_CC_ID_PKG_SHIFT 20
2020 +#define BCMA_CC_ID_NRCORES 0x0F000000
2021 +#define BCMA_CC_ID_NRCORES_SHIFT 24
2022 +#define BCMA_CC_ID_TYPE 0xF0000000
2023 +#define BCMA_CC_ID_TYPE_SHIFT 28
2024 +#define BCMA_CC_CAP 0x0004 /* Capabilities */
2025 +#define BCMA_CC_CAP_NRUART 0x00000003 /* # of UARTs */
2026 +#define BCMA_CC_CAP_MIPSEB 0x00000004 /* MIPS in BigEndian Mode */
2027 +#define BCMA_CC_CAP_UARTCLK 0x00000018 /* UART clock select */
2028 +#define BCMA_CC_CAP_UARTCLK_INT 0x00000008 /* UARTs are driven by internal divided clock */
2029 +#define BCMA_CC_CAP_UARTGPIO 0x00000020 /* UARTs on GPIO 15-12 */
2030 +#define BCMA_CC_CAP_EXTBUS 0x000000C0 /* External buses present */
2031 +#define BCMA_CC_CAP_FLASHT 0x00000700 /* Flash Type */
2032 +#define BCMA_CC_FLASHT_NONE 0x00000000 /* No flash */
2033 +#define BCMA_CC_FLASHT_STSER 0x00000100 /* ST serial flash */
2034 +#define BCMA_CC_FLASHT_ATSER 0x00000200 /* Atmel serial flash */
2035 +#define BCMA_CC_FLASHT_PARA 0x00000700 /* Parallel flash */
2036 +#define BCMA_CC_CAP_PLLT 0x00038000 /* PLL Type */
2037 +#define BCMA_PLLTYPE_NONE 0x00000000
2038 +#define BCMA_PLLTYPE_1 0x00010000 /* 48Mhz base, 3 dividers */
2039 +#define BCMA_PLLTYPE_2 0x00020000 /* 48Mhz, 4 dividers */
2040 +#define BCMA_PLLTYPE_3 0x00030000 /* 25Mhz, 2 dividers */
2041 +#define BCMA_PLLTYPE_4 0x00008000 /* 48Mhz, 4 dividers */
2042 +#define BCMA_PLLTYPE_5 0x00018000 /* 25Mhz, 4 dividers */
2043 +#define BCMA_PLLTYPE_6 0x00028000 /* 100/200 or 120/240 only */
2044 +#define BCMA_PLLTYPE_7 0x00038000 /* 25Mhz, 4 dividers */
2045 +#define BCMA_CC_CAP_PCTL 0x00040000 /* Power Control */
2046 +#define BCMA_CC_CAP_OTPS 0x00380000 /* OTP size */
2047 +#define BCMA_CC_CAP_OTPS_SHIFT 19
2048 +#define BCMA_CC_CAP_OTPS_BASE 5
2049 +#define BCMA_CC_CAP_JTAGM 0x00400000 /* JTAG master present */
2050 +#define BCMA_CC_CAP_BROM 0x00800000 /* Internal boot ROM active */
2051 +#define BCMA_CC_CAP_64BIT 0x08000000 /* 64-bit Backplane */
2052 +#define BCMA_CC_CAP_PMU 0x10000000 /* PMU available (rev >= 20) */
2053 +#define BCMA_CC_CAP_ECI 0x20000000 /* ECI available (rev >= 20) */
2054 +#define BCMA_CC_CAP_SPROM 0x40000000 /* SPROM present */
2055 +#define BCMA_CC_CORECTL 0x0008
2056 +#define BCMA_CC_CORECTL_UARTCLK0 0x00000001 /* Drive UART with internal clock */
2057 +#define BCMA_CC_CORECTL_SE 0x00000002 /* sync clk out enable (corerev >= 3) */
2058 +#define BCMA_CC_CORECTL_UARTCLKEN 0x00000008 /* UART clock enable (rev >= 21) */
2059 +#define BCMA_CC_BIST 0x000C
2060 +#define BCMA_CC_OTPS 0x0010 /* OTP status */
2061 +#define BCMA_CC_OTPS_PROGFAIL 0x80000000
2062 +#define BCMA_CC_OTPS_PROTECT 0x00000007
2063 +#define BCMA_CC_OTPS_HW_PROTECT 0x00000001
2064 +#define BCMA_CC_OTPS_SW_PROTECT 0x00000002
2065 +#define BCMA_CC_OTPS_CID_PROTECT 0x00000004
2066 +#define BCMA_CC_OTPC 0x0014 /* OTP control */
2067 +#define BCMA_CC_OTPC_RECWAIT 0xFF000000
2068 +#define BCMA_CC_OTPC_PROGWAIT 0x00FFFF00
2069 +#define BCMA_CC_OTPC_PRW_SHIFT 8
2070 +#define BCMA_CC_OTPC_MAXFAIL 0x00000038
2071 +#define BCMA_CC_OTPC_VSEL 0x00000006
2072 +#define BCMA_CC_OTPC_SELVL 0x00000001
2073 +#define BCMA_CC_OTPP 0x0018 /* OTP prog */
2074 +#define BCMA_CC_OTPP_COL 0x000000FF
2075 +#define BCMA_CC_OTPP_ROW 0x0000FF00
2076 +#define BCMA_CC_OTPP_ROW_SHIFT 8
2077 +#define BCMA_CC_OTPP_READERR 0x10000000
2078 +#define BCMA_CC_OTPP_VALUE 0x20000000
2079 +#define BCMA_CC_OTPP_READ 0x40000000
2080 +#define BCMA_CC_OTPP_START 0x80000000
2081 +#define BCMA_CC_OTPP_BUSY 0x80000000
2082 +#define BCMA_CC_IRQSTAT 0x0020
2083 +#define BCMA_CC_IRQMASK 0x0024
2084 +#define BCMA_CC_IRQ_GPIO 0x00000001 /* gpio intr */
2085 +#define BCMA_CC_IRQ_EXT 0x00000002 /* ro: ext intr pin (corerev >= 3) */
2086 +#define BCMA_CC_IRQ_WDRESET 0x80000000 /* watchdog reset occurred */
2087 +#define BCMA_CC_CHIPCTL 0x0028 /* Rev >= 11 only */
2088 +#define BCMA_CC_CHIPSTAT 0x002C /* Rev >= 11 only */
2089 +#define BCMA_CC_JCMD 0x0030 /* Rev >= 10 only */
2090 +#define BCMA_CC_JCMD_START 0x80000000
2091 +#define BCMA_CC_JCMD_BUSY 0x80000000
2092 +#define BCMA_CC_JCMD_PAUSE 0x40000000
2093 +#define BCMA_CC_JCMD0_ACC_MASK 0x0000F000
2094 +#define BCMA_CC_JCMD0_ACC_IRDR 0x00000000
2095 +#define BCMA_CC_JCMD0_ACC_DR 0x00001000
2096 +#define BCMA_CC_JCMD0_ACC_IR 0x00002000
2097 +#define BCMA_CC_JCMD0_ACC_RESET 0x00003000
2098 +#define BCMA_CC_JCMD0_ACC_IRPDR 0x00004000
2099 +#define BCMA_CC_JCMD0_ACC_PDR 0x00005000
2100 +#define BCMA_CC_JCMD0_IRW_MASK 0x00000F00
2101 +#define BCMA_CC_JCMD_ACC_MASK 0x000F0000 /* Changes for corerev 11 */
2102 +#define BCMA_CC_JCMD_ACC_IRDR 0x00000000
2103 +#define BCMA_CC_JCMD_ACC_DR 0x00010000
2104 +#define BCMA_CC_JCMD_ACC_IR 0x00020000
2105 +#define BCMA_CC_JCMD_ACC_RESET 0x00030000
2106 +#define BCMA_CC_JCMD_ACC_IRPDR 0x00040000
2107 +#define BCMA_CC_JCMD_ACC_PDR 0x00050000
2108 +#define BCMA_CC_JCMD_IRW_MASK 0x00001F00
2109 +#define BCMA_CC_JCMD_IRW_SHIFT 8
2110 +#define BCMA_CC_JCMD_DRW_MASK 0x0000003F
2111 +#define BCMA_CC_JIR 0x0034 /* Rev >= 10 only */
2112 +#define BCMA_CC_JDR 0x0038 /* Rev >= 10 only */
2113 +#define BCMA_CC_JCTL 0x003C /* Rev >= 10 only */
2114 +#define BCMA_CC_JCTL_FORCE_CLK 4 /* Force clock */
2115 +#define BCMA_CC_JCTL_EXT_EN 2 /* Enable external targets */
2116 +#define BCMA_CC_JCTL_EN 1 /* Enable Jtag master */
2117 +#define BCMA_CC_FLASHCTL 0x0040
2118 +#define BCMA_CC_FLASHCTL_START 0x80000000
2119 +#define BCMA_CC_FLASHCTL_BUSY BCMA_CC_FLASHCTL_START
2120 +#define BCMA_CC_FLASHADDR 0x0044
2121 +#define BCMA_CC_FLASHDATA 0x0048
2122 +#define BCMA_CC_BCAST_ADDR 0x0050
2123 +#define BCMA_CC_BCAST_DATA 0x0054
2124 +#define BCMA_CC_GPIOPULLUP 0x0058 /* Rev >= 20 only */
2125 +#define BCMA_CC_GPIOPULLDOWN 0x005C /* Rev >= 20 only */
2126 +#define BCMA_CC_GPIOIN 0x0060
2127 +#define BCMA_CC_GPIOOUT 0x0064
2128 +#define BCMA_CC_GPIOOUTEN 0x0068
2129 +#define BCMA_CC_GPIOCTL 0x006C
2130 +#define BCMA_CC_GPIOPOL 0x0070
2131 +#define BCMA_CC_GPIOIRQ 0x0074
2132 +#define BCMA_CC_WATCHDOG 0x0080
2133 +#define BCMA_CC_GPIOTIMER 0x0088 /* LED powersave (corerev >= 16) */
2134 +#define BCMA_CC_GPIOTIMER_OFFTIME 0x0000FFFF
2135 +#define BCMA_CC_GPIOTIMER_OFFTIME_SHIFT 0
2136 +#define BCMA_CC_GPIOTIMER_ONTIME 0xFFFF0000
2137 +#define BCMA_CC_GPIOTIMER_ONTIME_SHIFT 16
2138 +#define BCMA_CC_GPIOTOUTM 0x008C /* LED powersave (corerev >= 16) */
2139 +#define BCMA_CC_CLOCK_N 0x0090
2140 +#define BCMA_CC_CLOCK_SB 0x0094
2141 +#define BCMA_CC_CLOCK_PCI 0x0098
2142 +#define BCMA_CC_CLOCK_M2 0x009C
2143 +#define BCMA_CC_CLOCK_MIPS 0x00A0
2144 +#define BCMA_CC_CLKDIV 0x00A4 /* Rev >= 3 only */
2145 +#define BCMA_CC_CLKDIV_SFLASH 0x0F000000
2146 +#define BCMA_CC_CLKDIV_SFLASH_SHIFT 24
2147 +#define BCMA_CC_CLKDIV_OTP 0x000F0000
2148 +#define BCMA_CC_CLKDIV_OTP_SHIFT 16
2149 +#define BCMA_CC_CLKDIV_JTAG 0x00000F00
2150 +#define BCMA_CC_CLKDIV_JTAG_SHIFT 8
2151 +#define BCMA_CC_CLKDIV_UART 0x000000FF
2152 +#define BCMA_CC_CAP_EXT 0x00AC /* Capabilities */
2153 +#define BCMA_CC_PLLONDELAY 0x00B0 /* Rev >= 4 only */
2154 +#define BCMA_CC_FREFSELDELAY 0x00B4 /* Rev >= 4 only */
2155 +#define BCMA_CC_SLOWCLKCTL 0x00B8 /* 6 <= Rev <= 9 only */
2156 +#define BCMA_CC_SLOWCLKCTL_SRC 0x00000007 /* slow clock source mask */
2157 +#define BCMA_CC_SLOWCLKCTL_SRC_LPO 0x00000000 /* source of slow clock is LPO */
2158 +#define BCMA_CC_SLOWCLKCTL_SRC_XTAL 0x00000001 /* source of slow clock is crystal */
2159 +#define BCMA_CC_SLOECLKCTL_SRC_PCI 0x00000002 /* source of slow clock is PCI */
2160 +#define BCMA_CC_SLOWCLKCTL_LPOFREQ 0x00000200 /* LPOFreqSel, 1: 160Khz, 0: 32KHz */
2161 +#define BCMA_CC_SLOWCLKCTL_LPOPD 0x00000400 /* LPOPowerDown, 1: LPO is disabled, 0: LPO is enabled */
2162 +#define BCMA_CC_SLOWCLKCTL_FSLOW 0x00000800 /* ForceSlowClk, 1: sb/cores running on slow clock, 0: power logic control */
2163 +#define BCMA_CC_SLOWCLKCTL_IPLL 0x00001000 /* IgnorePllOffReq, 1/0: power logic ignores/honors PLL clock disable requests from core */
2164 +#define BCMA_CC_SLOWCLKCTL_ENXTAL 0x00002000 /* XtalControlEn, 1/0: power logic does/doesn't disable crystal when appropriate */
2165 +#define BCMA_CC_SLOWCLKCTL_XTALPU 0x00004000 /* XtalPU (RO), 1/0: crystal running/disabled */
2166 +#define BCMA_CC_SLOWCLKCTL_CLKDIV 0xFFFF0000 /* ClockDivider (SlowClk = 1/(4+divisor)) */
2167 +#define BCMA_CC_SLOWCLKCTL_CLKDIV_SHIFT 16
2168 +#define BCMA_CC_SYSCLKCTL 0x00C0 /* Rev >= 3 only */
2169 +#define BCMA_CC_SYSCLKCTL_IDLPEN 0x00000001 /* ILPen: Enable Idle Low Power */
2170 +#define BCMA_CC_SYSCLKCTL_ALPEN 0x00000002 /* ALPen: Enable Active Low Power */
2171 +#define BCMA_CC_SYSCLKCTL_PLLEN 0x00000004 /* ForcePLLOn */
2172 +#define BCMA_CC_SYSCLKCTL_FORCEALP 0x00000008 /* Force ALP (or HT if ALPen is not set */
2173 +#define BCMA_CC_SYSCLKCTL_FORCEHT 0x00000010 /* Force HT */
2174 +#define BCMA_CC_SYSCLKCTL_CLKDIV 0xFFFF0000 /* ClkDiv (ILP = 1/(4+divisor)) */
2175 +#define BCMA_CC_SYSCLKCTL_CLKDIV_SHIFT 16
2176 +#define BCMA_CC_CLKSTSTR 0x00C4 /* Rev >= 3 only */
2177 +#define BCMA_CC_EROM 0x00FC
2178 +#define BCMA_CC_PCMCIA_CFG 0x0100
2179 +#define BCMA_CC_PCMCIA_MEMWAIT 0x0104
2180 +#define BCMA_CC_PCMCIA_ATTRWAIT 0x0108
2181 +#define BCMA_CC_PCMCIA_IOWAIT 0x010C
2182 +#define BCMA_CC_IDE_CFG 0x0110
2183 +#define BCMA_CC_IDE_MEMWAIT 0x0114
2184 +#define BCMA_CC_IDE_ATTRWAIT 0x0118
2185 +#define BCMA_CC_IDE_IOWAIT 0x011C
2186 +#define BCMA_CC_PROG_CFG 0x0120
2187 +#define BCMA_CC_PROG_WAITCNT 0x0124
2188 +#define BCMA_CC_FLASH_CFG 0x0128
2189 +#define BCMA_CC_FLASH_WAITCNT 0x012C
2190 +/* 0x1E0 is defined as shared BCMA_CLKCTLST */
2191 +#define BCMA_CC_HW_WORKAROUND 0x01E4 /* Hardware workaround (rev >= 20) */
2192 +#define BCMA_CC_UART0_DATA 0x0300
2193 +#define BCMA_CC_UART0_IMR 0x0304
2194 +#define BCMA_CC_UART0_FCR 0x0308
2195 +#define BCMA_CC_UART0_LCR 0x030C
2196 +#define BCMA_CC_UART0_MCR 0x0310
2197 +#define BCMA_CC_UART0_LSR 0x0314
2198 +#define BCMA_CC_UART0_MSR 0x0318
2199 +#define BCMA_CC_UART0_SCRATCH 0x031C
2200 +#define BCMA_CC_UART1_DATA 0x0400
2201 +#define BCMA_CC_UART1_IMR 0x0404
2202 +#define BCMA_CC_UART1_FCR 0x0408
2203 +#define BCMA_CC_UART1_LCR 0x040C
2204 +#define BCMA_CC_UART1_MCR 0x0410
2205 +#define BCMA_CC_UART1_LSR 0x0414
2206 +#define BCMA_CC_UART1_MSR 0x0418
2207 +#define BCMA_CC_UART1_SCRATCH 0x041C
2208 +/* PMU registers (rev >= 20) */
2209 +#define BCMA_CC_PMU_CTL 0x0600 /* PMU control */
2210 +#define BCMA_CC_PMU_CTL_ILP_DIV 0xFFFF0000 /* ILP div mask */
2211 +#define BCMA_CC_PMU_CTL_ILP_DIV_SHIFT 16
2212 +#define BCMA_CC_PMU_CTL_NOILPONW 0x00000200 /* No ILP on wait */
2213 +#define BCMA_CC_PMU_CTL_HTREQEN 0x00000100 /* HT req enable */
2214 +#define BCMA_CC_PMU_CTL_ALPREQEN 0x00000080 /* ALP req enable */
2215 +#define BCMA_CC_PMU_CTL_XTALFREQ 0x0000007C /* Crystal freq */
2216 +#define BCMA_CC_PMU_CTL_XTALFREQ_SHIFT 2
2217 +#define BCMA_CC_PMU_CTL_ILPDIVEN 0x00000002 /* ILP div enable */
2218 +#define BCMA_CC_PMU_CTL_LPOSEL 0x00000001 /* LPO sel */
2219 +#define BCMA_CC_PMU_CAP 0x0604 /* PMU capabilities */
2220 +#define BCMA_CC_PMU_CAP_REVISION 0x000000FF /* Revision mask */
2221 +#define BCMA_CC_PMU_STAT 0x0608 /* PMU status */
2222 +#define BCMA_CC_PMU_STAT_INTPEND 0x00000040 /* Interrupt pending */
2223 +#define BCMA_CC_PMU_STAT_SBCLKST 0x00000030 /* Backplane clock status? */
2224 +#define BCMA_CC_PMU_STAT_HAVEALP 0x00000008 /* ALP available */
2225 +#define BCMA_CC_PMU_STAT_HAVEHT 0x00000004 /* HT available */
2226 +#define BCMA_CC_PMU_STAT_RESINIT 0x00000003 /* Res init */
2227 +#define BCMA_CC_PMU_RES_STAT 0x060C /* PMU res status */
2228 +#define BCMA_CC_PMU_RES_PEND 0x0610 /* PMU res pending */
2229 +#define BCMA_CC_PMU_TIMER 0x0614 /* PMU timer */
2230 +#define BCMA_CC_PMU_MINRES_MSK 0x0618 /* PMU min res mask */
2231 +#define BCMA_CC_PMU_MAXRES_MSK 0x061C /* PMU max res mask */
2232 +#define BCMA_CC_PMU_RES_TABSEL 0x0620 /* PMU res table sel */
2233 +#define BCMA_CC_PMU_RES_DEPMSK 0x0624 /* PMU res dep mask */
2234 +#define BCMA_CC_PMU_RES_UPDNTM 0x0628 /* PMU res updown timer */
2235 +#define BCMA_CC_PMU_RES_TIMER 0x062C /* PMU res timer */
2236 +#define BCMA_CC_PMU_CLKSTRETCH 0x0630 /* PMU clockstretch */
2237 +#define BCMA_CC_PMU_WATCHDOG 0x0634 /* PMU watchdog */
2238 +#define BCMA_CC_PMU_RES_REQTS 0x0640 /* PMU res req timer sel */
2239 +#define BCMA_CC_PMU_RES_REQT 0x0644 /* PMU res req timer */
2240 +#define BCMA_CC_PMU_RES_REQM 0x0648 /* PMU res req mask */
2241 +#define BCMA_CC_CHIPCTL_ADDR 0x0650
2242 +#define BCMA_CC_CHIPCTL_DATA 0x0654
2243 +#define BCMA_CC_REGCTL_ADDR 0x0658
2244 +#define BCMA_CC_REGCTL_DATA 0x065C
2245 +#define BCMA_CC_PLLCTL_ADDR 0x0660
2246 +#define BCMA_CC_PLLCTL_DATA 0x0664
2247 +#define BCMA_CC_SPROM 0x0800 /* SPROM beginning */
2248 +#define BCMA_CC_SPROM_PCIE6 0x0830 /* SPROM beginning on PCIe rev >= 6 */
2249 +
2250 +/* Data for the PMU, if available.
2251 + * Check availability with ((struct bcma_chipcommon)->capabilities & BCMA_CC_CAP_PMU)
2252 + */
2253 +struct bcma_chipcommon_pmu {
2254 + u8 rev; /* PMU revision */
2255 + u32 crystalfreq; /* The active crystal frequency (in kHz) */
2256 +};
2257 +
2258 +struct bcma_drv_cc {
2259 + struct bcma_device *core;
2260 + u32 status;
2261 + u32 capabilities;
2262 + u32 capabilities_ext;
2263 + /* Fast Powerup Delay constant */
2264 + u16 fast_pwrup_delay;
2265 + struct bcma_chipcommon_pmu pmu;
2266 +};
2267 +
2268 +/* Register access */
2269 +#define bcma_cc_read32(cc, offset) \
2270 + bcma_read32((cc)->core, offset)
2271 +#define bcma_cc_write32(cc, offset, val) \
2272 + bcma_write32((cc)->core, offset, val)
2273 +
2274 +#define bcma_cc_mask32(cc, offset, mask) \
2275 + bcma_cc_write32(cc, offset, bcma_cc_read32(cc, offset) & (mask))
2276 +#define bcma_cc_set32(cc, offset, set) \
2277 + bcma_cc_write32(cc, offset, bcma_cc_read32(cc, offset) | (set))
2278 +#define bcma_cc_maskset32(cc, offset, mask, set) \
2279 + bcma_cc_write32(cc, offset, (bcma_cc_read32(cc, offset) & (mask)) | (set))
2280 +
2281 +extern void bcma_core_chipcommon_init(struct bcma_drv_cc *cc);
2282 +
2283 +extern void bcma_chipco_suspend(struct bcma_drv_cc *cc);
2284 +extern void bcma_chipco_resume(struct bcma_drv_cc *cc);
2285 +
2286 +extern void bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc,
2287 + u32 ticks);
2288 +
2289 +void bcma_chipco_irq_mask(struct bcma_drv_cc *cc, u32 mask, u32 value);
2290 +
2291 +u32 bcma_chipco_irq_status(struct bcma_drv_cc *cc, u32 mask);
2292 +
2293 +/* Chipcommon GPIO pin access. */
2294 +u32 bcma_chipco_gpio_in(struct bcma_drv_cc *cc, u32 mask);
2295 +u32 bcma_chipco_gpio_out(struct bcma_drv_cc *cc, u32 mask, u32 value);
2296 +u32 bcma_chipco_gpio_outen(struct bcma_drv_cc *cc, u32 mask, u32 value);
2297 +u32 bcma_chipco_gpio_control(struct bcma_drv_cc *cc, u32 mask, u32 value);
2298 +u32 bcma_chipco_gpio_intmask(struct bcma_drv_cc *cc, u32 mask, u32 value);
2299 +u32 bcma_chipco_gpio_polarity(struct bcma_drv_cc *cc, u32 mask, u32 value);
2300 +
2301 +/* PMU support */
2302 +extern void bcma_pmu_init(struct bcma_drv_cc *cc);
2303 +
2304 +#endif /* LINUX_BCMA_DRIVER_CC_H_ */
2305 --- /dev/null
2306 +++ b/include/linux/bcma/bcma_driver_pci.h
2307 @@ -0,0 +1,91 @@
2308 +#ifndef LINUX_BCMA_DRIVER_PCI_H_
2309 +#define LINUX_BCMA_DRIVER_PCI_H_
2310 +
2311 +#include <linux/types.h>
2312 +
2313 +struct pci_dev;
2314 +
2315 +/** PCI core registers. **/
2316 +#define BCMA_CORE_PCI_CTL 0x0000 /* PCI Control */
2317 +#define BCMA_CORE_PCI_CTL_RST_OE 0x00000001 /* PCI_RESET Output Enable */
2318 +#define BCMA_CORE_PCI_CTL_RST 0x00000002 /* PCI_RESET driven out to pin */
2319 +#define BCMA_CORE_PCI_CTL_CLK_OE 0x00000004 /* Clock gate Output Enable */
2320 +#define BCMA_CORE_PCI_CTL_CLK 0x00000008 /* Gate for clock driven out to pin */
2321 +#define BCMA_CORE_PCI_ARBCTL 0x0010 /* PCI Arbiter Control */
2322 +#define BCMA_CORE_PCI_ARBCTL_INTERN 0x00000001 /* Use internal arbiter */
2323 +#define BCMA_CORE_PCI_ARBCTL_EXTERN 0x00000002 /* Use external arbiter */
2324 +#define BCMA_CORE_PCI_ARBCTL_PARKID 0x00000006 /* Mask, selects which agent is parked on an idle bus */
2325 +#define BCMA_CORE_PCI_ARBCTL_PARKID_LAST 0x00000000 /* Last requestor */
2326 +#define BCMA_CORE_PCI_ARBCTL_PARKID_4710 0x00000002 /* 4710 */
2327 +#define BCMA_CORE_PCI_ARBCTL_PARKID_EXT0 0x00000004 /* External requestor 0 */
2328 +#define BCMA_CORE_PCI_ARBCTL_PARKID_EXT1 0x00000006 /* External requestor 1 */
2329 +#define BCMA_CORE_PCI_ISTAT 0x0020 /* Interrupt status */
2330 +#define BCMA_CORE_PCI_ISTAT_INTA 0x00000001 /* PCI INTA# */
2331 +#define BCMA_CORE_PCI_ISTAT_INTB 0x00000002 /* PCI INTB# */
2332 +#define BCMA_CORE_PCI_ISTAT_SERR 0x00000004 /* PCI SERR# (write to clear) */
2333 +#define BCMA_CORE_PCI_ISTAT_PERR 0x00000008 /* PCI PERR# (write to clear) */
2334 +#define BCMA_CORE_PCI_ISTAT_PME 0x00000010 /* PCI PME# */
2335 +#define BCMA_CORE_PCI_IMASK 0x0024 /* Interrupt mask */
2336 +#define BCMA_CORE_PCI_IMASK_INTA 0x00000001 /* PCI INTA# */
2337 +#define BCMA_CORE_PCI_IMASK_INTB 0x00000002 /* PCI INTB# */
2338 +#define BCMA_CORE_PCI_IMASK_SERR 0x00000004 /* PCI SERR# */
2339 +#define BCMA_CORE_PCI_IMASK_PERR 0x00000008 /* PCI PERR# */
2340 +#define BCMA_CORE_PCI_IMASK_PME 0x00000010 /* PCI PME# */
2341 +#define BCMA_CORE_PCI_MBOX 0x0028 /* Backplane to PCI Mailbox */
2342 +#define BCMA_CORE_PCI_MBOX_F0_0 0x00000100 /* PCI function 0, INT 0 */
2343 +#define BCMA_CORE_PCI_MBOX_F0_1 0x00000200 /* PCI function 0, INT 1 */
2344 +#define BCMA_CORE_PCI_MBOX_F1_0 0x00000400 /* PCI function 1, INT 0 */
2345 +#define BCMA_CORE_PCI_MBOX_F1_1 0x00000800 /* PCI function 1, INT 1 */
2346 +#define BCMA_CORE_PCI_MBOX_F2_0 0x00001000 /* PCI function 2, INT 0 */
2347 +#define BCMA_CORE_PCI_MBOX_F2_1 0x00002000 /* PCI function 2, INT 1 */
2348 +#define BCMA_CORE_PCI_MBOX_F3_0 0x00004000 /* PCI function 3, INT 0 */
2349 +#define BCMA_CORE_PCI_MBOX_F3_1 0x00008000 /* PCI function 3, INT 1 */
2350 +#define BCMA_CORE_PCI_BCAST_ADDR 0x0050 /* Backplane Broadcast Address */
2351 +#define BCMA_CORE_PCI_BCAST_ADDR_MASK 0x000000FF
2352 +#define BCMA_CORE_PCI_BCAST_DATA 0x0054 /* Backplane Broadcast Data */
2353 +#define BCMA_CORE_PCI_GPIO_IN 0x0060 /* rev >= 2 only */
2354 +#define BCMA_CORE_PCI_GPIO_OUT 0x0064 /* rev >= 2 only */
2355 +#define BCMA_CORE_PCI_GPIO_ENABLE 0x0068 /* rev >= 2 only */
2356 +#define BCMA_CORE_PCI_GPIO_CTL 0x006C /* rev >= 2 only */
2357 +#define BCMA_CORE_PCI_SBTOPCI0 0x0100 /* Backplane to PCI translation 0 (sbtopci0) */
2358 +#define BCMA_CORE_PCI_SBTOPCI0_MASK 0xFC000000
2359 +#define BCMA_CORE_PCI_SBTOPCI1 0x0104 /* Backplane to PCI translation 1 (sbtopci1) */
2360 +#define BCMA_CORE_PCI_SBTOPCI1_MASK 0xFC000000
2361 +#define BCMA_CORE_PCI_SBTOPCI2 0x0108 /* Backplane to PCI translation 2 (sbtopci2) */
2362 +#define BCMA_CORE_PCI_SBTOPCI2_MASK 0xC0000000
2363 +#define BCMA_CORE_PCI_PCICFG0 0x0400 /* PCI config space 0 (rev >= 8) */
2364 +#define BCMA_CORE_PCI_PCICFG1 0x0500 /* PCI config space 1 (rev >= 8) */
2365 +#define BCMA_CORE_PCI_PCICFG2 0x0600 /* PCI config space 2 (rev >= 8) */
2366 +#define BCMA_CORE_PCI_PCICFG3 0x0700 /* PCI config space 3 (rev >= 8) */
2367 +#define BCMA_CORE_PCI_SPROM(wordoffset) (0x0800 + ((wordoffset) * 2)) /* SPROM shadow area (72 bytes) */
2368 +
2369 +/* SBtoPCIx */
2370 +#define BCMA_CORE_PCI_SBTOPCI_MEM 0x00000000
2371 +#define BCMA_CORE_PCI_SBTOPCI_IO 0x00000001
2372 +#define BCMA_CORE_PCI_SBTOPCI_CFG0 0x00000002
2373 +#define BCMA_CORE_PCI_SBTOPCI_CFG1 0x00000003
2374 +#define BCMA_CORE_PCI_SBTOPCI_PREF 0x00000004 /* Prefetch enable */
2375 +#define BCMA_CORE_PCI_SBTOPCI_BURST 0x00000008 /* Burst enable */
2376 +#define BCMA_CORE_PCI_SBTOPCI_MRM 0x00000020 /* Memory Read Multiple */
2377 +#define BCMA_CORE_PCI_SBTOPCI_RC 0x00000030 /* Read Command mask (rev >= 11) */
2378 +#define BCMA_CORE_PCI_SBTOPCI_RC_READ 0x00000000 /* Memory read */
2379 +#define BCMA_CORE_PCI_SBTOPCI_RC_READL 0x00000010 /* Memory read line */
2380 +#define BCMA_CORE_PCI_SBTOPCI_RC_READM 0x00000020 /* Memory read multiple */
2381 +
2382 +/* PCIcore specific boardflags */
2383 +#define BCMA_CORE_PCI_BFL_NOPCI 0x00000400 /* Board leaves PCI floating */
2384 +
2385 +struct bcma_drv_pci {
2386 + struct bcma_device *core;
2387 + u8 setup_done:1;
2388 +};
2389 +
2390 +/* Register access */
2391 +#define pcicore_read32(pc, offset) bcma_read32((pc)->core, offset)
2392 +#define pcicore_write32(pc, offset, val) bcma_write32((pc)->core, offset, val)
2393 +
2394 +extern void bcma_core_pci_init(struct bcma_drv_pci *pc);
2395 +extern int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc,
2396 + struct bcma_device *core, bool enable);
2397 +
2398 +#endif /* LINUX_BCMA_DRIVER_PCI_H_ */
2399 --- /dev/null
2400 +++ b/include/linux/bcma/bcma_regs.h
2401 @@ -0,0 +1,59 @@
2402 +#ifndef LINUX_BCMA_REGS_H_
2403 +#define LINUX_BCMA_REGS_H_
2404 +
2405 +/* Some single registers are shared between many cores */
2406 +/* BCMA_CLKCTLST: ChipCommon (rev >= 20), PCIe, 80211 */
2407 +#define BCMA_CLKCTLST 0x01E0 /* Clock control and status */
2408 +#define BCMA_CLKCTLST_FORCEALP 0x00000001 /* Force ALP request */
2409 +#define BCMA_CLKCTLST_FORCEHT 0x00000002 /* Force HT request */
2410 +#define BCMA_CLKCTLST_FORCEILP 0x00000004 /* Force ILP request */
2411 +#define BCMA_CLKCTLST_HAVEALPREQ 0x00000008 /* ALP available request */
2412 +#define BCMA_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */
2413 +#define BCMA_CLKCTLST_HWCROFF 0x00000020 /* Force HW clock request off */
2414 +#define BCMA_CLKCTLST_EXTRESREQ 0x00000700 /* Mask of external resource requests */
2415 +#define BCMA_CLKCTLST_HAVEALP 0x00010000 /* ALP available */
2416 +#define BCMA_CLKCTLST_HAVEHT 0x00020000 /* HT available */
2417 +#define BCMA_CLKCTLST_BP_ON_ALP 0x00040000 /* RO: running on ALP clock */
2418 +#define BCMA_CLKCTLST_BP_ON_HT 0x00080000 /* RO: running on HT clock */
2419 +#define BCMA_CLKCTLST_EXTRESST 0x07000000 /* Mask of external resource status */
2420 +/* Is there any BCM4328 on BCMA bus? */
2421 +#define BCMA_CLKCTLST_4328A0_HAVEHT 0x00010000 /* 4328a0 has reversed bits */
2422 +#define BCMA_CLKCTLST_4328A0_HAVEALP 0x00020000 /* 4328a0 has reversed bits */
2423 +
2424 +/* Agent registers (common for every core) */
2425 +#define BCMA_IOCTL 0x0408 /* IO control */
2426 +#define BCMA_IOCTL_CLK 0x0001
2427 +#define BCMA_IOCTL_FGC 0x0002
2428 +#define BCMA_IOCTL_CORE_BITS 0x3FFC
2429 +#define BCMA_IOCTL_PME_EN 0x4000
2430 +#define BCMA_IOCTL_BIST_EN 0x8000
2431 +#define BCMA_IOST 0x0500 /* IO status */
2432 +#define BCMA_IOST_CORE_BITS 0x0FFF
2433 +#define BCMA_IOST_DMA64 0x1000
2434 +#define BCMA_IOST_GATED_CLK 0x2000
2435 +#define BCMA_IOST_BIST_ERROR 0x4000
2436 +#define BCMA_IOST_BIST_DONE 0x8000
2437 +#define BCMA_RESET_CTL 0x0800
2438 +#define BCMA_RESET_CTL_RESET 0x0001
2439 +
2440 +/* BCMA PCI config space registers. */
2441 +#define BCMA_PCI_PMCSR 0x44
2442 +#define BCMA_PCI_PE 0x100
2443 +#define BCMA_PCI_BAR0_WIN 0x80 /* Backplane address space 0 */
2444 +#define BCMA_PCI_BAR1_WIN 0x84 /* Backplane address space 1 */
2445 +#define BCMA_PCI_SPROMCTL 0x88 /* SPROM control */
2446 +#define BCMA_PCI_SPROMCTL_WE 0x10 /* SPROM write enable */
2447 +#define BCMA_PCI_BAR1_CONTROL 0x8c /* Address space 1 burst control */
2448 +#define BCMA_PCI_IRQS 0x90 /* PCI interrupts */
2449 +#define BCMA_PCI_IRQMASK 0x94 /* PCI IRQ control and mask (pcirev >= 6 only) */
2450 +#define BCMA_PCI_BACKPLANE_IRQS 0x98 /* Backplane Interrupts */
2451 +#define BCMA_PCI_BAR0_WIN2 0xAC
2452 +#define BCMA_PCI_GPIO_IN 0xB0 /* GPIO Input (pcirev >= 3 only) */
2453 +#define BCMA_PCI_GPIO_OUT 0xB4 /* GPIO Output (pcirev >= 3 only) */
2454 +#define BCMA_PCI_GPIO_OUT_ENABLE 0xB8 /* GPIO Output Enable/Disable (pcirev >= 3 only) */
2455 +#define BCMA_PCI_GPIO_SCS 0x10 /* PCI config space bit 4 for 4306c0 slow clock source */
2456 +#define BCMA_PCI_GPIO_HWRAD 0x20 /* PCI config space GPIO 13 for hw radio disable */
2457 +#define BCMA_PCI_GPIO_XTAL 0x40 /* PCI config space GPIO 14 for Xtal powerup */
2458 +#define BCMA_PCI_GPIO_PLL 0x80 /* PCI config space GPIO 15 for PLL powerdown */
2459 +
2460 +#endif /* LINUX_BCMA_REGS_H_ */
2461 --- a/include/linux/mod_devicetable.h
2462 +++ b/include/linux/mod_devicetable.h
2463 @@ -382,6 +382,23 @@ struct ssb_device_id {
2464 #define SSB_ANY_ID 0xFFFF
2465 #define SSB_ANY_REV 0xFF
2466
2467 +/* Broadcom's specific AMBA core, see drivers/bcma/ */
2468 +struct bcma_device_id {
2469 + __u16 manuf;
2470 + __u16 id;
2471 + __u8 rev;
2472 + __u8 class;
2473 +};
2474 +#define BCMA_CORE(_manuf, _id, _rev, _class) \
2475 + { .manuf = _manuf, .id = _id, .rev = _rev, .class = _class, }
2476 +#define BCMA_CORETABLE_END \
2477 + { 0, },
2478 +
2479 +#define BCMA_ANY_MANUF 0xFFFF
2480 +#define BCMA_ANY_ID 0xFFFF
2481 +#define BCMA_ANY_REV 0xFF
2482 +#define BCMA_ANY_CLASS 0xFF
2483 +
2484 struct virtio_device_id {
2485 __u32 device;
2486 __u32 vendor;
2487 --- a/scripts/mod/file2alias.c
2488 +++ b/scripts/mod/file2alias.c
2489 @@ -633,6 +633,24 @@ static int do_ssb_entry(const char *file
2490 return 1;
2491 }
2492
2493 +/* Looks like: bcma:mNidNrevNclN. */
2494 +static int do_bcma_entry(const char *filename,
2495 + struct bcma_device_id *id, char *alias)
2496 +{
2497 + id->manuf = TO_NATIVE(id->manuf);
2498 + id->id = TO_NATIVE(id->id);
2499 + id->rev = TO_NATIVE(id->rev);
2500 + id->class = TO_NATIVE(id->class);
2501 +
2502 + strcpy(alias, "bcma:");
2503 + ADD(alias, "m", id->manuf != BCMA_ANY_MANUF, id->manuf);
2504 + ADD(alias, "id", id->id != BCMA_ANY_ID, id->id);
2505 + ADD(alias, "rev", id->rev != BCMA_ANY_REV, id->rev);
2506 + ADD(alias, "cl", id->class != BCMA_ANY_CLASS, id->class);
2507 + add_wildcard(alias);
2508 + return 1;
2509 +}
2510 +
2511 /* Looks like: virtio:dNvN */
2512 static int do_virtio_entry(const char *filename, struct virtio_device_id *id,
2513 char *alias)
2514 @@ -845,6 +863,10 @@ void handle_moddevtable(struct module *m
2515 do_table(symval, sym->st_size,
2516 sizeof(struct ssb_device_id), "ssb",
2517 do_ssb_entry, mod);
2518 + else if (sym_is(symname, "__mod_bcma_device_table"))
2519 + do_table(symval, sym->st_size,
2520 + sizeof(struct bcma_device_id), "bcma",
2521 + do_bcma_entry, mod);
2522 else if (sym_is(symname, "__mod_virtio_device_table"))
2523 do_table(symval, sym->st_size,
2524 sizeof(struct virtio_device_id), "virtio",
2525 --- /dev/null
2526 +++ b/drivers/bcma/sprom.c
2527 @@ -0,0 +1,171 @@
2528 +/*
2529 + * Broadcom specific AMBA
2530 + * SPROM reading
2531 + *
2532 + * Licensed under the GNU/GPL. See COPYING for details.
2533 + */
2534 +
2535 +#include "bcma_private.h"
2536 +
2537 +#include <linux/bcma/bcma.h>
2538 +#include <linux/bcma/bcma_regs.h>
2539 +#include <linux/pci.h>
2540 +#include <linux/io.h>
2541 +#include <linux/dma-mapping.h>
2542 +#include <linux/slab.h>
2543 +
2544 +#define SPOFF(offset) ((offset) / sizeof(u16))
2545 +
2546 +/**************************************************
2547 + * R/W ops.
2548 + **************************************************/
2549 +
2550 +static void bcma_sprom_read(struct bcma_bus *bus, u16 offset, u16 *sprom)
2551 +{
2552 + int i;
2553 + for (i = 0; i < SSB_SPROMSIZE_WORDS_R4; i++)
2554 + sprom[i] = bcma_read16(bus->drv_cc.core,
2555 + offset + (i * 2));
2556 +}
2557 +
2558 +/**************************************************
2559 + * Validation.
2560 + **************************************************/
2561 +
2562 +static inline u8 bcma_crc8(u8 crc, u8 data)
2563 +{
2564 + /* Polynomial: x^8 + x^7 + x^6 + x^4 + x^2 + 1 */
2565 + static const u8 t[] = {
2566 + 0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
2567 + 0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
2568 + 0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
2569 + 0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
2570 + 0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
2571 + 0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
2572 + 0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
2573 + 0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
2574 + 0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
2575 + 0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
2576 + 0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
2577 + 0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
2578 + 0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
2579 + 0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
2580 + 0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
2581 + 0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
2582 + 0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
2583 + 0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
2584 + 0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
2585 + 0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
2586 + 0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
2587 + 0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
2588 + 0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
2589 + 0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
2590 + 0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
2591 + 0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
2592 + 0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
2593 + 0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
2594 + 0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
2595 + 0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
2596 + 0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
2597 + 0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F,
2598 + };
2599 + return t[crc ^ data];
2600 +}
2601 +
2602 +static u8 bcma_sprom_crc(const u16 *sprom)
2603 +{
2604 + int word;
2605 + u8 crc = 0xFF;
2606 +
2607 + for (word = 0; word < SSB_SPROMSIZE_WORDS_R4 - 1; word++) {
2608 + crc = bcma_crc8(crc, sprom[word] & 0x00FF);
2609 + crc = bcma_crc8(crc, (sprom[word] & 0xFF00) >> 8);
2610 + }
2611 + crc = bcma_crc8(crc, sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & 0x00FF);
2612 + crc ^= 0xFF;
2613 +
2614 + return crc;
2615 +}
2616 +
2617 +static int bcma_sprom_check_crc(const u16 *sprom)
2618 +{
2619 + u8 crc;
2620 + u8 expected_crc;
2621 + u16 tmp;
2622 +
2623 + crc = bcma_sprom_crc(sprom);
2624 + tmp = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & SSB_SPROM_REVISION_CRC;
2625 + expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
2626 + if (crc != expected_crc)
2627 + return -EPROTO;
2628 +
2629 + return 0;
2630 +}
2631 +
2632 +static int bcma_sprom_valid(const u16 *sprom)
2633 +{
2634 + u16 revision;
2635 + int err;
2636 +
2637 + err = bcma_sprom_check_crc(sprom);
2638 + if (err)
2639 + return err;
2640 +
2641 + revision = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & SSB_SPROM_REVISION_REV;
2642 + if (revision != 8 && revision != 9) {
2643 + pr_err("Unsupported SPROM revision: %d\n", revision);
2644 + return -ENOENT;
2645 + }
2646 +
2647 + return 0;
2648 +}
2649 +
2650 +/**************************************************
2651 + * SPROM extraction.
2652 + **************************************************/
2653 +
2654 +static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom)
2655 +{
2656 + u16 v;
2657 + int i;
2658 +
2659 + for (i = 0; i < 3; i++) {
2660 + v = sprom[SPOFF(SSB_SPROM8_IL0MAC) + i];
2661 + *(((__be16 *)bus->sprom.il0mac) + i) = cpu_to_be16(v);
2662 + }
2663 +}
2664 +
2665 +int bcma_sprom_get(struct bcma_bus *bus)
2666 +{
2667 + u16 offset;
2668 + u16 *sprom;
2669 + int err = 0;
2670 +
2671 + if (!bus->drv_cc.core)
2672 + return -EOPNOTSUPP;
2673 +
2674 + if (!(bus->drv_cc.capabilities & BCMA_CC_CAP_SPROM))
2675 + return -ENOENT;
2676 +
2677 + sprom = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
2678 + GFP_KERNEL);
2679 + if (!sprom)
2680 + return -ENOMEM;
2681 +
2682 + /* Most cards have SPROM moved by additional offset 0x30 (48 dwords).
2683 + * According to brcm80211 this applies to cards with PCIe rev >= 6
2684 + * TODO: understand this condition and use it */
2685 + offset = (bus->chipinfo.id == 0x4331) ? BCMA_CC_SPROM :
2686 + BCMA_CC_SPROM_PCIE6;
2687 + bcma_sprom_read(bus, offset, sprom);
2688 +
2689 + err = bcma_sprom_valid(sprom);
2690 + if (err)
2691 + goto out;
2692 +
2693 + bcma_sprom_extract_r8(bus, sprom);
2694 +
2695 +out:
2696 + kfree(sprom);
2697 + return err;
2698 +}
2699 --- /dev/null
2700 +++ b/drivers/bcma/driver_pci_host.c
2701 @@ -0,0 +1,14 @@
2702 +/*
2703 + * Broadcom specific AMBA
2704 + * PCI Core in hostmode
2705 + *
2706 + * Licensed under the GNU/GPL. See COPYING for details.
2707 + */
2708 +
2709 +#include "bcma_private.h"
2710 +#include <linux/bcma/bcma.h>
2711 +
2712 +void bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc)
2713 +{
2714 + pr_err("No support for PCI core in hostmode yet\n");
2715 +}
Personal OpenWRT clone
This page took 0.167765 seconds and 5 git commands to generate.