1/*
2 * ocp.c
3 *
4 *      (c) Benjamin Herrenschmidt (benh@kernel.crashing.org)
5 *          Mipsys - France
6 *
7 *          Derived from work (c) Armin Kuster akuster@pacbell.net
8 *
9 *          Additional support and port to 2.6 LDM/sysfs by
10 *          Matt Porter <mporter@kernel.crashing.org>
11 *          Copyright 2004 MontaVista Software, Inc.
12 *
13 *  This program is free software; you can redistribute  it and/or modify it
14 *  under  the terms of  the GNU General Public License as published by the
15 *  Free Software Foundation;  either version 2 of the  License, or (at your
16 *  option) any later version.
17 *
18 *  OCP (On Chip Peripheral) is a software emulated "bus" with a
19 *  pseudo discovery method for dumb peripherals. Usually these type
20 *  of peripherals are found on embedded SoC (System On a Chip)
21 *  processors or highly integrated system controllers that have
22 *  a host bridge and many peripherals.  Common examples where
23 *  this is already used include the PPC4xx, PPC85xx, MPC52xx,
24 *  and MV64xxx parts.
25 *
26 *  This subsystem creates a standard OCP bus type within the
27 *  device model.  The devices on the OCP bus are seeded by an
28 *  an initial OCP device array created by the arch-specific
29 *  Device entries can be added/removed/modified through OCP
30 *  helper functions to accommodate system and  board-specific
31 *  parameters commonly found in embedded systems. OCP also
32 *  provides a standard method for devices to describe extended
33 *  attributes about themselves to the system.  A standard access
34 *  method allows OCP drivers to obtain the information, both
35 *  SoC-specific and system/board-specific, needed for operation.
36 */
37
38#include <linux/module.h>
39#include <linux/list.h>
40#include <linux/miscdevice.h>
41#include <linux/slab.h>
42#include <linux/types.h>
43#include <linux/init.h>
44#include <linux/pm.h>
45#include <linux/bootmem.h>
46#include <linux/device.h>
47
48#include <asm/io.h>
49#include <asm/ocp.h>
50#include <asm/errno.h>
51#include <asm/rwsem.h>
52#include <asm/semaphore.h>
53
54//#define DBG(x)	printk x
55#define DBG(x)
56
57extern int mem_init_done;
58
59extern struct ocp_def core_ocp[];	/* Static list of devices, provided by
60					   CPU core */
61
62LIST_HEAD(ocp_devices);			/* List of all OCP devices */
63DECLARE_RWSEM(ocp_devices_sem);		/* Global semaphores for those lists */
64
65static int ocp_inited;
66
67/* Sysfs support */
68#define OCP_DEF_ATTR(field, format_string)				\
69static ssize_t								\
70show_##field(struct device *dev, struct device_attribute *attr, char *buf)				\
71{									\
72	struct ocp_device *odev = to_ocp_dev(dev);			\
73									\
74	return sprintf(buf, format_string, odev->def->field);		\
75}									\
76static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
77
78OCP_DEF_ATTR(vendor, "0x%04x\n");
79OCP_DEF_ATTR(function, "0x%04x\n");
80OCP_DEF_ATTR(index, "0x%04x\n");
81#ifdef CONFIG_PTE_64BIT
82OCP_DEF_ATTR(paddr, "0x%016Lx\n");
83#else
84OCP_DEF_ATTR(paddr, "0x%08lx\n");
85#endif
86OCP_DEF_ATTR(irq, "%d\n");
87OCP_DEF_ATTR(pm, "%lu\n");
88
89void ocp_create_sysfs_dev_files(struct ocp_device *odev)
90{
91	struct device *dev = &odev->dev;
92
93	/* Current OCP device def attributes */
94	device_create_file(dev, &dev_attr_vendor);
95	device_create_file(dev, &dev_attr_function);
96	device_create_file(dev, &dev_attr_index);
97	device_create_file(dev, &dev_attr_paddr);
98	device_create_file(dev, &dev_attr_irq);
99	device_create_file(dev, &dev_attr_pm);
100	/* Current OCP device additions attributes */
101	if (odev->def->additions && odev->def->show)
102		odev->def->show(dev);
103}
104
105/**
106 *	ocp_device_match	-	Match one driver to one device
107 *	@drv: driver to match
108 *	@dev: device to match
109 *
110 *	This function returns 0 if the driver and device don't match
111 */
112static int
113ocp_device_match(struct device *dev, struct device_driver *drv)
114{
115	struct ocp_device *ocp_dev = to_ocp_dev(dev);
116	struct ocp_driver *ocp_drv = to_ocp_drv(drv);
117	const struct ocp_device_id *ids = ocp_drv->id_table;
118
119	if (!ids)
120		return 0;
121
122	while (ids->vendor || ids->function) {
123		if ((ids->vendor == OCP_ANY_ID
124		     || ids->vendor == ocp_dev->def->vendor)
125		    && (ids->function == OCP_ANY_ID
126			|| ids->function == ocp_dev->def->function))
127		        return 1;
128		ids++;
129	}
130	return 0;
131}
132
133static int
134ocp_device_probe(struct device *dev)
135{
136	int error = 0;
137	struct ocp_driver *drv;
138	struct ocp_device *ocp_dev;
139
140	drv = to_ocp_drv(dev->driver);
141	ocp_dev = to_ocp_dev(dev);
142
143	if (drv->probe) {
144		error = drv->probe(ocp_dev);
145		if (error >= 0) {
146			ocp_dev->driver = drv;
147			error = 0;
148		}
149	}
150	return error;
151}
152
153static int
154ocp_device_remove(struct device *dev)
155{
156	struct ocp_device *ocp_dev = to_ocp_dev(dev);
157
158	if (ocp_dev->driver) {
159		if (ocp_dev->driver->remove)
160			ocp_dev->driver->remove(ocp_dev);
161		ocp_dev->driver = NULL;
162	}
163	return 0;
164}
165
166static int
167ocp_device_suspend(struct device *dev, pm_message_t state)
168{
169	struct ocp_device *ocp_dev = to_ocp_dev(dev);
170	struct ocp_driver *ocp_drv = to_ocp_drv(dev->driver);
171
172	if (dev->driver && ocp_drv->suspend)
173		return ocp_drv->suspend(ocp_dev, state);
174	return 0;
175}
176
177static int
178ocp_device_resume(struct device *dev)
179{
180	struct ocp_device *ocp_dev = to_ocp_dev(dev);
181	struct ocp_driver *ocp_drv = to_ocp_drv(dev->driver);
182
183	if (dev->driver && ocp_drv->resume)
184		return ocp_drv->resume(ocp_dev);
185	return 0;
186}
187
188struct bus_type ocp_bus_type = {
189	.name = "ocp",
190	.match = ocp_device_match,
191	.probe = ocp_device_probe,
192	.remove = ocp_device_remove,
193	.suspend = ocp_device_suspend,
194	.resume = ocp_device_resume,
195};
196
197/**
198 *	ocp_register_driver	-	Register an OCP driver
199 *	@drv: pointer to statically defined ocp_driver structure
200 *
201 *	The driver's probe() callback is called either recursively
202 *	by this function or upon later call of ocp_driver_init
203 *
204 *	NOTE: Detection of devices is a 2 pass step on this implementation,
205 *	hotswap isn't supported. First, all OCP devices are put in the device
206 *	list, _then_ all drivers are probed on each match.
207 */
208int
209ocp_register_driver(struct ocp_driver *drv)
210{
211	/* initialize common driver fields */
212	drv->driver.name = drv->name;
213	drv->driver.bus = &ocp_bus_type;
214
215	/* register with core */
216	return driver_register(&drv->driver);
217}
218
219/**
220 *	ocp_unregister_driver	-	Unregister an OCP driver
221 *	@drv: pointer to statically defined ocp_driver structure
222 *
223 *	The driver's remove() callback is called recursively
224 *	by this function for any device already registered
225 */
226void
227ocp_unregister_driver(struct ocp_driver *drv)
228{
229	DBG(("ocp: ocp_unregister_driver(%s)...\n", drv->name));
230
231	driver_unregister(&drv->driver);
232
233	DBG(("ocp: ocp_unregister_driver(%s)... done.\n", drv->name));
234}
235
236/* Core of ocp_find_device(). Caller must hold ocp_devices_sem */
237static struct ocp_device *
238__ocp_find_device(unsigned int vendor, unsigned int function, int index)
239{
240	struct list_head	*entry;
241	struct ocp_device	*dev, *found = NULL;
242
243	DBG(("ocp: __ocp_find_device(vendor: %x, function: %x, index: %d)...\n", vendor, function, index));
244
245	list_for_each(entry, &ocp_devices) {
246		dev = list_entry(entry, struct ocp_device, link);
247		if (vendor != OCP_ANY_ID && vendor != dev->def->vendor)
248			continue;
249		if (function != OCP_ANY_ID && function != dev->def->function)
250			continue;
251		if (index != OCP_ANY_INDEX && index != dev->def->index)
252			continue;
253		found = dev;
254		break;
255	}
256
257	DBG(("ocp: __ocp_find_device(vendor: %x, function: %x, index: %d)... done\n", vendor, function, index));
258
259	return found;
260}
261
262/**
263 *	ocp_find_device	-	Find a device by function & index
264 *      @vendor: vendor ID of the device (or OCP_ANY_ID)
265 *	@function: function code of the device (or OCP_ANY_ID)
266 *	@idx: index of the device (or OCP_ANY_INDEX)
267 *
268 *	This function allows a lookup of a given function by it's
269 *	index, it's typically used to find the MAL or ZMII associated
270 *	with an EMAC or similar horrors.
271 *      You can pass vendor, though you usually want OCP_ANY_ID there...
272 */
273struct ocp_device *
274ocp_find_device(unsigned int vendor, unsigned int function, int index)
275{
276	struct ocp_device	*dev;
277
278	down_read(&ocp_devices_sem);
279	dev = __ocp_find_device(vendor, function, index);
280	up_read(&ocp_devices_sem);
281
282	return dev;
283}
284
285/**
286 *	ocp_get_one_device -	Find a def by function & index
287 *      @vendor: vendor ID of the device (or OCP_ANY_ID)
288 *	@function: function code of the device (or OCP_ANY_ID)
289 *	@idx: index of the device (or OCP_ANY_INDEX)
290 *
291 *	This function allows a lookup of a given ocp_def by it's
292 *	vendor, function, and index.  The main purpose for is to
293 *	allow modification of the def before binding to the driver
294 */
295struct ocp_def *
296ocp_get_one_device(unsigned int vendor, unsigned int function, int index)
297{
298	struct ocp_device	*dev;
299	struct ocp_def		*found = NULL;
300
301	DBG(("ocp: ocp_get_one_device(vendor: %x, function: %x, index: %d)...\n",
302		vendor, function, index));
303
304	dev = ocp_find_device(vendor, function, index);
305
306	if (dev)
307		found = dev->def;
308
309	DBG(("ocp: ocp_get_one_device(vendor: %x, function: %x, index: %d)... done.\n",
310		vendor, function, index));
311
312	return found;
313}
314
315/**
316 *	ocp_add_one_device	-	Add a device
317 *	@def: static device definition structure
318 *
319 *	This function adds a device definition to the
320 *	device list. It may only be called before
321 *	ocp_driver_init() and will return an error
322 *	otherwise.
323 */
324int
325ocp_add_one_device(struct ocp_def *def)
326{
327	struct	ocp_device	*dev;
328
329	DBG(("ocp: ocp_add_one_device()...\n"));
330
331	/* Can't be called after ocp driver init */
332	if (ocp_inited)
333		return 1;
334
335	if (mem_init_done)
336		dev = kmalloc(sizeof(*dev), GFP_KERNEL);
337	else
338		dev = alloc_bootmem(sizeof(*dev));
339
340	if (dev == NULL)
341		return 1;
342	memset(dev, 0, sizeof(*dev));
343	dev->def = def;
344	dev->current_state = 4;
345	sprintf(dev->name, "OCP device %04x:%04x:%04x",
346		dev->def->vendor, dev->def->function, dev->def->index);
347	down_write(&ocp_devices_sem);
348	list_add_tail(&dev->link, &ocp_devices);
349	up_write(&ocp_devices_sem);
350
351	DBG(("ocp: ocp_add_one_device()...done\n"));
352
353	return 0;
354}
355
356/**
357 *	ocp_remove_one_device -	Remove a device by function & index
358 *      @vendor: vendor ID of the device (or OCP_ANY_ID)
359 *	@function: function code of the device (or OCP_ANY_ID)
360 *	@idx: index of the device (or OCP_ANY_INDEX)
361 *
362 *	This function allows removal of a given function by its
363 *	index. It may only be called before ocp_driver_init()
364 *	and will return an error otherwise.
365 */
366int
367ocp_remove_one_device(unsigned int vendor, unsigned int function, int index)
368{
369	struct ocp_device *dev;
370
371	DBG(("ocp: ocp_remove_one_device(vendor: %x, function: %x, index: %d)...\n", vendor, function, index));
372
373	/* Can't be called after ocp driver init */
374	if (ocp_inited)
375		return 1;
376
377	down_write(&ocp_devices_sem);
378	dev = __ocp_find_device(vendor, function, index);
379	list_del((struct list_head *)dev);
380	up_write(&ocp_devices_sem);
381
382	DBG(("ocp: ocp_remove_one_device(vendor: %x, function: %x, index: %d)... done.\n", vendor, function, index));
383
384	return 0;
385}
386
387/**
388 *	ocp_for_each_device	-	Iterate over OCP devices
389 *	@callback: routine to execute for each ocp device.
390 *	@arg: user data to be passed to callback routine.
391 *
392 *	This routine holds the ocp_device semaphore, so the
393 *	callback routine cannot modify the ocp_device list.
394 */
395void
396ocp_for_each_device(void(*callback)(struct ocp_device *, void *arg), void *arg)
397{
398	struct list_head *entry;
399
400	if (callback) {
401		down_read(&ocp_devices_sem);
402		list_for_each(entry, &ocp_devices)
403			callback(list_entry(entry, struct ocp_device, link),
404				arg);
405		up_read(&ocp_devices_sem);
406	}
407}
408
409/**
410 *	ocp_early_init	-	Init OCP device management
411 *
412 *	This function builds the list of devices before setup_arch.
413 *	This allows platform code to modify the device lists before
414 *	they are bound to drivers (changes to paddr, removing devices
415 *	etc)
416 */
417int __init
418ocp_early_init(void)
419{
420	struct ocp_def	*def;
421
422	DBG(("ocp: ocp_early_init()...\n"));
423
424	/* Fill the devices list */
425	for (def = core_ocp; def->vendor != OCP_VENDOR_INVALID; def++)
426		ocp_add_one_device(def);
427
428	DBG(("ocp: ocp_early_init()... done.\n"));
429
430	return 0;
431}
432
433/**
434 *	ocp_driver_init	-	Init OCP device management
435 *
436 *	This function is meant to be called via OCP bus registration.
437 */
438static int __init
439ocp_driver_init(void)
440{
441	int ret = 0, index = 0;
442	struct device *ocp_bus;
443	struct list_head *entry;
444	struct ocp_device *dev;
445
446	if (ocp_inited)
447		return ret;
448	ocp_inited = 1;
449
450	DBG(("ocp: ocp_driver_init()...\n"));
451
452	/* Allocate/register primary OCP bus */
453	ocp_bus = kzalloc(sizeof(struct device), GFP_KERNEL);
454	if (ocp_bus == NULL)
455		return 1;
456	strcpy(ocp_bus->bus_id, "ocp");
457
458	bus_register(&ocp_bus_type);
459
460	device_register(ocp_bus);
461
462	/* Put each OCP device into global device list */
463	list_for_each(entry, &ocp_devices) {
464		dev = list_entry(entry, struct ocp_device, link);
465		sprintf(dev->dev.bus_id, "%2.2x", index);
466		dev->dev.parent = ocp_bus;
467		dev->dev.bus = &ocp_bus_type;
468		device_register(&dev->dev);
469		ocp_create_sysfs_dev_files(dev);
470		index++;
471	}
472
473	DBG(("ocp: ocp_driver_init()... done.\n"));
474
475	return 0;
476}
477
478postcore_initcall(ocp_driver_init);
479
480EXPORT_SYMBOL(ocp_bus_type);
481EXPORT_SYMBOL(ocp_find_device);
482EXPORT_SYMBOL(ocp_register_driver);
483EXPORT_SYMBOL(ocp_unregister_driver);
484