2 * Broadcom specific AMBA
5 * Licensed under the GNU/GPL. See COPYING for details.
8 #include "bcma_private.h"
9 #include <linux/module.h>
10 #include <linux/platform_device.h>
11 #include <linux/bcma/bcma.h>
12 #include <linux/slab.h>
14 MODULE_DESCRIPTION("Broadcom's specific AMBA driver");
15 MODULE_LICENSE("GPL");
17 /* contains the number the next bus should get. */
18 static unsigned int bcma_bus_next_num
= 0;
20 /* bcma_buses_mutex locks the bcma_bus_next_num */
21 static DEFINE_MUTEX(bcma_buses_mutex
);
23 static int bcma_bus_match(struct device
*dev
, struct device_driver
*drv
);
24 static int bcma_device_probe(struct device
*dev
);
25 static int bcma_device_remove(struct device
*dev
);
26 static int bcma_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
);
28 static ssize_t
manuf_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
30 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
31 return sprintf(buf
, "0x%03X\n", core
->id
.manuf
);
33 static DEVICE_ATTR_RO(manuf
);
35 static ssize_t
id_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
37 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
38 return sprintf(buf
, "0x%03X\n", core
->id
.id
);
40 static DEVICE_ATTR_RO(id
);
42 static ssize_t
rev_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
44 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
45 return sprintf(buf
, "0x%02X\n", core
->id
.rev
);
47 static DEVICE_ATTR_RO(rev
);
49 static ssize_t
class_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
51 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
52 return sprintf(buf
, "0x%X\n", core
->id
.class);
54 static DEVICE_ATTR_RO(class);
56 static struct attribute
*bcma_device_attrs
[] = {
63 ATTRIBUTE_GROUPS(bcma_device
);
65 static struct bus_type bcma_bus_type
= {
67 .match
= bcma_bus_match
,
68 .probe
= bcma_device_probe
,
69 .remove
= bcma_device_remove
,
70 .uevent
= bcma_device_uevent
,
71 .dev_groups
= bcma_device_groups
,
74 static u16
bcma_cc_core_id(struct bcma_bus
*bus
)
76 if (bus
->chipinfo
.id
== BCMA_CHIP_ID_BCM4706
)
77 return BCMA_CORE_4706_CHIPCOMMON
;
78 return BCMA_CORE_CHIPCOMMON
;
81 struct bcma_device
*bcma_find_core(struct bcma_bus
*bus
, u16 coreid
)
83 struct bcma_device
*core
;
85 list_for_each_entry(core
, &bus
->cores
, list
) {
86 if (core
->id
.id
== coreid
)
91 EXPORT_SYMBOL_GPL(bcma_find_core
);
93 struct bcma_device
*bcma_find_core_unit(struct bcma_bus
*bus
, u16 coreid
,
96 struct bcma_device
*core
;
98 list_for_each_entry(core
, &bus
->cores
, list
) {
99 if (core
->id
.id
== coreid
&& core
->core_unit
== unit
)
105 bool bcma_wait_value(struct bcma_device
*core
, u16 reg
, u32 mask
, u32 value
,
108 unsigned long deadline
= jiffies
+ timeout
;
112 val
= bcma_read32(core
, reg
);
113 if ((val
& mask
) == value
)
117 } while (!time_after_eq(jiffies
, deadline
));
119 bcma_warn(core
->bus
, "Timeout waiting for register 0x%04X!\n", reg
);
124 static void bcma_release_core_dev(struct device
*dev
)
126 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
128 iounmap(core
->io_addr
);
130 iounmap(core
->io_wrap
);
134 static int bcma_register_cores(struct bcma_bus
*bus
)
136 struct bcma_device
*core
;
139 list_for_each_entry(core
, &bus
->cores
, list
) {
140 /* We support that cores ourself */
141 switch (core
->id
.id
) {
142 case BCMA_CORE_4706_CHIPCOMMON
:
143 case BCMA_CORE_CHIPCOMMON
:
146 case BCMA_CORE_MIPS_74K
:
147 case BCMA_CORE_4706_MAC_GBIT_COMMON
:
151 /* Only first GMAC core on BCM4706 is connected and working */
152 if (core
->id
.id
== BCMA_CORE_4706_MAC_GBIT
&&
156 core
->dev
.release
= bcma_release_core_dev
;
157 core
->dev
.bus
= &bcma_bus_type
;
158 dev_set_name(&core
->dev
, "bcma%d:%d", bus
->num
, dev_id
);
160 switch (bus
->hosttype
) {
161 case BCMA_HOSTTYPE_PCI
:
162 core
->dev
.parent
= &bus
->host_pci
->dev
;
163 core
->dma_dev
= &bus
->host_pci
->dev
;
164 core
->irq
= bus
->host_pci
->irq
;
166 case BCMA_HOSTTYPE_SOC
:
167 core
->dev
.dma_mask
= &core
->dev
.coherent_dma_mask
;
168 core
->dma_dev
= &core
->dev
;
170 case BCMA_HOSTTYPE_SDIO
:
174 err
= device_register(&core
->dev
);
177 "Could not register dev for core 0x%03X\n",
181 core
->dev_registered
= true;
185 #ifdef CONFIG_BCMA_DRIVER_MIPS
186 if (bus
->drv_cc
.pflash
.present
) {
187 err
= platform_device_register(&bcma_pflash_dev
);
189 bcma_err(bus
, "Error registering parallel flash\n");
193 #ifdef CONFIG_BCMA_SFLASH
194 if (bus
->drv_cc
.sflash
.present
) {
195 err
= platform_device_register(&bcma_sflash_dev
);
197 bcma_err(bus
, "Error registering serial flash\n");
201 #ifdef CONFIG_BCMA_NFLASH
202 if (bus
->drv_cc
.nflash
.present
) {
203 err
= platform_device_register(&bcma_nflash_dev
);
205 bcma_err(bus
, "Error registering NAND flash\n");
208 err
= bcma_gpio_init(&bus
->drv_cc
);
209 if (err
== -ENOTSUPP
)
210 bcma_debug(bus
, "GPIO driver not activated\n");
212 bcma_err(bus
, "Error registering GPIO driver: %i\n", err
);
214 if (bus
->hosttype
== BCMA_HOSTTYPE_SOC
) {
215 err
= bcma_chipco_watchdog_register(&bus
->drv_cc
);
217 bcma_err(bus
, "Error registering watchdog driver\n");
223 static void bcma_unregister_cores(struct bcma_bus
*bus
)
225 struct bcma_device
*core
, *tmp
;
227 list_for_each_entry_safe(core
, tmp
, &bus
->cores
, list
) {
228 list_del(&core
->list
);
229 if (core
->dev_registered
)
230 device_unregister(&core
->dev
);
232 if (bus
->hosttype
== BCMA_HOSTTYPE_SOC
)
233 platform_device_unregister(bus
->drv_cc
.watchdog
);
236 int bcma_bus_register(struct bcma_bus
*bus
)
239 struct bcma_device
*core
;
241 mutex_lock(&bcma_buses_mutex
);
242 bus
->num
= bcma_bus_next_num
++;
243 mutex_unlock(&bcma_buses_mutex
);
245 /* Scan for devices (cores) */
246 err
= bcma_bus_scan(bus
);
248 bcma_err(bus
, "Failed to scan: %d\n", err
);
252 /* Early init CC core */
253 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
255 bus
->drv_cc
.core
= core
;
256 bcma_core_chipcommon_early_init(&bus
->drv_cc
);
259 /* Try to get SPROM */
260 err
= bcma_sprom_get(bus
);
261 if (err
== -ENOENT
) {
262 bcma_err(bus
, "No SPROM available\n");
264 bcma_err(bus
, "Failed to get SPROM: %d\n", err
);
267 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
269 bus
->drv_cc
.core
= core
;
270 bcma_core_chipcommon_init(&bus
->drv_cc
);
274 core
= bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
276 bus
->drv_mips
.core
= core
;
277 bcma_core_mips_init(&bus
->drv_mips
);
281 core
= bcma_find_core_unit(bus
, BCMA_CORE_PCIE
, 0);
283 bus
->drv_pci
[0].core
= core
;
284 bcma_core_pci_init(&bus
->drv_pci
[0]);
288 core
= bcma_find_core_unit(bus
, BCMA_CORE_PCIE
, 1);
290 bus
->drv_pci
[1].core
= core
;
291 bcma_core_pci_init(&bus
->drv_pci
[1]);
294 /* Init GBIT MAC COMMON core */
295 core
= bcma_find_core(bus
, BCMA_CORE_4706_MAC_GBIT_COMMON
);
297 bus
->drv_gmac_cmn
.core
= core
;
298 bcma_core_gmac_cmn_init(&bus
->drv_gmac_cmn
);
301 /* Register found cores */
302 bcma_register_cores(bus
);
304 bcma_info(bus
, "Bus registered\n");
309 void bcma_bus_unregister(struct bcma_bus
*bus
)
311 struct bcma_device
*cores
[3];
314 err
= bcma_gpio_unregister(&bus
->drv_cc
);
316 bcma_err(bus
, "Some GPIOs are still in use.\n");
318 bcma_err(bus
, "Can not unregister GPIO driver: %i\n", err
);
320 cores
[0] = bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
321 cores
[1] = bcma_find_core(bus
, BCMA_CORE_PCIE
);
322 cores
[2] = bcma_find_core(bus
, BCMA_CORE_4706_MAC_GBIT_COMMON
);
324 bcma_unregister_cores(bus
);
331 int __init
bcma_bus_early_register(struct bcma_bus
*bus
,
332 struct bcma_device
*core_cc
,
333 struct bcma_device
*core_mips
)
336 struct bcma_device
*core
;
337 struct bcma_device_id match
;
341 match
.manuf
= BCMA_MANUF_BCM
;
342 match
.id
= bcma_cc_core_id(bus
);
343 match
.class = BCMA_CL_SIM
;
344 match
.rev
= BCMA_ANY_REV
;
346 /* Scan for chip common core */
347 err
= bcma_bus_scan_early(bus
, &match
, core_cc
);
349 bcma_err(bus
, "Failed to scan for common core: %d\n", err
);
353 match
.manuf
= BCMA_MANUF_MIPS
;
354 match
.id
= BCMA_CORE_MIPS_74K
;
355 match
.class = BCMA_CL_SIM
;
356 match
.rev
= BCMA_ANY_REV
;
358 /* Scan for mips core */
359 err
= bcma_bus_scan_early(bus
, &match
, core_mips
);
361 bcma_err(bus
, "Failed to scan for mips core: %d\n", err
);
365 /* Early init CC core */
366 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
368 bus
->drv_cc
.core
= core
;
369 bcma_core_chipcommon_early_init(&bus
->drv_cc
);
372 /* Early init MIPS core */
373 core
= bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
375 bus
->drv_mips
.core
= core
;
376 bcma_core_mips_early_init(&bus
->drv_mips
);
379 bcma_info(bus
, "Early bus registered\n");
385 int bcma_bus_suspend(struct bcma_bus
*bus
)
387 struct bcma_device
*core
;
389 list_for_each_entry(core
, &bus
->cores
, list
) {
390 struct device_driver
*drv
= core
->dev
.driver
;
392 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
400 int bcma_bus_resume(struct bcma_bus
*bus
)
402 struct bcma_device
*core
;
405 if (bus
->drv_cc
.core
) {
406 bus
->drv_cc
.setup_done
= false;
407 bcma_core_chipcommon_init(&bus
->drv_cc
);
410 list_for_each_entry(core
, &bus
->cores
, list
) {
411 struct device_driver
*drv
= core
->dev
.driver
;
413 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
423 int __bcma_driver_register(struct bcma_driver
*drv
, struct module
*owner
)
425 drv
->drv
.name
= drv
->name
;
426 drv
->drv
.bus
= &bcma_bus_type
;
427 drv
->drv
.owner
= owner
;
429 return driver_register(&drv
->drv
);
431 EXPORT_SYMBOL_GPL(__bcma_driver_register
);
433 void bcma_driver_unregister(struct bcma_driver
*drv
)
435 driver_unregister(&drv
->drv
);
437 EXPORT_SYMBOL_GPL(bcma_driver_unregister
);
439 static int bcma_bus_match(struct device
*dev
, struct device_driver
*drv
)
441 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
442 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
443 const struct bcma_device_id
*cid
= &core
->id
;
444 const struct bcma_device_id
*did
;
446 for (did
= adrv
->id_table
; did
->manuf
|| did
->id
|| did
->rev
; did
++) {
447 if ((did
->manuf
== cid
->manuf
|| did
->manuf
== BCMA_ANY_MANUF
) &&
448 (did
->id
== cid
->id
|| did
->id
== BCMA_ANY_ID
) &&
449 (did
->rev
== cid
->rev
|| did
->rev
== BCMA_ANY_REV
) &&
450 (did
->class == cid
->class || did
->class == BCMA_ANY_CLASS
))
456 static int bcma_device_probe(struct device
*dev
)
458 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
459 struct bcma_driver
*adrv
= container_of(dev
->driver
, struct bcma_driver
,
464 err
= adrv
->probe(core
);
469 static int bcma_device_remove(struct device
*dev
)
471 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
472 struct bcma_driver
*adrv
= container_of(dev
->driver
, struct bcma_driver
,
481 static int bcma_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
483 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
485 return add_uevent_var(env
,
486 "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
487 core
->id
.manuf
, core
->id
.id
,
488 core
->id
.rev
, core
->id
.class);
491 static int __init
bcma_modinit(void)
495 err
= bus_register(&bcma_bus_type
);
499 #ifdef CONFIG_BCMA_HOST_PCI
500 err
= bcma_host_pci_init();
502 pr_err("PCI host initialization failed\n");
509 fs_initcall(bcma_modinit
);
511 static void __exit
bcma_modexit(void)
513 #ifdef CONFIG_BCMA_HOST_PCI
514 bcma_host_pci_exit();
516 bus_unregister(&bcma_bus_type
);
518 module_exit(bcma_modexit
)