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 
22 static int superhyway_devices;
23 
24 static struct device superhyway_bus_device = {
25 	.init_name = "superhyway",
26 };
27 
28 static 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  */
53 int 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 
93 int 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 
107 static 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 }
121 postcore_initcall(superhyway_init);
122 
123 static const struct superhyway_device_id *
124 superhyway_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 
137 static 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 
153 static 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  */
170 int 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  */
185 void superhyway_unregister_driver(struct superhyway_driver *drv)
186 {
187 	driver_unregister(&drv->drv);
188 }
189 
190 static 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 
204 struct 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 
214 static int __init superhyway_bus_init(void)
215 {
216 	return bus_register(&superhyway_bus_type);
217 }
218 
219 static void __exit superhyway_bus_exit(void)
220 {
221 	device_unregister(&superhyway_bus_device);
222 	bus_unregister(&superhyway_bus_type);
223 }
224 
225 core_initcall(superhyway_bus_init);
226 module_exit(superhyway_bus_exit);
227 
228 EXPORT_SYMBOL(superhyway_bus_type);
229 EXPORT_SYMBOL(superhyway_add_device);
230 EXPORT_SYMBOL(superhyway_add_devices);
231 EXPORT_SYMBOL(superhyway_register_driver);
232 EXPORT_SYMBOL(superhyway_unregister_driver);
233 
234 MODULE_LICENSE("GPL");
235