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 ssize_t
id_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
35 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
36 return sprintf(buf
, "0x%03X\n", core
->id
.id
);
38 static ssize_t
rev_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
40 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
41 return sprintf(buf
, "0x%02X\n", core
->id
.rev
);
43 static ssize_t
class_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
45 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
46 return sprintf(buf
, "0x%X\n", core
->id
.class);
48 static struct device_attribute bcma_device_attrs
[] = {
56 static struct bus_type bcma_bus_type
= {
58 .match
= bcma_bus_match
,
59 .probe
= bcma_device_probe
,
60 .remove
= bcma_device_remove
,
61 .uevent
= bcma_device_uevent
,
62 .dev_attrs
= bcma_device_attrs
,
65 static u16
bcma_cc_core_id(struct bcma_bus
*bus
)
67 if (bus
->chipinfo
.id
== BCMA_CHIP_ID_BCM4706
)
68 return BCMA_CORE_4706_CHIPCOMMON
;
69 return BCMA_CORE_CHIPCOMMON
;
72 struct bcma_device
*bcma_find_core(struct bcma_bus
*bus
, u16 coreid
)
74 struct bcma_device
*core
;
76 list_for_each_entry(core
, &bus
->cores
, list
) {
77 if (core
->id
.id
== coreid
)
82 EXPORT_SYMBOL_GPL(bcma_find_core
);
84 static struct bcma_device
*bcma_find_core_unit(struct bcma_bus
*bus
, u16 coreid
,
87 struct bcma_device
*core
;
89 list_for_each_entry(core
, &bus
->cores
, list
) {
90 if (core
->id
.id
== coreid
&& core
->core_unit
== unit
)
96 static void bcma_release_core_dev(struct device
*dev
)
98 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
100 iounmap(core
->io_addr
);
102 iounmap(core
->io_wrap
);
106 static int bcma_register_cores(struct bcma_bus
*bus
)
108 struct bcma_device
*core
;
111 list_for_each_entry(core
, &bus
->cores
, list
) {
112 /* We support that cores ourself */
113 switch (core
->id
.id
) {
114 case BCMA_CORE_4706_CHIPCOMMON
:
115 case BCMA_CORE_CHIPCOMMON
:
118 case BCMA_CORE_MIPS_74K
:
119 case BCMA_CORE_4706_MAC_GBIT_COMMON
:
123 core
->dev
.release
= bcma_release_core_dev
;
124 core
->dev
.bus
= &bcma_bus_type
;
125 dev_set_name(&core
->dev
, "bcma%d:%d", bus
->num
, dev_id
);
127 switch (bus
->hosttype
) {
128 case BCMA_HOSTTYPE_PCI
:
129 core
->dev
.parent
= &bus
->host_pci
->dev
;
130 core
->dma_dev
= &bus
->host_pci
->dev
;
131 core
->irq
= bus
->host_pci
->irq
;
133 case BCMA_HOSTTYPE_SOC
:
134 core
->dev
.dma_mask
= &core
->dev
.coherent_dma_mask
;
135 core
->dma_dev
= &core
->dev
;
137 case BCMA_HOSTTYPE_SDIO
:
141 err
= device_register(&core
->dev
);
144 "Could not register dev for core 0x%03X\n",
148 core
->dev_registered
= true;
152 #ifdef CONFIG_BCMA_SFLASH
153 if (bus
->drv_cc
.sflash
.present
) {
154 err
= platform_device_register(&bcma_sflash_dev
);
156 bcma_err(bus
, "Error registering serial flash\n");
160 #ifdef CONFIG_BCMA_NFLASH
161 if (bus
->drv_cc
.nflash
.present
) {
162 err
= platform_device_register(&bcma_nflash_dev
);
164 bcma_err(bus
, "Error registering NAND flash\n");
167 err
= bcma_gpio_init(&bus
->drv_cc
);
168 if (err
== -ENOTSUPP
)
169 bcma_debug(bus
, "GPIO driver not activated\n");
171 bcma_err(bus
, "Error registering GPIO driver: %i\n", err
);
173 if (bus
->hosttype
== BCMA_HOSTTYPE_SOC
) {
174 err
= bcma_chipco_watchdog_register(&bus
->drv_cc
);
176 bcma_err(bus
, "Error registering watchdog driver\n");
182 static void bcma_unregister_cores(struct bcma_bus
*bus
)
184 struct bcma_device
*core
, *tmp
;
186 list_for_each_entry_safe(core
, tmp
, &bus
->cores
, list
) {
187 list_del(&core
->list
);
188 if (core
->dev_registered
)
189 device_unregister(&core
->dev
);
191 if (bus
->hosttype
== BCMA_HOSTTYPE_SOC
)
192 platform_device_unregister(bus
->drv_cc
.watchdog
);
195 int __devinit
bcma_bus_register(struct bcma_bus
*bus
)
198 struct bcma_device
*core
;
200 mutex_lock(&bcma_buses_mutex
);
201 bus
->num
= bcma_bus_next_num
++;
202 mutex_unlock(&bcma_buses_mutex
);
204 /* Scan for devices (cores) */
205 err
= bcma_bus_scan(bus
);
207 bcma_err(bus
, "Failed to scan: %d\n", err
);
211 /* Early init CC core */
212 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
214 bus
->drv_cc
.core
= core
;
215 bcma_core_chipcommon_early_init(&bus
->drv_cc
);
218 /* Try to get SPROM */
219 err
= bcma_sprom_get(bus
);
220 if (err
== -ENOENT
) {
221 bcma_err(bus
, "No SPROM available\n");
223 bcma_err(bus
, "Failed to get SPROM: %d\n", err
);
226 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
228 bus
->drv_cc
.core
= core
;
229 bcma_core_chipcommon_init(&bus
->drv_cc
);
233 core
= bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
235 bus
->drv_mips
.core
= core
;
236 bcma_core_mips_init(&bus
->drv_mips
);
240 core
= bcma_find_core_unit(bus
, BCMA_CORE_PCIE
, 0);
242 bus
->drv_pci
[0].core
= core
;
243 bcma_core_pci_init(&bus
->drv_pci
[0]);
247 core
= bcma_find_core_unit(bus
, BCMA_CORE_PCIE
, 1);
249 bus
->drv_pci
[1].core
= core
;
250 bcma_core_pci_init(&bus
->drv_pci
[1]);
253 /* Init GBIT MAC COMMON core */
254 core
= bcma_find_core(bus
, BCMA_CORE_4706_MAC_GBIT_COMMON
);
256 bus
->drv_gmac_cmn
.core
= core
;
257 bcma_core_gmac_cmn_init(&bus
->drv_gmac_cmn
);
260 /* Register found cores */
261 bcma_register_cores(bus
);
263 bcma_info(bus
, "Bus registered\n");
268 void bcma_bus_unregister(struct bcma_bus
*bus
)
270 struct bcma_device
*cores
[3];
272 cores
[0] = bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
273 cores
[1] = bcma_find_core(bus
, BCMA_CORE_PCIE
);
274 cores
[2] = bcma_find_core(bus
, BCMA_CORE_4706_MAC_GBIT_COMMON
);
276 bcma_unregister_cores(bus
);
283 int __init
bcma_bus_early_register(struct bcma_bus
*bus
,
284 struct bcma_device
*core_cc
,
285 struct bcma_device
*core_mips
)
288 struct bcma_device
*core
;
289 struct bcma_device_id match
;
293 match
.manuf
= BCMA_MANUF_BCM
;
294 match
.id
= bcma_cc_core_id(bus
);
295 match
.class = BCMA_CL_SIM
;
296 match
.rev
= BCMA_ANY_REV
;
298 /* Scan for chip common core */
299 err
= bcma_bus_scan_early(bus
, &match
, core_cc
);
301 bcma_err(bus
, "Failed to scan for common core: %d\n", err
);
305 match
.manuf
= BCMA_MANUF_MIPS
;
306 match
.id
= BCMA_CORE_MIPS_74K
;
307 match
.class = BCMA_CL_SIM
;
308 match
.rev
= BCMA_ANY_REV
;
310 /* Scan for mips core */
311 err
= bcma_bus_scan_early(bus
, &match
, core_mips
);
313 bcma_err(bus
, "Failed to scan for mips core: %d\n", err
);
317 /* Early init CC core */
318 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
320 bus
->drv_cc
.core
= core
;
321 bcma_core_chipcommon_early_init(&bus
->drv_cc
);
324 /* Early init MIPS core */
325 core
= bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
327 bus
->drv_mips
.core
= core
;
328 bcma_core_mips_early_init(&bus
->drv_mips
);
331 bcma_info(bus
, "Early bus registered\n");
337 int bcma_bus_suspend(struct bcma_bus
*bus
)
339 struct bcma_device
*core
;
341 list_for_each_entry(core
, &bus
->cores
, list
) {
342 struct device_driver
*drv
= core
->dev
.driver
;
344 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
352 int bcma_bus_resume(struct bcma_bus
*bus
)
354 struct bcma_device
*core
;
357 if (bus
->drv_cc
.core
) {
358 bus
->drv_cc
.setup_done
= false;
359 bcma_core_chipcommon_init(&bus
->drv_cc
);
362 list_for_each_entry(core
, &bus
->cores
, list
) {
363 struct device_driver
*drv
= core
->dev
.driver
;
365 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
375 int __bcma_driver_register(struct bcma_driver
*drv
, struct module
*owner
)
377 drv
->drv
.name
= drv
->name
;
378 drv
->drv
.bus
= &bcma_bus_type
;
379 drv
->drv
.owner
= owner
;
381 return driver_register(&drv
->drv
);
383 EXPORT_SYMBOL_GPL(__bcma_driver_register
);
385 void bcma_driver_unregister(struct bcma_driver
*drv
)
387 driver_unregister(&drv
->drv
);
389 EXPORT_SYMBOL_GPL(bcma_driver_unregister
);
391 static int bcma_bus_match(struct device
*dev
, struct device_driver
*drv
)
393 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
394 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
395 const struct bcma_device_id
*cid
= &core
->id
;
396 const struct bcma_device_id
*did
;
398 for (did
= adrv
->id_table
; did
->manuf
|| did
->id
|| did
->rev
; did
++) {
399 if ((did
->manuf
== cid
->manuf
|| did
->manuf
== BCMA_ANY_MANUF
) &&
400 (did
->id
== cid
->id
|| did
->id
== BCMA_ANY_ID
) &&
401 (did
->rev
== cid
->rev
|| did
->rev
== BCMA_ANY_REV
) &&
402 (did
->class == cid
->class || did
->class == BCMA_ANY_CLASS
))
408 static int bcma_device_probe(struct device
*dev
)
410 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
411 struct bcma_driver
*adrv
= container_of(dev
->driver
, struct bcma_driver
,
416 err
= adrv
->probe(core
);
421 static int bcma_device_remove(struct device
*dev
)
423 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
424 struct bcma_driver
*adrv
= container_of(dev
->driver
, struct bcma_driver
,
433 static int bcma_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
435 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
437 return add_uevent_var(env
,
438 "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
439 core
->id
.manuf
, core
->id
.id
,
440 core
->id
.rev
, core
->id
.class);
443 static int __init
bcma_modinit(void)
447 err
= bus_register(&bcma_bus_type
);
451 #ifdef CONFIG_BCMA_HOST_PCI
452 err
= bcma_host_pci_init();
454 pr_err("PCI host initialization failed\n");
461 fs_initcall(bcma_modinit
);
463 static void __exit
bcma_modexit(void)
465 #ifdef CONFIG_BCMA_HOST_PCI
466 bcma_host_pci_exit();
468 bus_unregister(&bcma_bus_type
);
470 module_exit(bcma_modexit
)