1/*
2 * drivers/sh/superhyway/superhyway.c
3 *
4 * SuperHyway Bus Driver
5 *
6 * Copyright (C) 2004, 2005  Paul Mundt <lethal@linux-sh.org>
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License.  See the file "COPYING" in the main directory of this archive
10 * for more details.
11 */
12#include <linux/kernel.h>
13#include <linux/device.h>
14#include <linux/init.h>
15#include <linux/module.h>
16#include <linux/types.h>
17#include <linux/list.h>
18#include <linux/superhyway.h>
19#include <linux/string.h>
20#include <linux/slab.h>
21
22static int superhyway_devices;
23
24static struct device superhyway_bus_device = {
25	.bus_id = "superhyway",
26};
27
28static void superhyway_device_release(struct device *dev)
29{
30	struct superhyway_device *sdev = to_superhyway_device(dev);
31
32	kfree(sdev->resource);
33	kfree(sdev);
34}
35
36/**
37 * superhyway_add_device - Add a SuperHyway module
38 * @base: Physical address where module is mapped.
39 * @sdev: SuperHyway device to add, or NULL to allocate a new one.
40 * @bus: Bus where SuperHyway module resides.
41 *
42 * This is responsible for adding a new SuperHyway module. This sets up a new
43 * struct superhyway_device for the module being added if @sdev == NULL.
44 *
45 * Devices are initially added in the order that they are scanned (from the
46 * top-down of the memory map), and are assigned an ID based on the order that
47 * they are added. Any manual addition of a module will thus get the ID after
48 * the devices already discovered regardless of where it resides in memory.
49 *
50 * Further work can and should be done in superhyway_scan_bus(), to be sure
51 * that any new modules are properly discovered and subsequently registered.
52 */
53int superhyway_add_device(unsigned long base, struct superhyway_device *sdev,
54			  struct superhyway_bus *bus)
55{
56	struct superhyway_device *dev = sdev;
57
58	if (!dev) {
59		dev = kmalloc(sizeof(struct superhyway_device), GFP_KERNEL);
60		if (!dev)
61			return -ENOMEM;
62
63		memset(dev, 0, sizeof(struct superhyway_device));
64	}
65
66	dev->bus = bus;
67	superhyway_read_vcr(dev, base, &dev->vcr);
68
69	if (!dev->resource) {
70		dev->resource = kmalloc(sizeof(struct resource), GFP_KERNEL);
71		if (!dev->resource) {
72			kfree(dev);
73			return -ENOMEM;
74		}
75
76		dev->resource->name	= dev->name;
77		dev->resource->start	= base;
78		dev->resource->end	= dev->resource->start + 0x01000000;
79	}
80
81	dev->dev.parent		= &superhyway_bus_device;
82	dev->dev.bus		= &superhyway_bus_type;
83	dev->dev.release	= superhyway_device_release;
84	dev->id.id		= dev->vcr.mod_id;
85
86	sprintf(dev->name, "SuperHyway device %04x", dev->id.id);
87	sprintf(dev->dev.bus_id, "%02x", superhyway_devices);
88
89	superhyway_devices++;
90
91	return device_register(&dev->dev);
92}
93
94int superhyway_add_devices(struct superhyway_bus *bus,
95			   struct superhyway_device **devices,
96			   int nr_devices)
97{
98	int i, ret = 0;
99
100	for (i = 0; i < nr_devices; i++) {
101		struct superhyway_device *dev = devices[i];
102		ret |= superhyway_add_device(dev->resource[0].start, dev, bus);
103	}
104
105	return ret;
106}
107
108static int __init superhyway_init(void)
109{
110	struct superhyway_bus *bus;
111	int ret = 0;
112
113	device_register(&superhyway_bus_device);
114
115	for (bus = superhyway_channels; bus->ops; bus++)
116		ret |= superhyway_scan_bus(bus);
117
118	return ret;
119}
120
121postcore_initcall(superhyway_init);
122
123static const struct superhyway_device_id *
124superhyway_match_id(const struct superhyway_device_id *ids,
125		    struct superhyway_device *dev)
126{
127	while (ids->id) {
128		if (ids->id == dev->id.id)
129			return ids;
130
131		ids++;
132	}
133
134	return NULL;
135}
136
137static int superhyway_device_probe(struct device *dev)
138{
139	struct superhyway_device *shyway_dev = to_superhyway_device(dev);
140	struct superhyway_driver *shyway_drv = to_superhyway_driver(dev->driver);
141
142	if (shyway_drv && shyway_drv->probe) {
143		const struct superhyway_device_id *id;
144
145		id = superhyway_match_id(shyway_drv->id_table, shyway_dev);
146		if (id)
147			return shyway_drv->probe(shyway_dev, id);
148	}
149
150	return -ENODEV;
151}
152
153static int superhyway_device_remove(struct device *dev)
154{
155	struct superhyway_device *shyway_dev = to_superhyway_device(dev);
156	struct superhyway_driver *shyway_drv = to_superhyway_driver(dev->driver);
157
158	if (shyway_drv && shyway_drv->remove) {
159		shyway_drv->remove(shyway_dev);
160		return 0;
161	}
162
163	return -ENODEV;
164}
165
166/**
167 * superhyway_register_driver - Register a new SuperHyway driver
168 * @drv: SuperHyway driver to register.
169 *
170 * This registers the passed in @drv. Any devices matching the id table will
171 * automatically be populated and handed off to the driver's specified probe
172 * routine.
173 */
174int superhyway_register_driver(struct superhyway_driver *drv)
175{
176	drv->drv.name	= drv->name;
177	drv->drv.bus	= &superhyway_bus_type;
178
179	return driver_register(&drv->drv);
180}
181
182/**
183 * superhyway_unregister_driver - Unregister a SuperHyway driver
184 * @drv: SuperHyway driver to unregister.
185 *
186 * This cleans up after superhyway_register_driver(), and should be invoked in
187 * the exit path of any module drivers.
188 */
189void superhyway_unregister_driver(struct superhyway_driver *drv)
190{
191	driver_unregister(&drv->drv);
192}
193
194static int superhyway_bus_match(struct device *dev, struct device_driver *drv)
195{
196	struct superhyway_device *shyway_dev = to_superhyway_device(dev);
197	struct superhyway_driver *shyway_drv = to_superhyway_driver(drv);
198	const struct superhyway_device_id *ids = shyway_drv->id_table;
199
200	if (!ids)
201		return -EINVAL;
202	if (superhyway_match_id(ids, shyway_dev))
203		return 1;
204
205	return -ENODEV;
206}
207
208struct bus_type superhyway_bus_type = {
209	.name		= "superhyway",
210	.match		= superhyway_bus_match,
211#ifdef CONFIG_SYSFS
212	.dev_attrs	= superhyway_dev_attrs,
213#endif
214	.probe		= superhyway_device_probe,
215	.remove		= superhyway_device_remove,
216};
217
218static int __init superhyway_bus_init(void)
219{
220	return bus_register(&superhyway_bus_type);
221}
222
223static void __exit superhyway_bus_exit(void)
224{
225	device_unregister(&superhyway_bus_device);
226	bus_unregister(&superhyway_bus_type);
227}
228
229core_initcall(superhyway_bus_init);
230module_exit(superhyway_bus_exit);
231
232EXPORT_SYMBOL(superhyway_bus_type);
233EXPORT_SYMBOL(superhyway_add_device);
234EXPORT_SYMBOL(superhyway_add_devices);
235EXPORT_SYMBOL(superhyway_register_driver);
236EXPORT_SYMBOL(superhyway_unregister_driver);
237
238MODULE_LICENSE("GPL");
239