[deliverable/linux.git] / arch / powerpc / kernel / ibmebus.c

/*
 * IBM PowerPC IBM eBus Infrastructure Support.
 *
 * Copyright (c) 2005 IBM Corporation
 *  Joachim Fenkes <fenkes@de.ibm.com>
 *  Heiko J Schick <schickhj@de.ibm.com>
 *
 * All rights reserved.
 *
 * This source code is distributed under a dual license of GPL v2.0 and OpenIB
 * BSD.
 *
 * OpenIB BSD License
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials
 * provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/init.h>
#include <linux/console.h>
#include <linux/kobject.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <asm/ibmebus.h>
#include <asm/abs_addr.h>

#define MAX_LOC_CODE_LENGTH 80

static struct device ibmebus_bus_device = { /* fake "parent" device */
	.bus_id = "ibmebus",
};

struct bus_type ibmebus_bus_type;

static void *ibmebus_alloc_coherent(struct device *dev,
				    size_t size,
				    dma_addr_t *dma_handle,
				    gfp_t flag)
{
	void *mem;

	mem = kmalloc(size, flag);
	*dma_handle = (dma_addr_t)mem;

	return mem;
}

static void ibmebus_free_coherent(struct device *dev,
				  size_t size, void *vaddr,
				  dma_addr_t dma_handle)
{
	kfree(vaddr);
}

static dma_addr_t ibmebus_map_single(struct device *dev,
				     void *ptr,
				     size_t size,
				     enum dma_data_direction direction)
{
	return (dma_addr_t)(ptr);
}

static void ibmebus_unmap_single(struct device *dev,
				 dma_addr_t dma_addr,
				 size_t size,
				 enum dma_data_direction direction)
{
	return;
}

static int ibmebus_map_sg(struct device *dev,
			  struct scatterlist *sg,
			  int nents, enum dma_data_direction direction)
{
	int i;

	for (i = 0; i < nents; i++) {
		sg[i].dma_address = (dma_addr_t)page_address(sg[i].page)
			+ sg[i].offset;
		sg[i].dma_length = sg[i].length;
	}

	return nents;
}

static void ibmebus_unmap_sg(struct device *dev,
			     struct scatterlist *sg,
			     int nents, enum dma_data_direction direction)
{
	return;
}

static int ibmebus_dma_supported(struct device *dev, u64 mask)
{
	return 1;
}

static struct dma_mapping_ops ibmebus_dma_ops = {
	.alloc_coherent = ibmebus_alloc_coherent,
	.free_coherent  = ibmebus_free_coherent,
	.map_single     = ibmebus_map_single,
	.unmap_single   = ibmebus_unmap_single,
	.map_sg         = ibmebus_map_sg,
	.unmap_sg       = ibmebus_unmap_sg,
	.dma_supported  = ibmebus_dma_supported,
};

static int ibmebus_bus_probe(struct device *dev)
{
	struct ibmebus_dev *ibmebusdev    = to_ibmebus_dev(dev);
	struct ibmebus_driver *ibmebusdrv = to_ibmebus_driver(dev->driver);
	const struct of_device_id *id;
	int error = -ENODEV;

	if (!ibmebusdrv->probe)
		return error;

	id = of_match_device(ibmebusdrv->id_table, &ibmebusdev->ofdev);
	if (id) {
		error = ibmebusdrv->probe(ibmebusdev, id);
	}

	return error;
}

static int ibmebus_bus_remove(struct device *dev)
{
	struct ibmebus_dev *ibmebusdev    = to_ibmebus_dev(dev);
	struct ibmebus_driver *ibmebusdrv = to_ibmebus_driver(dev->driver);

	if (ibmebusdrv->remove) {
		return ibmebusdrv->remove(ibmebusdev);
	}

	return 0;
}

static void __devinit ibmebus_dev_release(struct device *dev)
{
	of_node_put(to_ibmebus_dev(dev)->ofdev.node);
	kfree(to_ibmebus_dev(dev));
}

static int __devinit ibmebus_register_device_common(
	struct ibmebus_dev *dev, const char *name)
{
	int err = 0;

	dev->ofdev.dev.parent  = &ibmebus_bus_device;
	dev->ofdev.dev.bus     = &ibmebus_bus_type;
	dev->ofdev.dev.release = ibmebus_dev_release;

