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_unit(struct bcma_bus
*bus
, u16 coreid
,
84 struct bcma_device
*core
;
86 list_for_each_entry(core
, &bus
->cores
, list
) {
87 if (core
->id
.id
== coreid
&& core
->core_unit
== unit
)
92 EXPORT_SYMBOL_GPL(bcma_find_core_unit
);
94 bool bcma_wait_value(struct bcma_device
*core
, u16 reg
, u32 mask
, u32 value
,
97 unsigned long deadline
= jiffies
+ timeout
;
101 val
= bcma_read32(core
, reg
);
102 if ((val
& mask
) == value
)
106 } while (!time_after_eq(jiffies
, deadline
));
108 bcma_warn(core
->bus
, "Timeout waiting for register 0x%04X!\n", reg
);
113 static void bcma_release_core_dev(struct device
*dev
)
115 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
117 iounmap(core
->io_addr
);
119 iounmap(core
->io_wrap
);
123 static int bcma_register_cores(struct bcma_bus
*bus
)
125 struct bcma_device
*core
;
128 list_for_each_entry(core
, &bus
->cores
, list
) {
129 /* We support that cores ourself */
130 switch (core
->id
.id
) {
131 case BCMA_CORE_4706_CHIPCOMMON
:
132 case BCMA_CORE_CHIPCOMMON
:
135 case BCMA_CORE_PCIE2
:
136 case BCMA_CORE_MIPS_74K
:
137 case BCMA_CORE_4706_MAC_GBIT_COMMON
:
141 /* Only first GMAC core on BCM4706 is connected and working */
142 if (core
->id
.id
== BCMA_CORE_4706_MAC_GBIT
&&
146 core
->dev
.release
= bcma_release_core_dev
;
147 core
->dev
.bus
= &bcma_bus_type
;
148 dev_set_name(&core
->dev
, "bcma%d:%d", bus
->num
, dev_id
);
150 switch (bus
->hosttype
) {
151 case BCMA_HOSTTYPE_PCI
:
152 core
->dev
.parent
= &bus
->host_pci
->dev
;
153 core
->dma_dev
= &bus
->host_pci
->dev
;
154 core
->irq
= bus
->host_pci
->irq
;
156 case BCMA_HOSTTYPE_SOC
:
157 core
->dev
.dma_mask
= &core
->dev
.coherent_dma_mask
;
158 core
->dma_dev
= &core
->dev
;
160 case BCMA_HOSTTYPE_SDIO
:
164 err
= device_register(&core
->dev
);
167 "Could not register dev for core 0x%03X\n",
169 put_device(&core
->dev
);
172 core
->dev_registered
= true;
176 #ifdef CONFIG_BCMA_DRIVER_MIPS
177 if (bus
->drv_cc
.pflash
.present
) {
178 err
= platform_device_register(&bcma_pflash_dev
);
180 bcma_err(bus
, "Error registering parallel flash\n");
184 #ifdef CONFIG_BCMA_SFLASH
185 if (bus
->drv_cc
.sflash
.present
) {
186 err
= platform_device_register(&bcma_sflash_dev
);
188 bcma_err(bus
, "Error registering serial flash\n");
192 #ifdef CONFIG_BCMA_NFLASH
193 if (bus
->drv_cc
.nflash
.present
) {
194 err
= platform_device_register(&bcma_nflash_dev
);
196 bcma_err(bus
, "Error registering NAND flash\n");
199 err
= bcma_gpio_init(&bus
->drv_cc
);
200 if (err
== -ENOTSUPP
)
201 bcma_debug(bus
, "GPIO driver not activated\n");
203 bcma_err(bus
, "Error registering GPIO driver: %i\n", err
);
205 if (bus
->hosttype
== BCMA_HOSTTYPE_SOC
) {
206 err
= bcma_chipco_watchdog_register(&bus
->drv_cc
);
208 bcma_err(bus
, "Error registering watchdog driver\n");
214 static void bcma_unregister_cores(struct bcma_bus
*bus
)
216 struct bcma_device
*core
, *tmp
;
218 list_for_each_entry_safe(core
, tmp
, &bus
->cores
, list
) {
219 list_del(&core
->list
);
220 if (core
->dev_registered
)
221 device_unregister(&core
->dev
);
223 if (bus
->hosttype
== BCMA_HOSTTYPE_SOC
)
224 platform_device_unregister(bus
->drv_cc
.watchdog
);
227 int bcma_bus_register(struct bcma_bus
*bus
)
230 struct bcma_device
*core
;
232 mutex_lock(&bcma_buses_mutex
);
233 bus
->num
= bcma_bus_next_num
++;
234 mutex_unlock(&bcma_buses_mutex
);
236 /* Scan for devices (cores) */
237 err
= bcma_bus_scan(bus
);
239 bcma_err(bus
, "Failed to scan: %d\n", err
);
243 /* Early init CC core */
244 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
246 bus
->drv_cc
.core
= core
;
247 bcma_core_chipcommon_early_init(&bus
->drv_cc
);
250 /* Try to get SPROM */
251 err
= bcma_sprom_get(bus
);
252 if (err
== -ENOENT
) {
253 bcma_err(bus
, "No SPROM available\n");
255 bcma_err(bus
, "Failed to get SPROM: %d\n", err
);
258 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
260 bus
->drv_cc
.core
= core
;
261 bcma_core_chipcommon_init(&bus
->drv_cc
);
265 core
= bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
267 bus
->drv_mips
.core
= core
;
268 bcma_core_mips_init(&bus
->drv_mips
);
272 core
= bcma_find_core_unit(bus
, BCMA_CORE_PCIE
, 0);
274 bus
->drv_pci
[0].core
= core
;
275 bcma_core_pci_init(&bus
->drv_pci
[0]);
279 core
= bcma_find_core_unit(bus
, BCMA_CORE_PCIE
, 1);
281 bus
->drv_pci
[1].core
= core
;
282 bcma_core_pci_init(&bus
->drv_pci
[1]);
285 /* Init PCIe Gen 2 core */
286 core
= bcma_find_core_unit(bus
, BCMA_CORE_PCIE2
, 0);
288 bus
->drv_pcie2
.core
= core
;
289 bcma_core_pcie2_init(&bus
->drv_pcie2
);
292 /* Init GBIT MAC COMMON core */
293 core
= bcma_find_core(bus
, BCMA_CORE_4706_MAC_GBIT_COMMON
);
295 bus
->drv_gmac_cmn
.core
= core
;
296 bcma_core_gmac_cmn_init(&bus
->drv_gmac_cmn
);
299 /* Register found cores */
300 bcma_register_cores(bus
);
302 bcma_info(bus
, "Bus registered\n");
307 void bcma_bus_unregister(struct bcma_bus
*bus
)
309 struct bcma_device
*cores
[3];
312 err
= bcma_gpio_unregister(&bus
->drv_cc
);
314 bcma_err(bus
, "Some GPIOs are still in use.\n");
316 bcma_err(bus
, "Can not unregister GPIO driver: %i\n", err
);
318 cores
[0] = bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
319 cores
[1] = bcma_find_core(bus
, BCMA_CORE_PCIE
);
320 cores
[2] = bcma_find_core(bus
, BCMA_CORE_4706_MAC_GBIT_COMMON
);
322 bcma_unregister_cores(bus
);
329 int __init
bcma_bus_early_register(struct bcma_bus
*bus
,
330 struct bcma_device
*core_cc
,
331 struct bcma_device
*core_mips
)
334 struct bcma_device
*core
;
335 struct bcma_device_id match
;
339 match
.manuf
= BCMA_MANUF_BCM
;
340 match
.id
= bcma_cc_core_id(bus
);
341 match
.class = BCMA_CL_SIM
;
342 match
.rev
= BCMA_ANY_REV
;
344 /* Scan for chip common core */
345 err
= bcma_bus_scan_early(bus
, &match
, core_cc
);
347 bcma_err(bus
, "Failed to scan for common core: %d\n", err
);
351 match
.manuf
= BCMA_MANUF_MIPS
;
352 match
.id
= BCMA_CORE_MIPS_74K
;
353 match
.class = BCMA_CL_SIM
;
354 match
.rev
= BCMA_ANY_REV
;
356 /* Scan for mips core */
357 err
= bcma_bus_scan_early(bus
, &match
, core_mips
);
359 bcma_err(bus
, "Failed to scan for mips core: %d\n", err
);
363 /* Early init CC core */
364 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
366 bus
->drv_cc
.core
= core
;
367 bcma_core_chipcommon_early_init(&bus
->drv_cc
);
370 /* Early init MIPS core */
371 core
= bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
373 bus
->drv_mips
.core
= core
;
374 bcma_core_mips_early_init(&bus
->drv_mips
);
377 bcma_info(bus
, "Early bus registered\n");
383 int bcma_bus_suspend(struct bcma_bus
*bus
)
385 struct bcma_device
*core
;
387 list_for_each_entry(core
, &bus
->cores
, list
) {
388 struct device_driver
*drv
= core
->dev
.driver
;
390 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
398 int bcma_bus_resume(struct bcma_bus
*bus
)
400 struct bcma_device
*core
;
403 if (bus
->drv_cc
.core
) {
404 bus
->drv_cc
.setup_done
= false;
405 bcma_core_chipcommon_init(&bus
->drv_cc
);
408 list_for_each_entry(core
, &bus
->cores
, list
) {
409 struct device_driver
*drv
= core
->dev
.driver
;
411 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
421 int __bcma_driver_register(struct bcma_driver
*drv
, struct module
*owner
)
423 drv
->drv
.name
= drv
->name
;
424 drv
->drv
.bus
= &bcma_bus_type
;
425 drv
->drv
.owner
= owner
;
427 return driver_register(&drv
->drv
);
429 EXPORT_SYMBOL_GPL(__bcma_driver_register
);
431 void bcma_driver_unregister(struct bcma_driver
*drv
)
433 driver_unregister(&drv
->drv
);
435 EXPORT_SYMBOL_GPL(bcma_driver_unregister
);
437 static int bcma_bus_match(struct device
*dev
, struct device_driver
*drv
)
439 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
440 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
441 const struct bcma_device_id
*cid
= &core
->id
;
442 const struct bcma_device_id
*did
;
444 for (did
= adrv
->id_table
; did
->manuf
|| did
->id
|| did
->rev
; did
++) {
445 if ((did
->manuf
== cid
->manuf
|| did
->manuf
== BCMA_ANY_MANUF
) &&
446 (did
->id
== cid
->id
|| did
->id
== BCMA_ANY_ID
) &&
447 (did
->rev
== cid
->rev
|| did
->rev
== BCMA_ANY_REV
) &&
448 (did
->class == cid
->class || did
->class == BCMA_ANY_CLASS
))
454 static int bcma_device_probe(struct device
*dev
)
456 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
457 struct bcma_driver
*adrv
= container_of(dev
->driver
, struct bcma_driver
,
462 err
= adrv
->probe(core
);
467 static int bcma_device_remove(struct device
*dev
)
469 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
470 struct bcma_driver
*adrv
= container_of(dev
->driver
, struct bcma_driver
,
479 static int bcma_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
481 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
483 return add_uevent_var(env
,
484 "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
485 core
->id
.manuf
, core
->id
.id
,
486 core
->id
.rev
, core
->id
.class);
489 static int __init
bcma_modinit(void)
493 err
= bus_register(&bcma_bus_type
);
497 #ifdef CONFIG_BCMA_HOST_PCI
498 err
= bcma_host_pci_init();
500 pr_err("PCI host initialization failed\n");
507 fs_initcall(bcma_modinit
);
509 static void __exit
bcma_modexit(void)
511 #ifdef CONFIG_BCMA_HOST_PCI
512 bcma_host_pci_exit();
514 bus_unregister(&bcma_bus_type
);
516 module_exit(bcma_modexit
)