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 void bcma_release_core_dev(struct device
*dev
)
86 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
88 iounmap(core
->io_addr
);
90 iounmap(core
->io_wrap
);
94 static int bcma_register_cores(struct bcma_bus
*bus
)
96 struct bcma_device
*core
;
99 list_for_each_entry(core
, &bus
->cores
, list
) {
100 /* We support that cores ourself */
101 switch (core
->id
.id
) {
102 case BCMA_CORE_4706_CHIPCOMMON
:
103 case BCMA_CORE_CHIPCOMMON
:
106 case BCMA_CORE_MIPS_74K
:
107 case BCMA_CORE_4706_MAC_GBIT_COMMON
:
111 core
->dev
.release
= bcma_release_core_dev
;
112 core
->dev
.bus
= &bcma_bus_type
;
113 dev_set_name(&core
->dev
, "bcma%d:%d", bus
->num
, dev_id
);
115 switch (bus
->hosttype
) {
116 case BCMA_HOSTTYPE_PCI
:
117 core
->dev
.parent
= &bus
->host_pci
->dev
;
118 core
->dma_dev
= &bus
->host_pci
->dev
;
119 core
->irq
= bus
->host_pci
->irq
;
121 case BCMA_HOSTTYPE_SOC
:
122 core
->dev
.dma_mask
= &core
->dev
.coherent_dma_mask
;
123 core
->dma_dev
= &core
->dev
;
125 case BCMA_HOSTTYPE_SDIO
:
129 err
= device_register(&core
->dev
);
132 "Could not register dev for core 0x%03X\n",
136 core
->dev_registered
= true;
140 #ifdef CONFIG_BCMA_SFLASH
141 if (bus
->drv_cc
.sflash
.present
) {
142 err
= platform_device_register(&bcma_sflash_dev
);
144 bcma_err(bus
, "Error registering serial flash\n");
148 #ifdef CONFIG_BCMA_NFLASH
149 if (bus
->drv_cc
.nflash
.present
) {
150 err
= platform_device_register(&bcma_nflash_dev
);
152 bcma_err(bus
, "Error registering NAND flash\n");
159 static void bcma_unregister_cores(struct bcma_bus
*bus
)
161 struct bcma_device
*core
;
163 list_for_each_entry(core
, &bus
->cores
, list
) {
164 if (core
->dev_registered
)
165 device_unregister(&core
->dev
);
169 int __devinit
bcma_bus_register(struct bcma_bus
*bus
)
172 struct bcma_device
*core
;
174 mutex_lock(&bcma_buses_mutex
);
175 bus
->num
= bcma_bus_next_num
++;
176 mutex_unlock(&bcma_buses_mutex
);
178 /* Scan for devices (cores) */
179 err
= bcma_bus_scan(bus
);
181 bcma_err(bus
, "Failed to scan: %d\n", err
);
186 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
188 bus
->drv_cc
.core
= core
;
189 bcma_core_chipcommon_init(&bus
->drv_cc
);
193 core
= bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
195 bus
->drv_mips
.core
= core
;
196 bcma_core_mips_init(&bus
->drv_mips
);
200 core
= bcma_find_core(bus
, BCMA_CORE_PCIE
);
202 bus
->drv_pci
.core
= core
;
203 bcma_core_pci_init(&bus
->drv_pci
);
206 /* Init GBIT MAC COMMON core */
207 core
= bcma_find_core(bus
, BCMA_CORE_4706_MAC_GBIT_COMMON
);
209 bus
->drv_gmac_cmn
.core
= core
;
210 bcma_core_gmac_cmn_init(&bus
->drv_gmac_cmn
);
213 /* Try to get SPROM */
214 err
= bcma_sprom_get(bus
);
215 if (err
== -ENOENT
) {
216 bcma_err(bus
, "No SPROM available\n");
218 bcma_err(bus
, "Failed to get SPROM: %d\n", err
);
220 /* Register found cores */
221 bcma_register_cores(bus
);
223 bcma_info(bus
, "Bus registered\n");
228 void bcma_bus_unregister(struct bcma_bus
*bus
)
230 struct bcma_device
*cores
[3];
232 cores
[0] = bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
233 cores
[1] = bcma_find_core(bus
, BCMA_CORE_PCIE
);
234 cores
[2] = bcma_find_core(bus
, BCMA_CORE_4706_MAC_GBIT_COMMON
);
236 bcma_unregister_cores(bus
);
243 int __init
bcma_bus_early_register(struct bcma_bus
*bus
,
244 struct bcma_device
*core_cc
,
245 struct bcma_device
*core_mips
)
248 struct bcma_device
*core
;
249 struct bcma_device_id match
;
253 match
.manuf
= BCMA_MANUF_BCM
;
254 match
.id
= bcma_cc_core_id(bus
);
255 match
.class = BCMA_CL_SIM
;
256 match
.rev
= BCMA_ANY_REV
;
258 /* Scan for chip common core */
259 err
= bcma_bus_scan_early(bus
, &match
, core_cc
);
261 bcma_err(bus
, "Failed to scan for common core: %d\n", err
);
265 match
.manuf
= BCMA_MANUF_MIPS
;
266 match
.id
= BCMA_CORE_MIPS_74K
;
267 match
.class = BCMA_CL_SIM
;
268 match
.rev
= BCMA_ANY_REV
;
270 /* Scan for mips core */
271 err
= bcma_bus_scan_early(bus
, &match
, core_mips
);
273 bcma_err(bus
, "Failed to scan for mips core: %d\n", err
);
278 core
= bcma_find_core(bus
, bcma_cc_core_id(bus
));
280 bus
->drv_cc
.core
= core
;
281 bcma_core_chipcommon_init(&bus
->drv_cc
);
285 core
= bcma_find_core(bus
, BCMA_CORE_MIPS_74K
);
287 bus
->drv_mips
.core
= core
;
288 bcma_core_mips_init(&bus
->drv_mips
);
291 bcma_info(bus
, "Early bus registered\n");
297 int bcma_bus_suspend(struct bcma_bus
*bus
)
299 struct bcma_device
*core
;
301 list_for_each_entry(core
, &bus
->cores
, list
) {
302 struct device_driver
*drv
= core
->dev
.driver
;
304 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
312 int bcma_bus_resume(struct bcma_bus
*bus
)
314 struct bcma_device
*core
;
317 if (bus
->drv_cc
.core
) {
318 bus
->drv_cc
.setup_done
= false;
319 bcma_core_chipcommon_init(&bus
->drv_cc
);
322 list_for_each_entry(core
, &bus
->cores
, list
) {
323 struct device_driver
*drv
= core
->dev
.driver
;
325 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
335 int __bcma_driver_register(struct bcma_driver
*drv
, struct module
*owner
)
337 drv
->drv
.name
= drv
->name
;
338 drv
->drv
.bus
= &bcma_bus_type
;
339 drv
->drv
.owner
= owner
;
341 return driver_register(&drv
->drv
);
343 EXPORT_SYMBOL_GPL(__bcma_driver_register
);
345 void bcma_driver_unregister(struct bcma_driver
*drv
)
347 driver_unregister(&drv
->drv
);
349 EXPORT_SYMBOL_GPL(bcma_driver_unregister
);
351 static int bcma_bus_match(struct device
*dev
, struct device_driver
*drv
)
353 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
354 struct bcma_driver
*adrv
= container_of(drv
, struct bcma_driver
, drv
);
355 const struct bcma_device_id
*cid
= &core
->id
;
356 const struct bcma_device_id
*did
;
358 for (did
= adrv
->id_table
; did
->manuf
|| did
->id
|| did
->rev
; did
++) {
359 if ((did
->manuf
== cid
->manuf
|| did
->manuf
== BCMA_ANY_MANUF
) &&
360 (did
->id
== cid
->id
|| did
->id
== BCMA_ANY_ID
) &&
361 (did
->rev
== cid
->rev
|| did
->rev
== BCMA_ANY_REV
) &&
362 (did
->class == cid
->class || did
->class == BCMA_ANY_CLASS
))
368 static int bcma_device_probe(struct device
*dev
)
370 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
371 struct bcma_driver
*adrv
= container_of(dev
->driver
, struct bcma_driver
,
376 err
= adrv
->probe(core
);
381 static int bcma_device_remove(struct device
*dev
)
383 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
384 struct bcma_driver
*adrv
= container_of(dev
->driver
, struct bcma_driver
,
393 static int bcma_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
395 struct bcma_device
*core
= container_of(dev
, struct bcma_device
, dev
);
397 return add_uevent_var(env
,
398 "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
399 core
->id
.manuf
, core
->id
.id
,
400 core
->id
.rev
, core
->id
.class);
403 static int __init
bcma_modinit(void)
407 err
= bus_register(&bcma_bus_type
);
411 #ifdef CONFIG_BCMA_HOST_PCI
412 err
= bcma_host_pci_init();
414 pr_err("PCI host initialization failed\n");
421 fs_initcall(bcma_modinit
);
423 static void __exit
bcma_modexit(void)
425 #ifdef CONFIG_BCMA_HOST_PCI
426 bcma_host_pci_exit();
428 bus_unregister(&bcma_bus_type
);
430 module_exit(bcma_modexit
)