	dev->ofdev.dev.archdata.of_node = dev->ofdev.node;
	dev->ofdev.dev.archdata.dma_ops = &ibmebus_dma_ops;
	dev->ofdev.dev.archdata.numa_node = of_node_to_nid(dev->ofdev.node);

	/* An ibmebusdev is based on a of_device. We have to change the
	 * bus type to use our own DMA mapping operations.
	 */
	if ((err = of_device_register(&dev->ofdev)) != 0) {
		printk(KERN_ERR "%s: failed to register device (%d).\n",
		       __FUNCTION__, err);
		return -ENODEV;
	}

	return 0;
}

static struct ibmebus_dev* __devinit ibmebus_register_device_node(
	struct device_node *dn)
{
	struct ibmebus_dev *dev;
	const char *loc_code;
	int length;

	loc_code = of_get_property(dn, "ibm,loc-code", NULL);
	if (!loc_code) {
                printk(KERN_WARNING "%s: node %s missing 'ibm,loc-code'\n",
		       __FUNCTION__, dn->name ? dn->name : "<unknown>");
		return ERR_PTR(-EINVAL);
        }

	if (strlen(loc_code) == 0) {
	        printk(KERN_WARNING "%s: 'ibm,loc-code' is invalid\n",
		       __FUNCTION__);
		return ERR_PTR(-EINVAL);
	}

	dev = kzalloc(sizeof(struct ibmebus_dev), GFP_KERNEL);
	if (!dev) {
		return ERR_PTR(-ENOMEM);
	}

	dev->ofdev.node = of_node_get(dn);

	length = strlen(loc_code);
	memcpy(dev->ofdev.dev.bus_id, loc_code
		+ (length - min(length, BUS_ID_SIZE - 1)),
		min(length, BUS_ID_SIZE - 1));

	/* Register with generic device framework. */
	if (ibmebus_register_device_common(dev, dn->name) != 0) {
		kfree(dev);
		return ERR_PTR(-ENODEV);
	}

	return dev;
}

static void ibmebus_probe_of_nodes(char* name)
{
	struct device_node *dn = NULL;

	while ((dn = of_find_node_by_name(dn, name))) {
		if (IS_ERR(ibmebus_register_device_node(dn))) {
			of_node_put(dn);
			return;
		}
	}

	of_node_put(dn);

	return;
}

static void ibmebus_add_devices_by_id(struct of_device_id *idt)
{
	while (strlen(idt->name) > 0) {
		ibmebus_probe_of_nodes(idt->name);
		idt++;
	}

	return;
}

static int ibmebus_match_helper_name(struct device *dev, void *data)
{
	const struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev);
	const char *name;

	name = of_get_property(ebus_dev->ofdev.node, "name", NULL);

	if (name && (strcmp(data, name) == 0))
		return 1;

	return 0;
}

static int ibmebus_unregister_device(struct device *dev)
{
	of_device_unregister(to_of_device(dev));

	return 0;
}

static void ibmebus_remove_devices_by_id(struct of_device_id *idt)
{
	struct device *dev;

	while (strlen(idt->name) > 0) {
		while ((dev = bus_find_device(&ibmebus_bus_type, NULL,
					      (void*)idt->name,
					      ibmebus_match_helper_name))) {
			ibmebus_unregister_device(dev);
		}
		idt++;
	}

	return;
}

int ibmebus_register_driver(struct ibmebus_driver *drv)
{
	int err = 0;

	drv->driver.name   = drv->name;
	drv->driver.bus    = &ibmebus_bus_type;
	drv->driver.probe  = ibmebus_bus_probe;
	drv->driver.remove = ibmebus_bus_remove;

	if ((err = driver_register(&drv->driver) != 0))
		return err;

	/* remove all supported devices first, in case someone
	 * probed them manually before registering the driver */
	ibmebus_remove_devices_by_id(drv->id_table);
	ibmebus_add_devices_by_id(drv->id_table);

	return 0;
}
EXPORT_SYMBOL(ibmebus_register_driver);

void ibmebus_unregister_driver(struct ibmebus_driver *drv)
{
	driver_unregister(&drv->driver);
	ibmebus_remove_devices_by_id(drv->id_table);
}
EXPORT_SYMBOL(ibmebus_unregister_driver);

