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	.init_name = "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 = kzalloc(sizeof(struct superhyway_device), GFP_KERNEL);
 60		if (!dev)
 61			return -ENOMEM;
 62
 63	}
 64
 65	dev->bus = bus;
 66	superhyway_read_vcr(dev, base, &dev->vcr);
 67
 68	if (!dev->resource) {
 69		dev->resource = kzalloc(sizeof(struct resource), GFP_KERNEL);
 70		if (!dev->resource) {
 71			kfree(dev);
 72			return -ENOMEM;
 73		}
 74
 75		dev->resource->name	= dev->name;
 76		dev->resource->start	= base;
 77		dev->resource->end	= dev->resource->start + 0x01000000;
 78	}
 79
 80	dev->dev.parent		= &superhyway_bus_device;
 81	dev->dev.bus		= &superhyway_bus_type;
 82	dev->dev.release	= superhyway_device_release;
 83	dev->id.id		= dev->vcr.mod_id;
 84
 85	sprintf(dev->name, "SuperHyway device %04x", dev->id.id);
 86	dev_set_name(&dev->dev, "%02x", superhyway_devices);
 87
 88	superhyway_devices++;
 89
 90	return device_register(&dev->dev);
 91}
 92
 93int superhyway_add_devices(struct superhyway_bus *bus,
 94			   struct superhyway_device **devices,
 95			   int nr_devices)
 96{
 97	int i, ret = 0;
 98
 99	for (i = 0; i < nr_devices; i++) {
100		struct superhyway_device *dev = devices[i];
101		ret |= superhyway_add_device(dev->resource[0].start, dev, bus);
102	}
103
104	return ret;
105}
106
107static int __init superhyway_init(void)
108{
109	struct superhyway_bus *bus;
110	int ret;
111
112	ret = device_register(&superhyway_bus_device);
113	if (unlikely(ret))
114		return ret;
115
116	for (bus = superhyway_channels; bus->ops; bus++)
117		ret |= superhyway_scan_bus(bus);
118
119	return ret;
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 void 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->remove)
159		shyway_drv->remove(shyway_dev);
160}
161
162/**
163 * superhyway_register_driver - Register a new SuperHyway driver
164 * @drv: SuperHyway driver to register.
165 *
166 * This registers the passed in @drv. Any devices matching the id table will
167 * automatically be populated and handed off to the driver's specified probe
168 * routine.
169 */
170int superhyway_register_driver(struct superhyway_driver *drv)
171{
172	drv->drv.name	= drv->name;
173	drv->drv.bus	= &superhyway_bus_type;
174
175	return driver_register(&drv->drv);
176}
177
178/**
179 * superhyway_unregister_driver - Unregister a SuperHyway driver
180 * @drv: SuperHyway driver to unregister.
181 *
182 * This cleans up after superhyway_register_driver(), and should be invoked in
183 * the exit path of any module drivers.
184 */
185void superhyway_unregister_driver(struct superhyway_driver *drv)
186{
187	driver_unregister(&drv->drv);
188}
189
190static int superhyway_bus_match(struct device *dev, struct device_driver *drv)
191{
192	struct superhyway_device *shyway_dev = to_superhyway_device(dev);
193	struct superhyway_driver *shyway_drv = to_superhyway_driver(drv);
194	const struct superhyway_device_id *ids = shyway_drv->id_table;
195
196	if (!ids)
197		return -EINVAL;
198	if (superhyway_match_id(ids, shyway_dev))
199		return 1;
200
201	return -ENODEV;
202}
203
204struct bus_type superhyway_bus_type = {
205	.name		= "superhyway",
206	.match		= superhyway_bus_match,
207#ifdef CONFIG_SYSFS
208	.dev_groups	= superhyway_dev_groups,
209#endif
210	.probe		= superhyway_device_probe,
211	.remove		= superhyway_device_remove,
212};
213
214static int __init superhyway_bus_init(void)
215{
216	return bus_register(&superhyway_bus_type);
217}
218
219static void __exit superhyway_bus_exit(void)
220{
221	device_unregister(&superhyway_bus_device);
222	bus_unregister(&superhyway_bus_type);
223}
224
225core_initcall(superhyway_bus_init);
226module_exit(superhyway_bus_exit);
227
228EXPORT_SYMBOL(superhyway_bus_type);
229EXPORT_SYMBOL(superhyway_add_device);
230EXPORT_SYMBOL(superhyway_add_devices);
231EXPORT_SYMBOL(superhyway_register_driver);
232EXPORT_SYMBOL(superhyway_unregister_driver);
233
234MODULE_LICENSE("GPL");