1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39#include <linux/init.h>
40#include <linux/export.h>
41#include <linux/console.h>
42#include <linux/kobject.h>
43#include <linux/dma-mapping.h>
44#include <linux/interrupt.h>
45#include <linux/of.h>
46#include <linux/slab.h>
47#include <linux/stat.h>
48#include <linux/of_platform.h>
49#include <asm/ibmebus.h>
50
51static struct device ibmebus_bus_device = {
52 .init_name = "ibmebus",
53};
54
55struct bus_type ibmebus_bus_type;
56
57
58static const struct of_device_id ibmebus_matches[] __initconst = {
59 { .compatible = "IBM,lhca" },
60 { .compatible = "IBM,lhea" },
61 {},
62};
63
64static void *ibmebus_alloc_coherent(struct device *dev,
65 size_t size,
66 dma_addr_t *dma_handle,
67 gfp_t flag,
68 unsigned long attrs)
69{
70 void *mem;
71
72 mem = kmalloc(size, flag);
73 *dma_handle = (dma_addr_t)mem;
74
75 return mem;
76}
77
78static void ibmebus_free_coherent(struct device *dev,
79 size_t size, void *vaddr,
80 dma_addr_t dma_handle,
81 unsigned long attrs)
82{
83 kfree(vaddr);
84}
85
86static dma_addr_t ibmebus_map_page(struct device *dev,
87 struct page *page,
88 unsigned long offset,
89 size_t size,
90 enum dma_data_direction direction,
91 unsigned long attrs)
92{
93 return (dma_addr_t)(page_address(page) + offset);
94}
95
96static void ibmebus_unmap_page(struct device *dev,
97 dma_addr_t dma_addr,
98 size_t size,
99 enum dma_data_direction direction,
100 unsigned long attrs)
101{
102 return;
103}
104
105static int ibmebus_map_sg(struct device *dev,
106 struct scatterlist *sgl,
107 int nents, enum dma_data_direction direction,
108 unsigned long attrs)
109{
110 struct scatterlist *sg;
111 int i;
112
113 for_each_sg(sgl, sg, nents, i) {
114 sg->dma_address = (dma_addr_t) sg_virt(sg);
115 sg->dma_length = sg->length;
116 }
117
118 return nents;
119}
120
121static void ibmebus_unmap_sg(struct device *dev,
122 struct scatterlist *sg,
123 int nents, enum dma_data_direction direction,
124 unsigned long attrs)
125{
126 return;
127}
128
129static int ibmebus_dma_supported(struct device *dev, u64 mask)
130{
131 return mask == DMA_BIT_MASK(64);
132}
133
134static u64 ibmebus_dma_get_required_mask(struct device *dev)
135{
136 return DMA_BIT_MASK(64);
137}
138
139static const struct dma_map_ops ibmebus_dma_ops = {
140 .alloc = ibmebus_alloc_coherent,
141 .free = ibmebus_free_coherent,
142 .map_sg = ibmebus_map_sg,
143 .unmap_sg = ibmebus_unmap_sg,
144 .dma_supported = ibmebus_dma_supported,
145 .get_required_mask = ibmebus_dma_get_required_mask,
146 .map_page = ibmebus_map_page,
147 .unmap_page = ibmebus_unmap_page,
148};
149
150static int ibmebus_match_path(struct device *dev, void *data)
151{
152 struct device_node *dn = to_platform_device(dev)->dev.of_node;
153 return (of_find_node_by_path(data) == dn);
154}
155
156static int ibmebus_match_node(struct device *dev, void *data)
157{
158 return to_platform_device(dev)->dev.of_node == data;
159}
160
161static int ibmebus_create_device(struct device_node *dn)
162{
163 struct platform_device *dev;
164 int ret;
165
166 dev = of_device_alloc(dn, NULL, &ibmebus_bus_device);
167 if (!dev)
168 return -ENOMEM;
169
170 dev->dev.bus = &ibmebus_bus_type;
171 dev->dev.dma_ops = &ibmebus_dma_ops;
172
173 ret = of_device_add(dev);
174 if (ret)
175 platform_device_put(dev);
176 return ret;
177}
178
179static int ibmebus_create_devices(const struct of_device_id *matches)
180{
181 struct device_node *root, *child;
182 struct device *dev;
183 int ret = 0;
184
185 root = of_find_node_by_path("/");
186
187 for_each_child_of_node(root, child) {
188 if (!of_match_node(matches, child))
189 continue;
190
191 dev = bus_find_device(&ibmebus_bus_type, NULL, child,
192 ibmebus_match_node);
193 if (dev) {
194 put_device(dev);
195 continue;
196 }
197
198 ret = ibmebus_create_device(child);
199 if (ret) {
200 printk(KERN_ERR "%s: failed to create device (%i)",
201 __func__, ret);
202 of_node_put(child);
203 break;
204 }
205 }
206
207 of_node_put(root);
208 return ret;
209}
210
211int ibmebus_register_driver(struct platform_driver *drv)
212{
213
214 ibmebus_create_devices(drv->driver.of_match_table);
215
216 drv->driver.bus = &ibmebus_bus_type;
217 return driver_register(&drv->driver);
218}
219EXPORT_SYMBOL(ibmebus_register_driver);
220
221void ibmebus_unregister_driver(struct platform_driver *drv)
222{
223 driver_unregister(&drv->driver);
224}
225EXPORT_SYMBOL(ibmebus_unregister_driver);
226
227int ibmebus_request_irq(u32 ist, irq_handler_t handler,
228 unsigned long irq_flags, const char *devname,
229 void *dev_id)
230{
231 unsigned int irq = irq_create_mapping(NULL, ist);
232
233 if (!irq)
234 return -EINVAL;
235
236 return request_irq(irq, handler, irq_flags, devname, dev_id);
237}
238EXPORT_SYMBOL(ibmebus_request_irq);
239
240void ibmebus_free_irq(u32 ist, void *dev_id)
241{
242 unsigned int irq = irq_find_mapping(NULL, ist);
243
244 free_irq(irq, dev_id);
245 irq_dispose_mapping(irq);
246}
247EXPORT_SYMBOL(ibmebus_free_irq);
248
249static char *ibmebus_chomp(const char *in, size_t count)
250{
251 char *out = kmalloc(count + 1, GFP_KERNEL);
252
253 if (!out)
254 return NULL;
255
256 memcpy(out, in, count);
257 out[count] = '\0';
258 if (out[count - 1] == '\n')
259 out[count - 1] = '\0';
260
261 return out;
262}
263
264static ssize_t ibmebus_store_probe(struct bus_type *bus,
265 const char *buf, size_t count)
266{
267 struct device_node *dn = NULL;
268 struct device *dev;
269 char *path;
270 ssize_t rc = 0;
271
272 path = ibmebus_chomp(buf, count);
273 if (!path)
274 return -ENOMEM;
275
276 dev = bus_find_device(&ibmebus_bus_type, NULL, path,
277 ibmebus_match_path);
278 if (dev) {
279 put_device(dev);
280 printk(KERN_WARNING "%s: %s has already been probed\n",
281 __func__, path);
282 rc = -EEXIST;
283 goto out;
284 }
285
286 if ((dn = of_find_node_by_path(path))) {
287 rc = ibmebus_create_device(dn);
288 of_node_put(dn);
289 } else {
290 printk(KERN_WARNING "%s: no such device node: %s\n",
291 __func__, path);
292 rc = -ENODEV;
293 }
294
295out:
296 kfree(path);
297 if (rc)
298 return rc;
299 return count;
300}
301static BUS_ATTR(probe, 0200, NULL, ibmebus_store_probe);
302
303static ssize_t ibmebus_store_remove(struct bus_type *bus,
304 const char *buf, size_t count)
305{
306 struct device *dev;
307 char *path;
308
309 path = ibmebus_chomp(buf, count);
310 if (!path)
311 return -ENOMEM;
312
313 if ((dev = bus_find_device(&ibmebus_bus_type, NULL, path,
314 ibmebus_match_path))) {
315 of_device_unregister(to_platform_device(dev));
316 put_device(dev);
317
318 kfree(path);
319 return count;
320 } else {
321 printk(KERN_WARNING "%s: %s not on the bus\n",
322 __func__, path);
323
324 kfree(path);
325 return -ENODEV;
326 }
327}
328static BUS_ATTR(remove, 0200, NULL, ibmebus_store_remove);
329
330static struct attribute *ibmbus_bus_attrs[] = {
331 &bus_attr_probe.attr,
332 &bus_attr_remove.attr,
333 NULL,
334};
335ATTRIBUTE_GROUPS(ibmbus_bus);
336
337static int ibmebus_bus_bus_match(struct device *dev, struct device_driver *drv)
338{
339 const struct of_device_id *matches = drv->of_match_table;
340
341 if (!matches)
342 return 0;
343
344 return of_match_device(matches, dev) != NULL;
345}
346
347static int ibmebus_bus_device_probe(struct device *dev)
348{
349 int error = -ENODEV;
350 struct platform_driver *drv;
351 struct platform_device *of_dev;
352
353 drv = to_platform_driver(dev->driver);
354 of_dev = to_platform_device(dev);
355
356 if (!drv->probe)
357 return error;
358
359 of_dev_get(of_dev);
360
361 if (of_driver_match_device(dev, dev->driver))
362 error = drv->probe(of_dev);
363 if (error)
364 of_dev_put(of_dev);
365
366 return error;
367}
368
369static int ibmebus_bus_device_remove(struct device *dev)
370{
371 struct platform_device *of_dev = to_platform_device(dev);
372 struct platform_driver *drv = to_platform_driver(dev->driver);
373
374 if (dev->driver && drv->remove)
375 drv->remove(of_dev);
376 return 0;
377}
378
379static void ibmebus_bus_device_shutdown(struct device *dev)
380{
381 struct platform_device *of_dev = to_platform_device(dev);
382 struct platform_driver *drv = to_platform_driver(dev->driver);
383
384 if (dev->driver && drv->shutdown)
385 drv->shutdown(of_dev);
386}
387
388
389
390
391static ssize_t devspec_show(struct device *dev,
392 struct device_attribute *attr, char *buf)
393{
394 struct platform_device *ofdev;
395
396 ofdev = to_platform_device(dev);
397 return sprintf(buf, "%pOF\n", ofdev->dev.of_node);
398}
399static DEVICE_ATTR_RO(devspec);
400
401static ssize_t name_show(struct device *dev,
402 struct device_attribute *attr, char *buf)
403{
404 struct platform_device *ofdev;
405
406 ofdev = to_platform_device(dev);
407 return sprintf(buf, "%s\n", ofdev->dev.of_node->name);
408}
409static DEVICE_ATTR_RO(name);
410
411static ssize_t modalias_show(struct device *dev,
412 struct device_attribute *attr, char *buf)
413{
414 return of_device_modalias(dev, buf, PAGE_SIZE);
415}
416static DEVICE_ATTR_RO(modalias);
417
418static struct attribute *ibmebus_bus_device_attrs[] = {
419 &dev_attr_devspec.attr,
420 &dev_attr_name.attr,
421 &dev_attr_modalias.attr,
422 NULL,
423};
424ATTRIBUTE_GROUPS(ibmebus_bus_device);
425
426struct bus_type ibmebus_bus_type = {
427 .name = "ibmebus",
428 .uevent = of_device_uevent_modalias,
429 .bus_groups = ibmbus_bus_groups,
430 .match = ibmebus_bus_bus_match,
431 .probe = ibmebus_bus_device_probe,
432 .remove = ibmebus_bus_device_remove,
433 .shutdown = ibmebus_bus_device_shutdown,
434 .dev_groups = ibmebus_bus_device_groups,
435};
436EXPORT_SYMBOL(ibmebus_bus_type);
437
438static int __init ibmebus_bus_init(void)
439{
440 int err;
441
442 printk(KERN_INFO "IBM eBus Device Driver\n");
443
444 err = bus_register(&ibmebus_bus_type);
445 if (err) {
446 printk(KERN_ERR "%s: failed to register IBM eBus.\n",
447 __func__);
448 return err;
449 }
450
451 err = device_register(&ibmebus_bus_device);
452 if (err) {
453 printk(KERN_WARNING "%s: device_register returned %i\n",
454 __func__, err);
455 bus_unregister(&ibmebus_bus_type);
456
457 return err;
458 }
459
460 err = ibmebus_create_devices(ibmebus_matches);
461 if (err) {
462 device_unregister(&ibmebus_bus_device);
463 bus_unregister(&ibmebus_bus_type);
464 return err;
465 }
466
467 return 0;
468}
469postcore_initcall(ibmebus_bus_init);
470