int ibmebus_request_irq(struct ibmebus_dev *dev,
			u32 ist,
			irq_handler_t handler,
			unsigned long irq_flags, const char * devname,
			void *dev_id)
{
	unsigned int irq = irq_create_mapping(NULL, ist);

	if (irq == NO_IRQ)
		return -EINVAL;

	return request_irq(irq, handler,
			   irq_flags, devname, dev_id);
}
EXPORT_SYMBOL(ibmebus_request_irq);

void ibmebus_free_irq(struct ibmebus_dev *dev, u32 ist, void *dev_id)
{
	unsigned int irq = irq_find_mapping(NULL, ist);

	free_irq(irq, dev_id);
}
EXPORT_SYMBOL(ibmebus_free_irq);

static int ibmebus_bus_match(struct device *dev, struct device_driver *drv)
{
	const struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev);
	struct ibmebus_driver *ebus_drv    = to_ibmebus_driver(drv);
	const struct of_device_id *ids     = ebus_drv->id_table;
	const struct of_device_id *found_id;

	if (!ids)
		return 0;

	found_id = of_match_device(ids, &ebus_dev->ofdev);
	if (found_id)
		return 1;

	return 0;
}

static ssize_t name_show(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev);
	const char *name = of_get_property(ebus_dev->ofdev.node, "name", NULL);
	return sprintf(buf, "%s\n", name);
}

static struct device_attribute ibmebus_dev_attrs[] = {
	__ATTR_RO(name),
	__ATTR_NULL
};

static int ibmebus_match_helper_loc_code(struct device *dev, void *data)
{
	const struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev);
	const char *loc_code;

	loc_code = of_get_property(ebus_dev->ofdev.node, "ibm,loc-code", NULL);

	if (loc_code && (strcmp(data, loc_code) == 0))
		return 1;

	return 0;
}

static ssize_t ibmebus_store_probe(struct bus_type *bus,
				   const char *buf, size_t count)
{
	struct device_node *dn = NULL;
	struct ibmebus_dev *dev;
	const char *loc_code;
	char parm[MAX_LOC_CODE_LENGTH];

	if (count >= MAX_LOC_CODE_LENGTH)
		return -EINVAL;
	memcpy(parm, buf, count);
	parm[count] = '\0';
	if (parm[count-1] == '\n')
		parm[count-1] = '\0';

	if (bus_find_device(&ibmebus_bus_type, NULL, parm,
			     ibmebus_match_helper_loc_code)) {
		printk(KERN_WARNING "%s: loc_code %s has already been probed\n",
		       __FUNCTION__, parm);
		return -EINVAL;
	}

	while ((dn = of_find_all_nodes(dn))) {
		loc_code = of_get_property(dn, "ibm,loc-code", NULL);
		if (loc_code && (strncmp(loc_code, parm, count) == 0)) {
			dev = ibmebus_register_device_node(dn);
			if (IS_ERR(dev)) {
				of_node_put(dn);
				return PTR_ERR(dev);
			} else
				return count; /* success */
		}
	}

	/* if we drop out of the loop, the loc code was invalid */
	printk(KERN_WARNING "%s: no device with loc_code %s found\n",
	       __FUNCTION__, parm);
	return -ENODEV;
}

static ssize_t ibmebus_store_remove(struct bus_type *bus,
				    const char *buf, size_t count)
{
	struct device *dev;
	char parm[MAX_LOC_CODE_LENGTH];

	if (count >= MAX_LOC_CODE_LENGTH)
		return -EINVAL;
	memcpy(parm, buf, count);
	parm[count] = '\0';
	if (parm[count-1] == '\n')
		parm[count-1] = '\0';

	/* The location code is unique, so we will find one device at most */
	if ((dev = bus_find_device(&ibmebus_bus_type, NULL, parm,
				   ibmebus_match_helper_loc_code))) {
		ibmebus_unregister_device(dev);
	} else {
		printk(KERN_WARNING "%s: loc_code %s not on the bus\n",
		       __FUNCTION__, parm);
		return -ENODEV;
	}

	return count;
}

