This source file includes following definitions.
- superhyway_device_release
- superhyway_add_device
- superhyway_add_devices
- superhyway_init
- superhyway_match_id
- superhyway_device_probe
- superhyway_device_remove
- superhyway_register_driver
- superhyway_unregister_driver
- superhyway_bus_match
- superhyway_bus_init
- superhyway_bus_exit
1
2
3
4
5
6
7
8
9
10
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
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 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
168
169
170
171
172
173
174 int 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
184
185
186
187
188
189 void superhyway_unregister_driver(struct superhyway_driver *drv)
190 {
191 driver_unregister(&drv->drv);
192 }
193
194 static 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
208 struct bus_type superhyway_bus_type = {
209 .name = "superhyway",
210 .match = superhyway_bus_match,
211 #ifdef CONFIG_SYSFS
212 .dev_groups = superhyway_dev_groups,
213 #endif
214 .probe = superhyway_device_probe,
215 .remove = superhyway_device_remove,
216 };
217
218 static int __init superhyway_bus_init(void)
219 {
220 return bus_register(&superhyway_bus_type);
221 }
222
223 static void __exit superhyway_bus_exit(void)
224 {
225 device_unregister(&superhyway_bus_device);
226 bus_unregister(&superhyway_bus_type);
227 }
228
229 core_initcall(superhyway_bus_init);
230 module_exit(superhyway_bus_exit);
231
232 EXPORT_SYMBOL(superhyway_bus_type);
233 EXPORT_SYMBOL(superhyway_add_device);
234 EXPORT_SYMBOL(superhyway_add_devices);
235 EXPORT_SYMBOL(superhyway_register_driver);
236 EXPORT_SYMBOL(superhyway_unregister_driver);
237
238 MODULE_LICENSE("GPL");