xref: /openbmc/linux/drivers/bcma/main.c (revision 62e7ca52)
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/platform_device.h>
11 #include <linux/bcma/bcma.h>
12 #include <linux/slab.h>
13 
14 MODULE_DESCRIPTION("Broadcom's specific AMBA driver");
15 MODULE_LICENSE("GPL");
16 
17 /* contains the number the next bus should get. */
18 static unsigned int bcma_bus_next_num = 0;
19 
20 /* bcma_buses_mutex locks the bcma_bus_next_num */
21 static DEFINE_MUTEX(bcma_buses_mutex);
22 
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);
27 
28 static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
29 {
30 	struct bcma_device *core = container_of(dev, struct bcma_device, dev);
31 	return sprintf(buf, "0x%03X\n", core->id.manuf);
32 }
33 static DEVICE_ATTR_RO(manuf);
34 
35 static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf)
36 {
37 	struct bcma_device *core = container_of(dev, struct bcma_device, dev);
38 	return sprintf(buf, "0x%03X\n", core->id.id);
39 }
40 static DEVICE_ATTR_RO(id);
41 
42 static ssize_t rev_show(struct device *dev, struct device_attribute *attr, char *buf)
43 {
44 	struct bcma_device *core = container_of(dev, struct bcma_device, dev);
45 	return sprintf(buf, "0x%02X\n", core->id.rev);
46 }
47 static DEVICE_ATTR_RO(rev);
48 
49 static ssize_t class_show(struct device *dev, struct device_attribute *attr, char *buf)
50 {
51 	struct bcma_device *core = container_of(dev, struct bcma_device, dev);
52 	return sprintf(buf, "0x%X\n", core->id.class);
53 }
54 static DEVICE_ATTR_RO(class);
55 
56 static struct attribute *bcma_device_attrs[] = {
57 	&dev_attr_manuf.attr,
58 	&dev_attr_id.attr,
59 	&dev_attr_rev.attr,
60 	&dev_attr_class.attr,
61 	NULL,
62 };
63 ATTRIBUTE_GROUPS(bcma_device);
64 
65 static struct bus_type bcma_bus_type = {
66 	.name		= "bcma",
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,
72 };
73 
74 static u16 bcma_cc_core_id(struct bcma_bus *bus)
75 {
76 	if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706)
77 		return BCMA_CORE_4706_CHIPCOMMON;
78 	return BCMA_CORE_CHIPCOMMON;
79 }
80 
81 struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid,
82 					u8 unit)
83 {
84 	struct bcma_device *core;
85 
86 	list_for_each_entry(core, &bus->cores, list) {
87 		if (core->id.id == coreid && core->core_unit == unit)
88 			return core;
89 	}
90 	return NULL;
91 }
92 EXPORT_SYMBOL_GPL(bcma_find_core_unit);
93 
94 bool bcma_wait_value(struct bcma_device *core, u16 reg, u32 mask, u32 value,
95 		     int timeout)
96 {
97 	unsigned long deadline = jiffies + timeout;
98 	u32 val;
99 
100 	do {
101 		val = bcma_read32(core, reg);
102 		if ((val & mask) == value)
103 			return true;
104 		cpu_relax();
105 		udelay(10);
106 	} while (!time_after_eq(jiffies, deadline));
107 
108 	bcma_warn(core->bus, "Timeout waiting for register 0x%04X!\n", reg);
109 
110 	return false;
111 }
112 
113 static void bcma_release_core_dev(struct device *dev)
114 {
115 	struct bcma_device *core = container_of(dev, struct bcma_device, dev);
116 	if (core->io_addr)
117 		iounmap(core->io_addr);
118 	if (core->io_wrap)
119 		iounmap(core->io_wrap);
120 	kfree(core);
121 }
122 
123 static int bcma_register_cores(struct bcma_bus *bus)
124 {
125 	struct bcma_device *core;
126 	int err, dev_id = 0;
127 
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:
133 		case BCMA_CORE_PCI:
134 		case BCMA_CORE_PCIE:
135 		case BCMA_CORE_PCIE2:
136 		case BCMA_CORE_MIPS_74K:
137 		case BCMA_CORE_4706_MAC_GBIT_COMMON:
138 			continue;
139 		}
140 
141 		/* Only first GMAC core on BCM4706 is connected and working */
142 		if (core->id.id == BCMA_CORE_4706_MAC_GBIT &&
143 		    core->core_unit > 0)
144 			continue;
145 
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);
149 
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;
155 			break;
156 		case BCMA_HOSTTYPE_SOC:
157 			core->dev.dma_mask = &core->dev.coherent_dma_mask;
158 			core->dma_dev = &core->dev;
159 			break;
160 		case BCMA_HOSTTYPE_SDIO:
161 			break;
162 		}
163 
164 		err = device_register(&core->dev);
165 		if (err) {
166 			bcma_err(bus,
167 				 "Could not register dev for core 0x%03X\n",
168 				 core->id.id);
169 			put_device(&core->dev);
170 			continue;
171 		}
172 		core->dev_registered = true;
173 		dev_id++;
174 	}
175 
176 #ifdef CONFIG_BCMA_DRIVER_MIPS
177 	if (bus->drv_cc.pflash.present) {
178 		err = platform_device_register(&bcma_pflash_dev);
179 		if (err)
180 			bcma_err(bus, "Error registering parallel flash\n");
181 	}
182 #endif
183 
184 #ifdef CONFIG_BCMA_SFLASH
185 	if (bus->drv_cc.sflash.present) {
186 		err = platform_device_register(&bcma_sflash_dev);
187 		if (err)
188 			bcma_err(bus, "Error registering serial flash\n");
189 	}
190 #endif
191 
192 #ifdef CONFIG_BCMA_NFLASH
193 	if (bus->drv_cc.nflash.present) {
194 		err = platform_device_register(&bcma_nflash_dev);
195 		if (err)
196 			bcma_err(bus, "Error registering NAND flash\n");
197 	}
198 #endif
199 	err = bcma_gpio_init(&bus->drv_cc);
200 	if (err == -ENOTSUPP)
201 		bcma_debug(bus, "GPIO driver not activated\n");
202 	else if (err)
203 		bcma_err(bus, "Error registering GPIO driver: %i\n", err);
204 
205 	if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
206 		err = bcma_chipco_watchdog_register(&bus->drv_cc);
207 		if (err)
208 			bcma_err(bus, "Error registering watchdog driver\n");
209 	}
210 
211 	return 0;
212 }
213 
214 static void bcma_unregister_cores(struct bcma_bus *bus)
215 {
216 	struct bcma_device *core, *tmp;
217 
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);
222 	}
223 	if (bus->hosttype == BCMA_HOSTTYPE_SOC)
224 		platform_device_unregister(bus->drv_cc.watchdog);
225 }
226 
227 int bcma_bus_register(struct bcma_bus *bus)
228 {
229 	int err;
230 	struct bcma_device *core;
231 
232 	mutex_lock(&bcma_buses_mutex);
233 	bus->num = bcma_bus_next_num++;
234 	mutex_unlock(&bcma_buses_mutex);
235 
236 	/* Scan for devices (cores) */
237 	err = bcma_bus_scan(bus);
238 	if (err) {
239 		bcma_err(bus, "Failed to scan: %d\n", err);
240 		return err;
241 	}
242 
243 	/* Early init CC core */
244 	core = bcma_find_core(bus, bcma_cc_core_id(bus));
245 	if (core) {
246 		bus->drv_cc.core = core;
247 		bcma_core_chipcommon_early_init(&bus->drv_cc);
248 	}
249 
250 	/* Try to get SPROM */
251 	err = bcma_sprom_get(bus);
252 	if (err == -ENOENT) {
253 		bcma_err(bus, "No SPROM available\n");
254 	} else if (err)
255 		bcma_err(bus, "Failed to get SPROM: %d\n", err);
256 
257 	/* Init CC core */
258 	core = bcma_find_core(bus, bcma_cc_core_id(bus));
259 	if (core) {
260 		bus->drv_cc.core = core;
261 		bcma_core_chipcommon_init(&bus->drv_cc);
262 	}
263 
264 	/* Init MIPS core */
265 	core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
266 	if (core) {
267 		bus->drv_mips.core = core;
268 		bcma_core_mips_init(&bus->drv_mips);
269 	}
270 
271 	/* Init PCIE core */
272 	core = bcma_find_core_unit(bus, BCMA_CORE_PCIE, 0);
273 	if (core) {
274 		bus->drv_pci[0].core = core;
275 		bcma_core_pci_init(&bus->drv_pci[0]);
276 	}
277 
278 	/* Init PCIE core */
279 	core = bcma_find_core_unit(bus, BCMA_CORE_PCIE, 1);
280 	if (core) {
281 		bus->drv_pci[1].core = core;
282 		bcma_core_pci_init(&bus->drv_pci[1]);
283 	}
284 
285 	/* Init PCIe Gen 2 core */
286 	core = bcma_find_core_unit(bus, BCMA_CORE_PCIE2, 0);
287 	if (core) {
288 		bus->drv_pcie2.core = core;
289 		bcma_core_pcie2_init(&bus->drv_pcie2);
290 	}
291 
292 	/* Init GBIT MAC COMMON core */
293 	core = bcma_find_core(bus, BCMA_CORE_4706_MAC_GBIT_COMMON);
294 	if (core) {
295 		bus->drv_gmac_cmn.core = core;
296 		bcma_core_gmac_cmn_init(&bus->drv_gmac_cmn);
297 	}
298 
299 	/* Register found cores */
300 	bcma_register_cores(bus);
301 
302 	bcma_info(bus, "Bus registered\n");
303 
304 	return 0;
305 }
306 
307 void bcma_bus_unregister(struct bcma_bus *bus)
308 {
309 	struct bcma_device *cores[3];
310 	int err;
311 
312 	err = bcma_gpio_unregister(&bus->drv_cc);
313 	if (err == -EBUSY)
314 		bcma_err(bus, "Some GPIOs are still in use.\n");
315 	else if (err)
316 		bcma_err(bus, "Can not unregister GPIO driver: %i\n", err);
317 
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);
321 
322 	bcma_unregister_cores(bus);
323 
324 	kfree(cores[2]);
325 	kfree(cores[1]);
326 	kfree(cores[0]);
327 }
328 
329 int __init bcma_bus_early_register(struct bcma_bus *bus,
330 				   struct bcma_device *core_cc,
331 				   struct bcma_device *core_mips)
332 {
333 	int err;
334 	struct bcma_device *core;
335 	struct bcma_device_id match;
336 
337 	bcma_init_bus(bus);
338 
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;
343 
344 	/* Scan for chip common core */
345 	err = bcma_bus_scan_early(bus, &match, core_cc);
346 	if (err) {
347 		bcma_err(bus, "Failed to scan for common core: %d\n", err);
348 		return -1;
349 	}
350 
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;
355 
356 	/* Scan for mips core */
357 	err = bcma_bus_scan_early(bus, &match, core_mips);
358 	if (err) {
359 		bcma_err(bus, "Failed to scan for mips core: %d\n", err);
360 		return -1;
361 	}
362 
363 	/* Early init CC core */
364 	core = bcma_find_core(bus, bcma_cc_core_id(bus));
365 	if (core) {
366 		bus->drv_cc.core = core;
367 		bcma_core_chipcommon_early_init(&bus->drv_cc);
368 	}
369 
370 	/* Early init MIPS core */
371 	core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
372 	if (core) {
373 		bus->drv_mips.core = core;
374 		bcma_core_mips_early_init(&bus->drv_mips);
375 	}
376 
377 	bcma_info(bus, "Early bus registered\n");
378 
379 	return 0;
380 }
381 
382 #ifdef CONFIG_PM
383 int bcma_bus_suspend(struct bcma_bus *bus)
384 {
385 	struct bcma_device *core;
386 
387 	list_for_each_entry(core, &bus->cores, list) {
388 		struct device_driver *drv = core->dev.driver;
389 		if (drv) {
390 			struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
391 			if (adrv->suspend)
392 				adrv->suspend(core);
393 		}
394 	}
395 	return 0;
396 }
397 
398 int bcma_bus_resume(struct bcma_bus *bus)
399 {
400 	struct bcma_device *core;
401 
402 	/* Init CC core */
403 	if (bus->drv_cc.core) {
404 		bus->drv_cc.setup_done = false;
405 		bcma_core_chipcommon_init(&bus->drv_cc);
406 	}
407 
408 	list_for_each_entry(core, &bus->cores, list) {
409 		struct device_driver *drv = core->dev.driver;
410 		if (drv) {
411 			struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
412 			if (adrv->resume)
413 				adrv->resume(core);
414 		}
415 	}
416 
417 	return 0;
418 }
419 #endif
420 
421 int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
422 {
423 	drv->drv.name = drv->name;
424 	drv->drv.bus = &bcma_bus_type;
425 	drv->drv.owner = owner;
426 
427 	return driver_register(&drv->drv);
428 }
429 EXPORT_SYMBOL_GPL(__bcma_driver_register);
430 
431 void bcma_driver_unregister(struct bcma_driver *drv)
432 {
433 	driver_unregister(&drv->drv);
434 }
435 EXPORT_SYMBOL_GPL(bcma_driver_unregister);
436 
437 static int bcma_bus_match(struct device *dev, struct device_driver *drv)
438 {
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;
443 
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))
449 			return 1;
450 	}
451 	return 0;
452 }
453 
454 static int bcma_device_probe(struct device *dev)
455 {
456 	struct bcma_device *core = container_of(dev, struct bcma_device, dev);
457 	struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
458 					       drv);
459 	int err = 0;
460 
461 	if (adrv->probe)
462 		err = adrv->probe(core);
463 
464 	return err;
465 }
466 
467 static int bcma_device_remove(struct device *dev)
468 {
469 	struct bcma_device *core = container_of(dev, struct bcma_device, dev);
470 	struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
471 					       drv);
472 
473 	if (adrv->remove)
474 		adrv->remove(core);
475 
476 	return 0;
477 }
478 
479 static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
480 {
481 	struct bcma_device *core = container_of(dev, struct bcma_device, dev);
482 
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);
487 }
488 
489 static int __init bcma_modinit(void)
490 {
491 	int err;
492 
493 	err = bus_register(&bcma_bus_type);
494 	if (err)
495 		return err;
496 
497 #ifdef CONFIG_BCMA_HOST_PCI
498 	err = bcma_host_pci_init();
499 	if (err) {
500 		pr_err("PCI host initialization failed\n");
501 		err = 0;
502 	}
503 #endif
504 
505 	return err;
506 }
507 fs_initcall(bcma_modinit);
508 
509 static void __exit bcma_modexit(void)
510 {
511 #ifdef CONFIG_BCMA_HOST_PCI
512 	bcma_host_pci_exit();
513 #endif
514 	bus_unregister(&bcma_bus_type);
515 }
516 module_exit(bcma_modexit)
517