static struct bus_attribute ibmebus_bus_attrs[] = {
	__ATTR(probe, S_IWUSR, NULL, ibmebus_store_probe),
	__ATTR(remove, S_IWUSR, NULL, ibmebus_store_remove),
	__ATTR_NULL
};

struct bus_type ibmebus_bus_type = {
	.name      = "ibmebus",
	.match     = ibmebus_bus_match,
	.dev_attrs = ibmebus_dev_attrs,
	.bus_attrs = ibmebus_bus_attrs
};
EXPORT_SYMBOL(ibmebus_bus_type);

static int __init ibmebus_bus_init(void)
{
	int err;

	printk(KERN_INFO "IBM eBus Device Driver\n");

	err = bus_register(&ibmebus_bus_type);
	if (err) {
		printk(KERN_ERR ":%s: failed to register IBM eBus.\n",
		       __FUNCTION__);
		return err;
	}

	err = device_register(&ibmebus_bus_device);
	if (err) {
		printk(KERN_WARNING "%s: device_register returned %i\n",
		       __FUNCTION__, err);
		bus_unregister(&ibmebus_bus_type);

		return err;
	}

	return 0;
}
__initcall(ibmebus_bus_init);
Commit	Line	Data
d7a30103 HS	1	/*
	2	* IBM PowerPC IBM eBus Infrastructure Support.
	3	*
	4	* Copyright (c) 2005 IBM Corporation
6bccf755	5	* Joachim Fenkes <fenkes@de.ibm.com>
d7a30103	6	* Heiko J Schick <schickhj@de.ibm.com>
a8308800	7	*
d7a30103 HS	8	* All rights reserved.
d7a30103 HS	9	*
a8308800 JF	10	* This source code is distributed under a dual license of GPL v2.0 and OpenIB
a8308800 JF	11	* BSD.
d7a30103 HS	12	*
	13	* OpenIB BSD License
	14	*
a8308800 JF	15	* Redistribution and use in source and binary forms, with or without
a8308800 JF	16	* modification, are permitted provided that the following conditions are met:
d7a30103	17	*
a8308800 JF	18	* Redistributions of source code must retain the above copyright notice, this
a8308800 JF	19	* list of conditions and the following disclaimer.
d7a30103	20	*
a8308800 JF	21	* Redistributions in binary form must reproduce the above copyright notice,
a8308800 JF	22	* this list of conditions and the following disclaimer in the documentation
d7a30103	23	* and/or other materials
a8308800	24	* provided with the distribution.
d7a30103	25	*
a8308800 JF	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
d7a30103 HS	32	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
d7a30103 HS	33	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
a8308800 JF	34	* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
a8308800 JF	35	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
d7a30103 HS	36	* POSSIBILITY OF SUCH DAMAGE.
	37	*/
	38
	39	#include <linux/init.h>
	40	#include <linux/console.h>
	41	#include <linux/kobject.h>
	42	#include <linux/dma-mapping.h>
	43	#include <linux/interrupt.h>
	44	#include <asm/ibmebus.h>
	45	#include <asm/abs_addr.h>
	46
6bccf755 JF	47	#define MAX_LOC_CODE_LENGTH 80
	48
	49	static struct device ibmebus_bus_device = { /* fake "parent" device */
	50	.bus_id = "ibmebus",
d7a30103 HS	51	};
d7a30103 HS	52
6bccf755 JF	53	struct bus_type ibmebus_bus_type;
6bccf755 JF	54
d7a30103 HS	55	static void ibmebus_alloc_coherent(struct device dev,
	56	size_t size,
	57	dma_addr_t *dma_handle,
	58	gfp_t flag)
	59	{
	60	void *mem;
a8308800	61
d7a30103 HS	62	mem = kmalloc(size, flag);
	63	*dma_handle = (dma_addr_t)mem;
	64
	65	return mem;
	66	}
	67
	68	static void ibmebus_free_coherent(struct device *dev,
a8308800	69	size_t size, void *vaddr,
d7a30103 HS	70	dma_addr_t dma_handle)
	71	{
	72	kfree(vaddr);
	73	}
	74
	75	static dma_addr_t ibmebus_map_single(struct device *dev,
	76	void *ptr,
	77	size_t size,
	78	enum dma_data_direction direction)
	79	{
	80	return (dma_addr_t)(ptr);
	81	}
	82
	83	static void ibmebus_unmap_single(struct device *dev,
	84	dma_addr_t dma_addr,
a8308800	85	size_t size,
d7a30103 HS	86	enum dma_data_direction direction)
	87	{
	88	return;
	89	}
	90
	91	static int ibmebus_map_sg(struct device *dev,
	92	struct scatterlist *sg,
	93	int nents, enum dma_data_direction direction)
	94	{
	95	int i;
a8308800	96
d7a30103	97	for (i = 0; i < nents; i++) {
a8308800	98	sg[i].dma_address = (dma_addr_t)page_address(sg[i].page)
d7a30103 HS	99	+ sg[i].offset;
	100	sg[i].dma_length = sg[i].length;
	101	}
a8308800	102
d7a30103 HS	103	return nents;
	104	}
	105
	106	static void ibmebus_unmap_sg(struct device *dev,
	107	struct scatterlist *sg,
	108	int nents, enum dma_data_direction direction)
	109	{
	110	return;
	111	}
	112
	113	static int ibmebus_dma_supported(struct device *dev, u64 mask)
	114	{
	115	return 1;
	116	}
	117
