1/*
2 * IBM PowerPC IBM eBus Infrastructure Support.
3 *
4 * Copyright (c) 2005 IBM Corporation
5 *  Joachim Fenkes <fenkes@de.ibm.com>
6 *  Heiko J Schick <schickhj@de.ibm.com>
7 *
8 * All rights reserved.
9 *
10 * This source code is distributed under a dual license of GPL v2.0 and OpenIB
11 * BSD.
12 *
13 * OpenIB BSD License
14 *
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions are met:
17 *
18 * Redistributions of source code must retain the above copyright notice, this
19 * list of conditions and the following disclaimer.
20 *
21 * Redistributions in binary form must reproduce the above copyright notice,
22 * this list of conditions and the following disclaimer in the documentation
23 * and/or other materials
24 * provided with the distribution.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
33 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
34 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
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-map-ops.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#include <asm/machdep.h>
51
52static struct device ibmebus_bus_device = { /* fake "parent" device */
53	.init_name = "ibmebus",
54};
55
56struct bus_type ibmebus_bus_type;
57
58/* These devices will automatically be added to the bus during init */
59static const struct of_device_id ibmebus_matches[] __initconst = {
60	{ .compatible = "IBM,lhca" },
61	{ .compatible = "IBM,lhea" },
62	{},
63};
64
65static void *ibmebus_alloc_coherent(struct device *dev,
66				    size_t size,
67				    dma_addr_t *dma_handle,
68				    gfp_t flag,
69				    unsigned long attrs)
70{
71	void *mem;
72
73	mem = kmalloc(size, flag);
74	*dma_handle = (dma_addr_t)mem;
75
76	return mem;
77}
78
79static void ibmebus_free_coherent(struct device *dev,
80				  size_t size, void *vaddr,
81				  dma_addr_t dma_handle,
82				  unsigned long attrs)
83{
84	kfree(vaddr);
85}
86
87static dma_addr_t ibmebus_map_page(struct device *dev,
88				   struct page *page,
89				   unsigned long offset,
90				   size_t size,
91				   enum dma_data_direction direction,
92				   unsigned long attrs)
93{
94	return (dma_addr_t)(page_address(page) + offset);
95}
96
97static void ibmebus_unmap_page(struct device *dev,
98			       dma_addr_t dma_addr,
99			       size_t size,
100			       enum dma_data_direction direction,
101			       unsigned long attrs)
102{
103	return;
104}
105
106static int ibmebus_map_sg(struct device *dev,
107			  struct scatterlist *sgl,
108			  int nents, enum dma_data_direction direction,
109			  unsigned long attrs)
110{
111	struct scatterlist *sg;
112	int i;
113
114	for_each_sg(sgl, sg, nents, i) {
115		sg->dma_address = (dma_addr_t) sg_virt(sg);
116		sg->dma_length = sg->length;
117	}
118
119	return nents;
120}
121
122static void ibmebus_unmap_sg(struct device *dev,
123			     struct scatterlist *sg,
124			     int nents, enum dma_data_direction direction,
125			     unsigned long attrs)
126{
127	return;
128}
129
130static int ibmebus_dma_supported(struct device *dev, u64 mask)
131{
132	return mask == DMA_BIT_MASK(64);
133}
134
135static u64 ibmebus_dma_get_required_mask(struct device *dev)
136{
137	return DMA_BIT_MASK(64);
138}
139
140static const struct dma_map_ops ibmebus_dma_ops = {
141	.alloc              = ibmebus_alloc_coherent,
142	.free               = ibmebus_free_coherent,
143	.map_sg             = ibmebus_map_sg,
144	.unmap_sg           = ibmebus_unmap_sg,
145	.dma_supported      = ibmebus_dma_supported,
146	.get_required_mask  = ibmebus_dma_get_required_mask,
147	.map_page           = ibmebus_map_page,
148	.unmap_page         = ibmebus_unmap_page,
149};
150
151static int ibmebus_match_path(struct device *dev, const void *data)
152{
153	struct device_node *dn = to_platform_device(dev)->dev.of_node;
154	return (of_find_node_by_path(data) == dn);
155}
156
157static int ibmebus_match_node(struct device *dev, const void *data)
158{
159	return to_platform_device(dev)->dev.of_node == data;
160}
161
162static int ibmebus_create_device(struct device_node *dn)
163{
164	struct platform_device *dev;
165	int ret;
166
167	dev = of_device_alloc(dn, NULL, &ibmebus_bus_device);
168	if (!dev)
169		return -ENOMEM;
170
171	dev->dev.bus = &ibmebus_bus_type;
172	dev->dev.dma_ops = &ibmebus_dma_ops;
173
174	ret = of_device_add(dev);
175	if (ret)
176		platform_device_put(dev);
177	return ret;
178}
179
180static int ibmebus_create_devices(const struct of_device_id *matches)
181{
182	struct device_node *root, *child;
183	struct device *dev;
184	int ret = 0;
185
186	root = of_find_node_by_path("/");
187
188	for_each_child_of_node(root, child) {
189		if (!of_match_node(matches, child))
190			continue;
191
192		dev = bus_find_device(&ibmebus_bus_type, NULL, child,
193				      ibmebus_match_node);
194		if (dev) {
195			put_device(dev);
196			continue;
197		}
198
199		ret = ibmebus_create_device(child);
200		if (ret) {
201			printk(KERN_ERR "%s: failed to create device (%i)",
202			       __func__, ret);
203			of_node_put(child);
204			break;
205		}
206	}
207
208	of_node_put(root);
209	return ret;
210}
211
212int ibmebus_register_driver(struct platform_driver *drv)
213{
214	/* If the driver uses devices that ibmebus doesn't know, add them */
215	ibmebus_create_devices(drv->driver.of_match_table);
216
217	drv->driver.bus = &ibmebus_bus_type;
218	return driver_register(&drv->driver);
219}
220EXPORT_SYMBOL(ibmebus_register_driver);
221
222void ibmebus_unregister_driver(struct platform_driver *drv)
223{
224	driver_unregister(&drv->driver);
225}
226EXPORT_SYMBOL(ibmebus_unregister_driver);
227
228int ibmebus_request_irq(u32 ist, irq_handler_t handler,
229			unsigned long irq_flags, const char *devname,
230			void *dev_id)
231{
232	unsigned int irq = irq_create_mapping(NULL, ist);
233
234	if (!irq)
235		return -EINVAL;
236
237	return request_irq(irq, handler, irq_flags, devname, dev_id);
238}
239EXPORT_SYMBOL(ibmebus_request_irq);
240
241void ibmebus_free_irq(u32 ist, void *dev_id)
242{
243	unsigned int irq = irq_find_mapping(NULL, ist);
244
245	free_irq(irq, dev_id);
246	irq_dispose_mapping(irq);
247}
248EXPORT_SYMBOL(ibmebus_free_irq);
249
250static char *ibmebus_chomp(const char *in, size_t count)
251{
252	char *out = kmalloc(count + 1, GFP_KERNEL);
253
254	if (!out)
255		return NULL;
256
257	memcpy(out, in, count);
258	out[count] = '\0';
259	if (out[count - 1] == '\n')
260		out[count - 1] = '\0';
261
262	return out;
263}
264
265static ssize_t probe_store(struct bus_type *bus, 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_WO(probe);
302
303static ssize_t remove_store(struct bus_type *bus, const char *buf, size_t count)
304{
305	struct device *dev;
306	char *path;
307
308	path = ibmebus_chomp(buf, count);
309	if (!path)
310		return -ENOMEM;
311
312	if ((dev = bus_find_device(&ibmebus_bus_type, NULL, path,
313				   ibmebus_match_path))) {
314		of_device_unregister(to_platform_device(dev));
315		put_device(dev);
316
317		kfree(path);
318		return count;
319	} else {
320		printk(KERN_WARNING "%s: %s not on the bus\n",
321		       __func__, path);
322
323		kfree(path);
324		return -ENODEV;
325	}
326}
327static BUS_ATTR_WO(remove);
328
329static struct attribute *ibmbus_bus_attrs[] = {
330	&bus_attr_probe.attr,
331	&bus_attr_remove.attr,
332	NULL,
333};
334ATTRIBUTE_GROUPS(ibmbus_bus);
335
336static int ibmebus_bus_bus_match(struct device *dev, struct device_driver *drv)
337{
338	const struct of_device_id *matches = drv->of_match_table;
339
340	if (!matches)
341		return 0;
342
343	return of_match_device(matches, dev) != NULL;
344}
345
346static int ibmebus_bus_device_probe(struct device *dev)
347{
348	int error = -ENODEV;
349	struct platform_driver *drv;
350	struct platform_device *of_dev;
351
352	drv = to_platform_driver(dev->driver);
353	of_dev = to_platform_device(dev);
354
355	if (!drv->probe)
356		return error;
357
358	of_dev_get(of_dev);
359
360	if (of_driver_match_device(dev, dev->driver))
361		error = drv->probe(of_dev);
362	if (error)
363		of_dev_put(of_dev);
364
365	return error;
366}
367
368static int ibmebus_bus_device_remove(struct device *dev)
369{
370	struct platform_device *of_dev = to_platform_device(dev);
371	struct platform_driver *drv = to_platform_driver(dev->driver);
372
373	if (dev->driver && drv->remove)
374		drv->remove(of_dev);
375	return 0;
376}
377
378static void ibmebus_bus_device_shutdown(struct device *dev)
379{
380	struct platform_device *of_dev = to_platform_device(dev);
381	struct platform_driver *drv = to_platform_driver(dev->driver);
382
383	if (dev->driver && drv->shutdown)
384		drv->shutdown(of_dev);
385}
386
387/*
388 * ibmebus_bus_device_attrs
389 */
390static ssize_t devspec_show(struct device *dev,
391				struct device_attribute *attr, char *buf)
392{
393	struct platform_device *ofdev;
394
395	ofdev = to_platform_device(dev);
396	return sprintf(buf, "%pOF\n", ofdev->dev.of_node);
397}
398static DEVICE_ATTR_RO(devspec);
399
400static ssize_t name_show(struct device *dev,
401				struct device_attribute *attr, char *buf)
402{
403	struct platform_device *ofdev;
404
405	ofdev = to_platform_device(dev);
406	return sprintf(buf, "%pOFn\n", ofdev->dev.of_node);
407}
408static DEVICE_ATTR_RO(name);
409
410static ssize_t modalias_show(struct device *dev,
411				struct device_attribute *attr, char *buf)
412{
413	return of_device_modalias(dev, buf, PAGE_SIZE);
414}
415static DEVICE_ATTR_RO(modalias);
416
417static struct attribute *ibmebus_bus_device_attrs[] = {
418	&dev_attr_devspec.attr,
419	&dev_attr_name.attr,
420	&dev_attr_modalias.attr,
421	NULL,
422};
423ATTRIBUTE_GROUPS(ibmebus_bus_device);
424
425struct bus_type ibmebus_bus_type = {
426	.name      = "ibmebus",
427	.uevent    = of_device_uevent_modalias,
428	.bus_groups = ibmbus_bus_groups,
429	.match     = ibmebus_bus_bus_match,
430	.probe     = ibmebus_bus_device_probe,
431	.remove    = ibmebus_bus_device_remove,
432	.shutdown  = ibmebus_bus_device_shutdown,
433	.dev_groups = ibmebus_bus_device_groups,
434};
435EXPORT_SYMBOL(ibmebus_bus_type);
436
437static int __init ibmebus_bus_init(void)
438{
439	int err;
440
441	printk(KERN_INFO "IBM eBus Device Driver\n");
442
443	err = bus_register(&ibmebus_bus_type);
444	if (err) {
445		printk(KERN_ERR "%s: failed to register IBM eBus.\n",
446		       __func__);
447		return err;
448	}
449
450	err = device_register(&ibmebus_bus_device);
451	if (err) {
452		printk(KERN_WARNING "%s: device_register returned %i\n",
453		       __func__, err);
454		put_device(&ibmebus_bus_device);
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}
469machine_postcore_initcall(pseries, ibmebus_bus_init);
470