Branch data Line data Source code
1 : : /*
2 : : * Broadcom specific AMBA
3 : : * Bus subsystem
4 : : *
5 : : * Licensed under the GNU/GPL. See COPYING for details.
6 : : */
7 : :
8 : : #include "bcma_private.h"
9 : : #include <linux/module.h>
10 : : #include <linux/mmc/sdio_func.h>
11 : : #include <linux/platform_device.h>
12 : : #include <linux/pci.h>
13 : : #include <linux/bcma/bcma.h>
14 : : #include <linux/slab.h>
15 : : #include <linux/of_address.h>
16 : : #include <linux/of_irq.h>
17 : : #include <linux/of_platform.h>
18 : :
19 : : MODULE_DESCRIPTION("Broadcom's specific AMBA driver");
20 : : MODULE_LICENSE("GPL");
21 : :
22 : : /* contains the number the next bus should get. */
23 : : static unsigned int bcma_bus_next_num = 0;
24 : :
25 : : /* bcma_buses_mutex locks the bcma_bus_next_num */
26 : : static DEFINE_MUTEX(bcma_buses_mutex);
27 : :
28 : : static int bcma_bus_match(struct device *dev, struct device_driver *drv);
29 : : static int bcma_device_probe(struct device *dev);
30 : : static int bcma_device_remove(struct device *dev);
31 : : static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env);
32 : :
33 : 0 : static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
34 : : {
35 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
36 : 0 : return sprintf(buf, "0x%03X\n", core->id.manuf);
37 : : }
38 : : static DEVICE_ATTR_RO(manuf);
39 : :
40 : 0 : static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf)
41 : : {
42 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
43 : 0 : return sprintf(buf, "0x%03X\n", core->id.id);
44 : : }
45 : : static DEVICE_ATTR_RO(id);
46 : :
47 : 0 : static ssize_t rev_show(struct device *dev, struct device_attribute *attr, char *buf)
48 : : {
49 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
50 : 0 : return sprintf(buf, "0x%02X\n", core->id.rev);
51 : : }
52 : : static DEVICE_ATTR_RO(rev);
53 : :
54 : 0 : static ssize_t class_show(struct device *dev, struct device_attribute *attr, char *buf)
55 : : {
56 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
57 : 0 : return sprintf(buf, "0x%X\n", core->id.class);
58 : : }
59 : : static DEVICE_ATTR_RO(class);
60 : :
61 : : static struct attribute *bcma_device_attrs[] = {
62 : : &dev_attr_manuf.attr,
63 : : &dev_attr_id.attr,
64 : : &dev_attr_rev.attr,
65 : : &dev_attr_class.attr,
66 : : NULL,
67 : : };
68 : : ATTRIBUTE_GROUPS(bcma_device);
69 : :
70 : : static struct bus_type bcma_bus_type = {
71 : : .name = "bcma",
72 : : .match = bcma_bus_match,
73 : : .probe = bcma_device_probe,
74 : : .remove = bcma_device_remove,
75 : : .uevent = bcma_device_uevent,
76 : : .dev_groups = bcma_device_groups,
77 : : };
78 : :
79 : 0 : static u16 bcma_cc_core_id(struct bcma_bus *bus)
80 : : {
81 : 0 : if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706)
82 : 0 : return BCMA_CORE_4706_CHIPCOMMON;
83 : : return BCMA_CORE_CHIPCOMMON;
84 : : }
85 : :
86 : 0 : struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid,
87 : : u8 unit)
88 : : {
89 : 0 : struct bcma_device *core;
90 : :
91 [ # # # # : 0 : list_for_each_entry(core, &bus->cores, list) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
92 [ # # # # : 0 : if (core->id.id == coreid && core->core_unit == unit)
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
93 : 0 : return core;
94 : : }
95 : : return NULL;
96 : : }
97 : : EXPORT_SYMBOL_GPL(bcma_find_core_unit);
98 : :
99 : 0 : bool bcma_wait_value(struct bcma_device *core, u16 reg, u32 mask, u32 value,
100 : : int timeout)
101 : : {
102 : 0 : unsigned long deadline = jiffies + timeout;
103 : 0 : u32 val;
104 : :
105 : 0 : do {
106 : 0 : val = bcma_read32(core, reg);
107 [ # # ]: 0 : if ((val & mask) == value)
108 : : return true;
109 : 0 : cpu_relax();
110 : 0 : udelay(10);
111 [ # # ]: 0 : } while (!time_after_eq(jiffies, deadline));
112 : :
113 : 0 : bcma_warn(core->bus, "Timeout waiting for register 0x%04X!\n", reg);
114 : :
115 : 0 : return false;
116 : : }
117 : :
118 : 0 : static void bcma_release_core_dev(struct device *dev)
119 : : {
120 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
121 [ # # ]: 0 : if (core->io_addr)
122 : 0 : iounmap(core->io_addr);
123 [ # # ]: 0 : if (core->io_wrap)
124 : 0 : iounmap(core->io_wrap);
125 : 0 : kfree(core);
126 : 0 : }
127 : :
128 : 0 : static bool bcma_is_core_needed_early(u16 core_id)
129 : : {
130 : 0 : switch (core_id) {
131 : : case BCMA_CORE_NS_NAND:
132 : : case BCMA_CORE_NS_QSPI:
133 : : return true;
134 : : }
135 : :
136 : 0 : return false;
137 : : }
138 : :
139 : 0 : static struct device_node *bcma_of_find_child_device(struct device *parent,
140 : : struct bcma_device *core)
141 : : {
142 : 0 : struct device_node *node;
143 : 0 : u64 size;
144 : 0 : const __be32 *reg;
145 : :
146 : 0 : if (!parent->of_node)
147 : : return NULL;
148 : :
149 : : for_each_child_of_node(parent->of_node, node) {
150 : : reg = of_get_address(node, 0, &size, NULL);
151 : : if (!reg)
152 : : continue;
153 : : if (of_translate_address(node, reg) == core->addr)
154 : : return node;
155 : : }
156 : : return NULL;
157 : : }
158 : :
159 : : static int bcma_of_irq_parse(struct device *parent,
160 : : struct bcma_device *core,
161 : : struct of_phandle_args *out_irq, int num)
162 : : {
163 : : __be32 laddr[1];
164 : : int rc;
165 : :
166 : : if (core->dev.of_node) {
167 : : rc = of_irq_parse_one(core->dev.of_node, num, out_irq);
168 : : if (!rc)
169 : : return rc;
170 : : }
171 : :
172 : : out_irq->np = parent->of_node;
173 : : out_irq->args_count = 1;
174 : : out_irq->args[0] = num;
175 : :
176 : : laddr[0] = cpu_to_be32(core->addr);
177 : : return of_irq_parse_raw(laddr, out_irq);
178 : : }
179 : :
180 : 0 : static unsigned int bcma_of_get_irq(struct device *parent,
181 : : struct bcma_device *core, int num)
182 : : {
183 : 0 : struct of_phandle_args out_irq;
184 : 0 : int ret;
185 : :
186 : 0 : if (!IS_ENABLED(CONFIG_OF_IRQ) || !parent->of_node)
187 : 0 : return 0;
188 : :
189 : : ret = bcma_of_irq_parse(parent, core, &out_irq, num);
190 : : if (ret) {
191 : : bcma_debug(core->bus, "bcma_of_get_irq() failed with rc=%d\n",
192 : : ret);
193 : : return 0;
194 : : }
195 : :
196 : : return irq_create_of_mapping(&out_irq);
197 : : }
198 : :
199 : 0 : static void bcma_of_fill_device(struct device *parent,
200 : : struct bcma_device *core)
201 : : {
202 : 0 : struct device_node *node;
203 : :
204 : 0 : node = bcma_of_find_child_device(parent, core);
205 : 0 : if (node)
206 : : core->dev.of_node = node;
207 : :
208 : 0 : core->irq = bcma_of_get_irq(parent, core, 0);
209 : :
210 : 0 : of_dma_configure(&core->dev, node, false);
211 : 0 : }
212 : :
213 : 0 : unsigned int bcma_core_irq(struct bcma_device *core, int num)
214 : : {
215 : 0 : struct bcma_bus *bus = core->bus;
216 : 0 : unsigned int mips_irq;
217 : :
218 [ # # # ]: 0 : switch (bus->hosttype) {
219 : 0 : case BCMA_HOSTTYPE_PCI:
220 : 0 : return bus->host_pci->irq;
221 : 0 : case BCMA_HOSTTYPE_SOC:
222 [ # # # # ]: 0 : if (bus->drv_mips.core && num == 0) {
223 : : mips_irq = bcma_core_mips_irq(core);
224 : : return mips_irq <= 4 ? mips_irq + 2 : 0;
225 : : }
226 : 0 : if (bus->dev)
227 : : return bcma_of_get_irq(bus->dev, core, num);
228 : : return 0;
229 : : case BCMA_HOSTTYPE_SDIO:
230 : : return 0;
231 : : }
232 : :
233 : : return 0;
234 : : }
235 : : EXPORT_SYMBOL(bcma_core_irq);
236 : :
237 : 0 : void bcma_prepare_core(struct bcma_bus *bus, struct bcma_device *core)
238 : : {
239 : 0 : core->dev.release = bcma_release_core_dev;
240 : 0 : core->dev.bus = &bcma_bus_type;
241 : 0 : dev_set_name(&core->dev, "bcma%d:%d", bus->num, core->core_index);
242 : 0 : core->dev.parent = bus->dev;
243 [ # # ]: 0 : if (bus->dev)
244 : 0 : bcma_of_fill_device(bus->dev, core);
245 : :
246 [ # # # ]: 0 : switch (bus->hosttype) {
247 : 0 : case BCMA_HOSTTYPE_PCI:
248 : 0 : core->dma_dev = bus->dev;
249 : 0 : core->irq = bus->host_pci->irq;
250 : 0 : break;
251 : : case BCMA_HOSTTYPE_SOC:
252 : 0 : if (IS_ENABLED(CONFIG_OF) && bus->dev) {
253 : : core->dma_dev = bus->dev;
254 : : } else {
255 : 0 : core->dev.dma_mask = &core->dev.coherent_dma_mask;
256 : 0 : core->dma_dev = &core->dev;
257 : : }
258 : 0 : break;
259 : : case BCMA_HOSTTYPE_SDIO:
260 : : break;
261 : : }
262 : 0 : }
263 : :
264 : 0 : void bcma_init_bus(struct bcma_bus *bus)
265 : : {
266 : 0 : mutex_lock(&bcma_buses_mutex);
267 : 0 : bus->num = bcma_bus_next_num++;
268 : 0 : mutex_unlock(&bcma_buses_mutex);
269 : :
270 : 0 : INIT_LIST_HEAD(&bus->cores);
271 : 0 : bus->nr_cores = 0;
272 : :
273 : 0 : bcma_detect_chip(bus);
274 : 0 : }
275 : :
276 : : static void bcma_register_core(struct bcma_bus *bus, struct bcma_device *core)
277 : : {
278 : : int err;
279 : :
280 : : err = device_register(&core->dev);
281 : : if (err) {
282 : : bcma_err(bus, "Could not register dev for core 0x%03X\n",
283 : : core->id.id);
284 : : put_device(&core->dev);
285 : : return;
286 : : }
287 : : core->dev_registered = true;
288 : : }
289 : :
290 : 0 : static int bcma_register_devices(struct bcma_bus *bus)
291 : : {
292 : 0 : struct bcma_device *core;
293 : 0 : int err;
294 : :
295 [ # # ]: 0 : list_for_each_entry(core, &bus->cores, list) {
296 : : /* We support that cores ourself */
297 [ # # ]: 0 : switch (core->id.id) {
298 : 0 : case BCMA_CORE_4706_CHIPCOMMON:
299 : : case BCMA_CORE_CHIPCOMMON:
300 : : case BCMA_CORE_NS_CHIPCOMMON_B:
301 : : case BCMA_CORE_PCI:
302 : : case BCMA_CORE_PCIE:
303 : : case BCMA_CORE_PCIE2:
304 : : case BCMA_CORE_MIPS_74K:
305 : : case BCMA_CORE_4706_MAC_GBIT_COMMON:
306 : 0 : continue;
307 : : }
308 : :
309 : : /* Early cores were already registered */
310 [ # # ]: 0 : if (bcma_is_core_needed_early(core->id.id))
311 : 0 : continue;
312 : :
313 : : /* Only first GMAC core on BCM4706 is connected and working */
314 [ # # ]: 0 : if (core->id.id == BCMA_CORE_4706_MAC_GBIT &&
315 [ # # ]: 0 : core->core_unit > 0)
316 : 0 : continue;
317 : :
318 : 0 : bcma_register_core(bus, core);
319 : : }
320 : :
321 : : #ifdef CONFIG_BCMA_PFLASH
322 : : if (bus->drv_cc.pflash.present) {
323 : : err = platform_device_register(&bcma_pflash_dev);
324 : : if (err)
325 : : bcma_err(bus, "Error registering parallel flash\n");
326 : : }
327 : : #endif
328 : :
329 : : #ifdef CONFIG_BCMA_SFLASH
330 : : if (bus->drv_cc.sflash.present) {
331 : : err = platform_device_register(&bcma_sflash_dev);
332 : : if (err)
333 : : bcma_err(bus, "Error registering serial flash\n");
334 : : }
335 : : #endif
336 : :
337 : : #ifdef CONFIG_BCMA_NFLASH
338 : : if (bus->drv_cc.nflash.present) {
339 : : err = platform_device_register(&bcma_nflash_dev);
340 : : if (err)
341 : : bcma_err(bus, "Error registering NAND flash\n");
342 : : }
343 : : #endif
344 [ # # ]: 0 : err = bcma_gpio_init(&bus->drv_cc);
345 : 0 : if (err == -ENOTSUPP)
346 : : bcma_debug(bus, "GPIO driver not activated\n");
347 : : else if (err)
348 : : bcma_err(bus, "Error registering GPIO driver: %i\n", err);
349 : :
350 [ # # ]: 0 : if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
351 : 0 : err = bcma_chipco_watchdog_register(&bus->drv_cc);
352 [ # # ]: 0 : if (err)
353 : 0 : bcma_err(bus, "Error registering watchdog driver\n");
354 : : }
355 : :
356 : 0 : return 0;
357 : : }
358 : :
359 : 0 : void bcma_unregister_cores(struct bcma_bus *bus)
360 : : {
361 : 0 : struct bcma_device *core, *tmp;
362 : :
363 [ # # ]: 0 : list_for_each_entry_safe(core, tmp, &bus->cores, list) {
364 [ # # ]: 0 : if (!core->dev_registered)
365 : 0 : continue;
366 : 0 : list_del(&core->list);
367 : 0 : device_unregister(&core->dev);
368 : : }
369 [ # # ]: 0 : if (bus->hosttype == BCMA_HOSTTYPE_SOC)
370 : 0 : platform_device_unregister(bus->drv_cc.watchdog);
371 : :
372 : : /* Now noone uses internally-handled cores, we can free them */
373 [ # # ]: 0 : list_for_each_entry_safe(core, tmp, &bus->cores, list) {
374 : 0 : list_del(&core->list);
375 : 0 : kfree(core);
376 : : }
377 : 0 : }
378 : :
379 : 0 : int bcma_bus_register(struct bcma_bus *bus)
380 : : {
381 : 0 : int err;
382 : 0 : struct bcma_device *core;
383 : :
384 : : /* Scan for devices (cores) */
385 : 0 : err = bcma_bus_scan(bus);
386 [ # # ]: 0 : if (err) {
387 : 0 : bcma_err(bus, "Failed to scan: %d\n", err);
388 : 0 : return err;
389 : : }
390 : :
391 : : /* Early init CC core */
392 [ # # ]: 0 : core = bcma_find_core(bus, bcma_cc_core_id(bus));
393 [ # # ]: 0 : if (core) {
394 : 0 : bus->drv_cc.core = core;
395 : 0 : bcma_core_chipcommon_early_init(&bus->drv_cc);
396 : : }
397 : :
398 : : /* Early init PCIE core */
399 : 0 : core = bcma_find_core(bus, BCMA_CORE_PCIE);
400 [ # # ]: 0 : if (core) {
401 : 0 : bus->drv_pci[0].core = core;
402 : 0 : bcma_core_pci_early_init(&bus->drv_pci[0]);
403 : : }
404 : :
405 : 0 : if (bus->dev)
406 : : of_platform_default_populate(bus->dev->of_node, NULL, bus->dev);
407 : :
408 : : /* Cores providing flash access go before SPROM init */
409 [ # # ]: 0 : list_for_each_entry(core, &bus->cores, list) {
410 [ # # ]: 0 : if (bcma_is_core_needed_early(core->id.id))
411 : 0 : bcma_register_core(bus, core);
412 : : }
413 : :
414 : : /* Try to get SPROM */
415 : 0 : err = bcma_sprom_get(bus);
416 [ # # ]: 0 : if (err == -ENOENT) {
417 : 0 : bcma_err(bus, "No SPROM available\n");
418 [ # # ]: 0 : } else if (err)
419 : 0 : bcma_err(bus, "Failed to get SPROM: %d\n", err);
420 : :
421 : : /* Init CC core */
422 [ # # ]: 0 : core = bcma_find_core(bus, bcma_cc_core_id(bus));
423 [ # # ]: 0 : if (core) {
424 : 0 : bus->drv_cc.core = core;
425 : 0 : bcma_core_chipcommon_init(&bus->drv_cc);
426 : : }
427 : :
428 : : /* Init CC core */
429 : 0 : core = bcma_find_core(bus, BCMA_CORE_NS_CHIPCOMMON_B);
430 [ # # ]: 0 : if (core) {
431 : 0 : bus->drv_cc_b.core = core;
432 : 0 : bcma_core_chipcommon_b_init(&bus->drv_cc_b);
433 : : }
434 : :
435 : : /* Init MIPS core */
436 : 0 : core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
437 [ # # ]: 0 : if (core) {
438 : 0 : bus->drv_mips.core = core;
439 : 0 : bcma_core_mips_init(&bus->drv_mips);
440 : : }
441 : :
442 : : /* Init PCIE core */
443 : 0 : core = bcma_find_core_unit(bus, BCMA_CORE_PCIE, 0);
444 [ # # ]: 0 : if (core) {
445 : 0 : bus->drv_pci[0].core = core;
446 : 0 : bcma_core_pci_init(&bus->drv_pci[0]);
447 : : }
448 : :
449 : : /* Init PCIE core */
450 : 0 : core = bcma_find_core_unit(bus, BCMA_CORE_PCIE, 1);
451 [ # # ]: 0 : if (core) {
452 : 0 : bus->drv_pci[1].core = core;
453 : 0 : bcma_core_pci_init(&bus->drv_pci[1]);
454 : : }
455 : :
456 : : /* Init PCIe Gen 2 core */
457 : 0 : core = bcma_find_core_unit(bus, BCMA_CORE_PCIE2, 0);
458 [ # # ]: 0 : if (core) {
459 : 0 : bus->drv_pcie2.core = core;
460 : 0 : bcma_core_pcie2_init(&bus->drv_pcie2);
461 : : }
462 : :
463 : : /* Init GBIT MAC COMMON core */
464 : 0 : core = bcma_find_core(bus, BCMA_CORE_4706_MAC_GBIT_COMMON);
465 [ # # ]: 0 : if (core) {
466 : 0 : bus->drv_gmac_cmn.core = core;
467 : 0 : bcma_core_gmac_cmn_init(&bus->drv_gmac_cmn);
468 : : }
469 : :
470 : : /* Register found cores */
471 : 0 : bcma_register_devices(bus);
472 : :
473 : 0 : bcma_info(bus, "Bus registered\n");
474 : :
475 : 0 : return 0;
476 : : }
477 : :
478 : 0 : void bcma_bus_unregister(struct bcma_bus *bus)
479 : : {
480 : 0 : int err;
481 : :
482 : 0 : err = bcma_gpio_unregister(&bus->drv_cc);
483 : 0 : if (err == -EBUSY)
484 : : bcma_err(bus, "Some GPIOs are still in use.\n");
485 : 0 : else if (err)
486 : : bcma_err(bus, "Can not unregister GPIO driver: %i\n", err);
487 : :
488 : 0 : bcma_core_chipcommon_b_free(&bus->drv_cc_b);
489 : :
490 : 0 : bcma_unregister_cores(bus);
491 : 0 : }
492 : :
493 : : /*
494 : : * This is a special version of bus registration function designed for SoCs.
495 : : * It scans bus and performs basic initialization of main cores only.
496 : : * Please note it requires memory allocation, however it won't try to sleep.
497 : : */
498 : 0 : int __init bcma_bus_early_register(struct bcma_bus *bus)
499 : : {
500 : 0 : int err;
501 : 0 : struct bcma_device *core;
502 : :
503 : : /* Scan for devices (cores) */
504 : 0 : err = bcma_bus_scan(bus);
505 [ # # ]: 0 : if (err) {
506 : 0 : bcma_err(bus, "Failed to scan bus: %d\n", err);
507 : 0 : return -1;
508 : : }
509 : :
510 : : /* Early init CC core */
511 [ # # ]: 0 : core = bcma_find_core(bus, bcma_cc_core_id(bus));
512 [ # # ]: 0 : if (core) {
513 : 0 : bus->drv_cc.core = core;
514 : 0 : bcma_core_chipcommon_early_init(&bus->drv_cc);
515 : : }
516 : :
517 : : /* Early init MIPS core */
518 : 0 : core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
519 [ # # ]: 0 : if (core) {
520 : 0 : bus->drv_mips.core = core;
521 : 0 : bcma_core_mips_early_init(&bus->drv_mips);
522 : : }
523 : :
524 : 0 : bcma_info(bus, "Early bus registered\n");
525 : :
526 : 0 : return 0;
527 : : }
528 : :
529 : : #ifdef CONFIG_PM
530 : 0 : int bcma_bus_suspend(struct bcma_bus *bus)
531 : : {
532 : 0 : struct bcma_device *core;
533 : :
534 [ # # ]: 0 : list_for_each_entry(core, &bus->cores, list) {
535 : 0 : struct device_driver *drv = core->dev.driver;
536 [ # # ]: 0 : if (drv) {
537 : 0 : struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
538 [ # # ]: 0 : if (adrv->suspend)
539 : 0 : adrv->suspend(core);
540 : : }
541 : : }
542 : 0 : return 0;
543 : : }
544 : :
545 : 0 : int bcma_bus_resume(struct bcma_bus *bus)
546 : : {
547 : 0 : struct bcma_device *core;
548 : :
549 : : /* Init CC core */
550 [ # # ]: 0 : if (bus->drv_cc.core) {
551 : 0 : bus->drv_cc.setup_done = false;
552 : 0 : bcma_core_chipcommon_init(&bus->drv_cc);
553 : : }
554 : :
555 [ # # ]: 0 : list_for_each_entry(core, &bus->cores, list) {
556 : 0 : struct device_driver *drv = core->dev.driver;
557 [ # # ]: 0 : if (drv) {
558 : 0 : struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
559 [ # # ]: 0 : if (adrv->resume)
560 : 0 : adrv->resume(core);
561 : : }
562 : : }
563 : :
564 : 0 : return 0;
565 : : }
566 : : #endif
567 : :
568 : 0 : int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
569 : : {
570 : 0 : drv->drv.name = drv->name;
571 : 0 : drv->drv.bus = &bcma_bus_type;
572 : 0 : drv->drv.owner = owner;
573 : :
574 : 0 : return driver_register(&drv->drv);
575 : : }
576 : : EXPORT_SYMBOL_GPL(__bcma_driver_register);
577 : :
578 : 0 : void bcma_driver_unregister(struct bcma_driver *drv)
579 : : {
580 : 0 : driver_unregister(&drv->drv);
581 : 0 : }
582 : : EXPORT_SYMBOL_GPL(bcma_driver_unregister);
583 : :
584 : 0 : static int bcma_bus_match(struct device *dev, struct device_driver *drv)
585 : : {
586 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
587 : 0 : struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
588 : 0 : const struct bcma_device_id *cid = &core->id;
589 : 0 : const struct bcma_device_id *did;
590 : :
591 [ # # # # : 0 : for (did = adrv->id_table; did->manuf || did->id || did->rev; did++) {
# # ]
592 [ # # # # ]: 0 : if ((did->manuf == cid->manuf || did->manuf == BCMA_ANY_MANUF) &&
593 [ # # # # ]: 0 : (did->id == cid->id || did->id == BCMA_ANY_ID) &&
594 [ # # # # ]: 0 : (did->rev == cid->rev || did->rev == BCMA_ANY_REV) &&
595 [ # # # # ]: 0 : (did->class == cid->class || did->class == BCMA_ANY_CLASS))
596 : : return 1;
597 : : }
598 : : return 0;
599 : : }
600 : :
601 : 0 : static int bcma_device_probe(struct device *dev)
602 : : {
603 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
604 : 0 : struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
605 : : drv);
606 : 0 : int err = 0;
607 : :
608 : 0 : get_device(dev);
609 [ # # ]: 0 : if (adrv->probe)
610 : 0 : err = adrv->probe(core);
611 [ # # ]: 0 : if (err)
612 : 0 : put_device(dev);
613 : :
614 : 0 : return err;
615 : : }
616 : :
617 : 0 : static int bcma_device_remove(struct device *dev)
618 : : {
619 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
620 : 0 : struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
621 : : drv);
622 : :
623 [ # # ]: 0 : if (adrv->remove)
624 : 0 : adrv->remove(core);
625 : 0 : put_device(dev);
626 : :
627 : 0 : return 0;
628 : : }
629 : :
630 : 0 : static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
631 : : {
632 : 0 : struct bcma_device *core = container_of(dev, struct bcma_device, dev);
633 : :
634 : 0 : return add_uevent_var(env,
635 : : "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
636 : 0 : core->id.manuf, core->id.id,
637 : 0 : core->id.rev, core->id.class);
638 : : }
639 : :
640 : : static unsigned int bcma_bus_registered;
641 : :
642 : : /*
643 : : * If built-in, bus has to be registered early, before any driver calls
644 : : * bcma_driver_register.
645 : : * Otherwise registering driver would trigger BUG in driver_register.
646 : : */
647 : 60 : static int __init bcma_init_bus_register(void)
648 : : {
649 : 60 : int err;
650 : :
651 [ + + ]: 60 : if (bcma_bus_registered)
652 : : return 0;
653 : :
654 : 30 : err = bus_register(&bcma_bus_type);
655 [ + - ]: 30 : if (!err)
656 : 30 : bcma_bus_registered = 1;
657 : :
658 : : return err;
659 : : }
660 : : #ifndef MODULE
661 : : fs_initcall(bcma_init_bus_register);
662 : : #endif
663 : :
664 : : /* Main initialization has to be done with SPI/mtd/NAND/SPROM available */
665 : 30 : static int __init bcma_modinit(void)
666 : : {
667 : 30 : int err;
668 : :
669 : 30 : err = bcma_init_bus_register();
670 [ + - ]: 30 : if (err)
671 : : return err;
672 : :
673 : 30 : err = bcma_host_soc_register_driver();
674 : 30 : if (err) {
675 : : pr_err("SoC host initialization failed\n");
676 : : err = 0;
677 : : }
678 : : #ifdef CONFIG_BCMA_HOST_PCI
679 : 30 : err = bcma_host_pci_init();
680 [ - + ]: 30 : if (err) {
681 : 0 : pr_err("PCI host initialization failed\n");
682 : 0 : err = 0;
683 : : }
684 : : #endif
685 : :
686 : : return err;
687 : : }
688 : : module_init(bcma_modinit);
689 : :
690 : 0 : static void __exit bcma_modexit(void)
691 : : {
692 : : #ifdef CONFIG_BCMA_HOST_PCI
693 : 0 : bcma_host_pci_exit();
694 : : #endif
695 : 0 : bcma_host_soc_unregister_driver();
696 : 0 : bus_unregister(&bcma_bus_type);
697 : 0 : }
698 : : module_exit(bcma_modexit)
|