12d04eef	118	static struct dma_mapping_ops ibmebus_dma_ops = {
d7a30103 HS	119	.alloc_coherent = ibmebus_alloc_coherent,
	120	.free_coherent = ibmebus_free_coherent,
	121	.map_single = ibmebus_map_single,
	122	.unmap_single = ibmebus_unmap_single,
	123	.map_sg = ibmebus_map_sg,
	124	.unmap_sg = ibmebus_unmap_sg,
	125	.dma_supported = ibmebus_dma_supported,
	126	};
	127
	128	static int ibmebus_bus_probe(struct device *dev)
	129	{
	130	struct ibmebus_dev *ibmebusdev = to_ibmebus_dev(dev);
	131	struct ibmebus_driver *ibmebusdrv = to_ibmebus_driver(dev->driver);
	132	const struct of_device_id *id;
	133	int error = -ENODEV;
a8308800	134
d7a30103 HS	135	if (!ibmebusdrv->probe)
d7a30103 HS	136	return error;
a8308800	137
d7a30103 HS	138	id = of_match_device(ibmebusdrv->id_table, &ibmebusdev->ofdev);
	139	if (id) {
	140	error = ibmebusdrv->probe(ibmebusdev, id);
	141	}
a8308800	142
d7a30103 HS	143	return error;
	144	}
	145
	146	static int ibmebus_bus_remove(struct device *dev)
	147	{
	148	struct ibmebus_dev *ibmebusdev = to_ibmebus_dev(dev);
	149	struct ibmebus_driver *ibmebusdrv = to_ibmebus_driver(dev->driver);
a8308800	150
d7a30103 HS	151	if (ibmebusdrv->remove) {
	152	return ibmebusdrv->remove(ibmebusdev);
	153	}
a8308800	154
d7a30103 HS	155	return 0;
	156	}
	157
	158	static void __devinit ibmebus_dev_release(struct device *dev)
	159	{
	160	of_node_put(to_ibmebus_dev(dev)->ofdev.node);
	161	kfree(to_ibmebus_dev(dev));
	162	}
	163
6bccf755	164	static int __devinit ibmebus_register_device_common(
a7f67bdf	165	struct ibmebus_dev dev, const char name)
d7a30103 HS	166	{
	167	int err = 0;
	168
6bccf755	169	dev->ofdev.dev.parent = &ibmebus_bus_device;
d7a30103 HS	170	dev->ofdev.dev.bus = &ibmebus_bus_type;
	171	dev->ofdev.dev.release = ibmebus_dev_release;
	172
12d04eef BH	173	dev->ofdev.dev.archdata.of_node = dev->ofdev.node;
	174	dev->ofdev.dev.archdata.dma_ops = &ibmebus_dma_ops;
	175	dev->ofdev.dev.archdata.numa_node = of_node_to_nid(dev->ofdev.node);
	176
d7a30103	177	/* An ibmebusdev is based on a of_device. We have to change the
a8308800 JF	178	* bus type to use our own DMA mapping operations.
a8308800 JF	179	*/
d7a30103 HS	180	if ((err = of_device_register(&dev->ofdev)) != 0) {
	181	printk(KERN_ERR "%s: failed to register device (%d).\n",
	182	__FUNCTION__, err);
6bccf755	183	return -ENODEV;
d7a30103	184	}
a8308800	185
6bccf755	186	return 0;
d7a30103 HS	187	}
	188
	189	static struct ibmebus_dev* __devinit ibmebus_register_device_node(
	190	struct device_node *dn)
	191	{
	192	struct ibmebus_dev *dev;
a7f67bdf	193	const char *loc_code;
d7a30103 HS	194	int length;
d7a30103 HS	195
e2eb6392	196	loc_code = of_get_property(dn, "ibm,loc-code", NULL);
d7a30103 HS	197	if (!loc_code) {
	198	printk(KERN_WARNING "%s: node %s missing 'ibm,loc-code'\n",
	199	__FUNCTION__, dn->name ? dn->name : "<unknown>");
6bccf755	200	return ERR_PTR(-EINVAL);
d7a30103	201	}
a8308800	202
d7a30103 HS	203	if (strlen(loc_code) == 0) {
	204	printk(KERN_WARNING "%s: 'ibm,loc-code' is invalid\n",
	205	__FUNCTION__);
6bccf755	206	return ERR_PTR(-EINVAL);
d7a30103 HS	207	}
d7a30103 HS	208
f8485350	209	dev = kzalloc(sizeof(struct ibmebus_dev), GFP_KERNEL);
d7a30103	210	if (!dev) {
6bccf755	211	return ERR_PTR(-ENOMEM);
d7a30103	212	}
d7a30103 HS	213
d7a30103 HS	214	dev->ofdev.node = of_node_get(dn);
a8308800	215
d7a30103	216	length = strlen(loc_code);
a8308800 JF	217	memcpy(dev->ofdev.dev.bus_id, loc_code
a8308800 JF	218	+ (length - min(length, BUS_ID_SIZE - 1)),
d7a30103 HS	219	min(length, BUS_ID_SIZE - 1));
	220
	221	/* Register with generic device framework. */
6bccf755	222	if (ibmebus_register_device_common(dev, dn->name) != 0) {
d7a30103	223	kfree(dev);
6bccf755	224	return ERR_PTR(-ENODEV);
d7a30103 HS	225	}
	226
	227	return dev;
	228	}
	229
	230	static void ibmebus_probe_of_nodes(char* name)
	231	{
	232	struct device_node *dn = NULL;
a8308800	233
d7a30103	234	while ((dn = of_find_node_by_name(dn, name))) {
6bccf755	235	if (IS_ERR(ibmebus_register_device_node(dn))) {
d7a30103	236	of_node_put(dn);
d7a30103 HS	237	return;
	238	}
	239	}
a8308800	240
d7a30103	241	of_node_put(dn);
a8308800	242
d7a30103 HS	243	return;
	244	}
	245
	246	static void ibmebus_add_devices_by_id(struct of_device_id *idt)
	247	{
	248	while (strlen(idt->name) > 0) {
	249	ibmebus_probe_of_nodes(idt->name);
	250	idt++;
	251	}
	252
	253	return;
	254	}
	255
6bccf755	256	static int ibmebus_match_helper_name(struct device dev, void data)
d7a30103	257	{
6bccf755	258	const struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev);
e2eb6392	259	const char *name;
6bccf755	260
e2eb6392	261	name = of_get_property(ebus_dev->ofdev.node, "name", NULL);
6bccf755	262
e2eb6392	263	if (name && (strcmp(data, name) == 0))
d7a30103	264	return 1;
a8308800	265
d7a30103 HS	266	return 0;
	267	}
	268
	269	static int ibmebus_unregister_device(struct device *dev)
	270	{
d7a30103 HS	271	of_device_unregister(to_of_device(dev));
	272
	273	return 0;
	274	}
	275
	276	static void ibmebus_remove_devices_by_id(struct of_device_id *idt)
	277	{
	278	struct device *dev;
a8308800	279
d7a30103	280	while (strlen(idt->name) > 0) {
a8308800	281	while ((dev = bus_find_device(&ibmebus_bus_type, NULL,
d7a30103	282	(void*)idt->name,
6bccf755	283	ibmebus_match_helper_name))) {
d7a30103 HS	284	ibmebus_unregister_device(dev);
	285	}
	286	idt++;
d7a30103	287	}
a8308800	288
d7a30103 HS	289	return;
	290	}
	291
	292	int ibmebus_register_driver(struct ibmebus_driver *drv)
	293	{
	294	int err = 0;
	295
	296	drv->driver.name = drv->name;
	297	drv->driver.bus = &ibmebus_bus_type;
	298	drv->driver.probe = ibmebus_bus_probe;
	299	drv->driver.remove = ibmebus_bus_remove;
	300
	301	if ((err = driver_register(&drv->driver) != 0))
	302	return err;
	303
6bccf755 JF	304	/* remove all supported devices first, in case someone
	305	* probed them manually before registering the driver */
	306	ibmebus_remove_devices_by_id(drv->id_table);
d7a30103	307	ibmebus_add_devices_by_id(drv->id_table);
a8308800	308
d7a30103 HS	309	return 0;
	310	}
	311	EXPORT_SYMBOL(ibmebus_register_driver);
	312
	313	void ibmebus_unregister_driver(struct ibmebus_driver *drv)
a8308800	314	{
d7a30103 HS	315	driver_unregister(&drv->driver);
	316	ibmebus_remove_devices_by_id(drv->id_table);
	317	}
	318	EXPORT_SYMBOL(ibmebus_unregister_driver);
	319
	320	int ibmebus_request_irq(struct ibmebus_dev *dev,
a8308800	321	u32 ist,
40220c1a	322	irq_handler_t handler,
d7a30103 HS	323	unsigned long irq_flags, const char * devname,
	324	void *dev_id)
	325	{
6e99e458	326	unsigned int irq = irq_create_mapping(NULL, ist);
a8308800	327
d7a30103 HS	328	if (irq == NO_IRQ)
d7a30103 HS	329	return -EINVAL;
a8308800	330
d7a30103 HS	331	return request_irq(irq, handler,
	332	irq_flags, devname, dev_id);
	333	}
	334	EXPORT_SYMBOL(ibmebus_request_irq);
	335
	336	void ibmebus_free_irq(struct ibmebus_dev dev, u32 ist, void dev_id)
	337	{
0ebfff14	338	unsigned int irq = irq_find_mapping(NULL, ist);
a8308800	339
d7a30103	340	free_irq(irq, dev_id);
d7a30103 HS	341	}
	342	EXPORT_SYMBOL(ibmebus_free_irq);
	343
	344	static int ibmebus_bus_match(struct device dev, struct device_driver drv)
a8308800	345	{
d7a30103 HS	346	const struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev);
	347	struct ibmebus_driver *ebus_drv = to_ibmebus_driver(drv);
	348	const struct of_device_id *ids = ebus_drv->id_table;
	349	const struct of_device_id *found_id;
a8308800	350
d7a30103 HS	351	if (!ids)
d7a30103 HS	352	return 0;
a8308800	353
d7a30103 HS	354	found_id = of_match_device(ids, &ebus_dev->ofdev);
	355	if (found_id)
	356	return 1;
a8308800	357
d7a30103 HS	358	return 0;
	359	}
	360
6bccf755 JF	361	static ssize_t name_show(struct device *dev,
	362	struct device_attribute attr, char buf)
	363	{
	364	struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev);
e2eb6392	365	const char *name = of_get_property(ebus_dev->ofdev.node, "name", NULL);
6bccf755 JF	366	return sprintf(buf, "%s\n", name);
	367	}
	368
	369	static struct device_attribute ibmebus_dev_attrs[] = {
	370	__ATTR_RO(name),
	371	__ATTR_NULL
	372	};
	373
	374	static int ibmebus_match_helper_loc_code(struct device dev, void data)
	375	{
	376	const struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev);
e2eb6392	377	const char *loc_code;
6bccf755	378
e2eb6392	379	loc_code = of_get_property(ebus_dev->ofdev.node, "ibm,loc-code", NULL);
6bccf755	380
e2eb6392	381	if (loc_code && (strcmp(data, loc_code) == 0))
6bccf755 JF	382	return 1;
	383
	384	return 0;
	385	}
	386
	387	static ssize_t ibmebus_store_probe(struct bus_type *bus,
	388	const char *buf, size_t count)
	389	{
	390	struct device_node *dn = NULL;
	391	struct ibmebus_dev *dev;
e2eb6392	392	const char *loc_code;
6bccf755 JF	393	char parm[MAX_LOC_CODE_LENGTH];
	394
	395	if (count >= MAX_LOC_CODE_LENGTH)
	396	return -EINVAL;
	397	memcpy(parm, buf, count);
	398	parm[count] = '\0';
	399	if (parm[count-1] == '\n')
	400	parm[count-1] = '\0';
	401
	402	if (bus_find_device(&ibmebus_bus_type, NULL, parm,
	403	ibmebus_match_helper_loc_code)) {
	404	printk(KERN_WARNING "%s: loc_code %s has already been probed\n",
	405	__FUNCTION__, parm);
	406	return -EINVAL;
	407	}
	408
	409	while ((dn = of_find_all_nodes(dn))) {
e2eb6392	410	loc_code = of_get_property(dn, "ibm,loc-code", NULL);
6bccf755 JF	411	if (loc_code && (strncmp(loc_code, parm, count) == 0)) {
	412	dev = ibmebus_register_device_node(dn);
	413	if (IS_ERR(dev)) {
	414	of_node_put(dn);
	415	return PTR_ERR(dev);
	416	} else
	417	return count; /* success */
	418	}
	419	}
	420
	421	/* if we drop out of the loop, the loc code was invalid */
	422	printk(KERN_WARNING "%s: no device with loc_code %s found\n",
	423	__FUNCTION__, parm);
	424	return -ENODEV;
	425	}
	426
	427	static ssize_t ibmebus_store_remove(struct bus_type *bus,
	428	const char *buf, size_t count)
	429	{
	430	struct device *dev;
	431	char parm[MAX_LOC_CODE_LENGTH];
	432
	433	if (count >= MAX_LOC_CODE_LENGTH)
	434	return -EINVAL;
	435	memcpy(parm, buf, count);
	436	parm[count] = '\0';
	437	if (parm[count-1] == '\n')
	438	parm[count-1] = '\0';
	439
	440	/* The location code is unique, so we will find one device at most */
	441	if ((dev = bus_find_device(&ibmebus_bus_type, NULL, parm,
	442	ibmebus_match_helper_loc_code))) {
	443	ibmebus_unregister_device(dev);
	444	} else {
	445	printk(KERN_WARNING "%s: loc_code %s not on the bus\n",
	446	__FUNCTION__, parm);
	447	return -ENODEV;
	448	}
	449
	450	return count;
	451	}
	452
	453	static struct bus_attribute ibmebus_bus_attrs[] = {
	454	__ATTR(probe, S_IWUSR, NULL, ibmebus_store_probe),
	455	__ATTR(remove, S_IWUSR, NULL, ibmebus_store_remove),
	456	__ATTR_NULL
	457	};
	458
d7a30103	459	struct bus_type ibmebus_bus_type = {
6bccf755 JF	460	.name = "ibmebus",
	461	.match = ibmebus_bus_match,
	462	.dev_attrs = ibmebus_dev_attrs,
	463	.bus_attrs = ibmebus_bus_attrs
d7a30103 HS	464	};
	465	EXPORT_SYMBOL(ibmebus_bus_type);
	466
	467	static int __init ibmebus_bus_init(void)
	468	{
	469	int err;
a8308800	470
d7a30103	471	printk(KERN_INFO "IBM eBus Device Driver\n");
a8308800	472
d7a30103 HS	473	err = bus_register(&ibmebus_bus_type);
	474	if (err) {
	475	printk(KERN_ERR ":%s: failed to register IBM eBus.\n",
	476	__FUNCTION__);
	477	return err;
	478	}
a8308800	479
6bccf755	480	err = device_register(&ibmebus_bus_device);
d7a30103	481	if (err) {
a8308800	482	printk(KERN_WARNING "%s: device_register returned %i\n",
d7a30103 HS	483	__FUNCTION__, err);
	484	bus_unregister(&ibmebus_bus_type);
	485
	486	return err;
	487	}
a8308800	488
d7a30103 HS	489	return 0;
	490	}
	491	__initcall(ibmebus_bus_init);