[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / base / platform.c

/*
 * platform.c - platform 'pseudo' bus for legacy devices
 *
 * Copyright (c) 2002-3 Patrick Mochel
 * Copyright (c) 2002-3 Open Source Development Labs
 *
 * This file is released under the GPLv2
 *
 * Please see Documentation/driver-model/platform.txt for more
 * information.
 */

#include <linux/device.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/dma-mapping.h>
#include <linux/bootmem.h>
#include <linux/err.h>
#include <linux/slab.h>

#include "base.h"

struct device platform_bus = {
	.bus_id		= "platform",
};

/**
 *	platform_get_resource - get a resource for a device
 *	@dev: platform device
 *	@type: resource type
 *	@num: resource index
 */
struct resource *
platform_get_resource(struct platform_device *dev, unsigned int type,
		      unsigned int num)
{
	int i;

	for (i = 0; i < dev->num_resources; i++) {
		struct resource *r = &dev->resource[i];

		if ((r->flags & (IORESOURCE_IO|IORESOURCE_MEM|
				 IORESOURCE_IRQ|IORESOURCE_DMA))
		    == type)
			if (num-- == 0)
				return r;
	}
	return NULL;
}

/**
 *	platform_get_irq - get an IRQ for a device
 *	@dev: platform device
 *	@num: IRQ number index
 */
int platform_get_irq(struct platform_device *dev, unsigned int num)
{
	struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num);

	return r ? r->start : 0;
}

/**
 *	platform_get_resource_byname - get a resource for a device by name
 *	@dev: platform device
 *	@type: resource type
 *	@name: resource name
 */
struct resource *
platform_get_resource_byname(struct platform_device *dev, unsigned int type,
		      char *name)
{
	int i;

	for (i = 0; i < dev->num_resources; i++) {
		struct resource *r = &dev->resource[i];

		if ((r->flags & (IORESOURCE_IO|IORESOURCE_MEM|
				 IORESOURCE_IRQ|IORESOURCE_DMA)) == type)
			if (!strcmp(r->name, name))
				return r;
	}
	return NULL;
}

/**
 *	platform_get_irq - get an IRQ for a device
 *	@dev: platform device
 *	@name: IRQ name
 */
int platform_get_irq_byname(struct platform_device *dev, char *name)
{
	struct resource *r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name);

	return r ? r->start : 0;
}

/**
 *	platform_add_devices - add a numbers of platform devices
 *	@devs: array of platform devices to add
 *	@num: number of platform devices in array
 */
int platform_add_devices(struct platform_device **devs, int num)
{
	int i, ret = 0;

	for (i = 0; i < num; i++) {
		ret = platform_device_register(devs[i]);
		if (ret) {
			while (--i >= 0)
				platform_device_unregister(devs[i]);
			break;
		}
	}

	return ret;
}

/**
 *	platform_device_register - add a platform-level device
 *	@pdev:	platform device we're adding
 *
 */
int platform_device_register(struct platform_device * pdev)
{
	int i, ret = 0;

	if (!pdev)
		return -EINVAL;

	if (!pdev->dev.parent)
		pdev->dev.parent = &platform_bus;

	pdev->dev.bus = &platform_bus_type;

	if (pdev->id != -1)
		snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%u", pdev->name, pdev->id);
	else
		strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);

	for (i = 0; i < pdev->num_resources; i++) {
		struct resource *p, *r = &pdev->resource[i];

		if (r->name == NULL)
			r->name = pdev->dev.bus_id;

		p = r->parent;
		if (!p) {
			if (r->flags & IORESOURCE_MEM)
				p = &iomem_resource;
			else if (r->flags & IORESOURCE_IO)
				p = &ioport_resource;
		}

		if (p && request_resource(p, r)) {
			printk(KERN_ERR
			       "%s: failed to claim resource %d\n",
			       pdev->dev.bus_id, i);
			ret = -EBUSY;
			goto failed;
		}
	}

	pr_debug("Registering platform device '%s'. Parent at %s\n",
		 pdev->dev.bus_id, pdev->dev.parent->bus_id);

	ret = device_register(&pdev->dev);
	if (ret == 0)
		return ret;

 failed:
	while (--i >= 0)
		if (pdev->resource[i].flags & (IORESOURCE_MEM|IORESOURCE_IO))
			release_resource(&pdev->resource[i]);
	return ret;
}

/**
 *	platform_device_unregister - remove a platform-level device
 *	@pdev:	platform device we're removing
 *
 *	Note that this function will also release all memory- and port-based
 *	resources owned by the device (@dev->resource).
 */
void platform_device_unregister(struct platform_device * pdev)
{
	int i;

	if (pdev) {
		for (i = 0; i < pdev->num_resources; i++) {
			struct resource *r = &pdev->resource[i];
			if (r->flags & (IORESOURCE_MEM|IORESOURCE_IO))
				release_resource(r);
		}

		device_unregister(&pdev->dev);
	}
}

struct platform_object {
        struct platform_device pdev;
        struct resource resources[0];
};

static void platform_device_release_simple(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);

	kfree(container_of(pdev, struct platform_object, pdev));
}

/**
 *	platform_device_register_simple
 *	@name:  base name of the device we're adding
 *	@id:    instance id
 *	@res:   set of resources that needs to be allocated for the device
 *	@num:	number of resources
 *
 *	This function creates a simple platform device that requires minimal
 *	resource and memory management. Canned release function freeing
 *	memory allocated for the device allows drivers using such devices
 *	to be unloaded iwithout waiting for the last reference to the device
 *	to be dropped.
 */
struct platform_device *platform_device_register_simple(char *name, unsigned int id,
							struct resource *res, unsigned int num)
{
	struct platform_object *pobj;
	int retval;

	pobj = kzalloc(sizeof(*pobj) + sizeof(struct resource) * num, GFP_KERNEL);
	if (!pobj) {
		retval = -ENOMEM;
		goto error;
	}

	pobj->pdev.name = name;
	pobj->pdev.id = id;
	pobj->pdev.dev.release = platform_device_release_simple;

	if (num) {
		memcpy(pobj->resources, res, sizeof(struct resource) * num);
		pobj->pdev.resource = pobj->resources;
		pobj->pdev.num_resources = num;
	}

	retval = platform_device_register(&pobj->pdev);
	if (retval)
		goto error;

	return &pobj->pdev;

error:
	kfree(pobj);
	return ERR_PTR(retval);
}


/**
 *	platform_match - bind platform device to platform driver.
 *	@dev:	device.
 *	@drv:	driver.
 *
 *	Platform device IDs are assumed to be encoded like this:
 *	"<name><instance>", where <name> is a short description of the
 *	type of device, like "pci" or "floppy", and <instance> is the
 *	enumerated instance of the device, like '0' or '42'.
 *	Driver IDs are simply "<name>".
 *	So, extract the <name> from the platform_device structure,
 *	and compare it against the name of the driver. Return whether
 *	they match or not.
 */

static int platform_match(struct device * dev, struct device_driver * drv)
{
	struct platform_device *pdev = container_of(dev, struct platform_device, dev);

	return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
}

static int platform_suspend(struct device * dev, pm_message_t state)
{
	int ret = 0;

	if (dev->driver && dev->driver->suspend)
		ret = dev->driver->suspend(dev, state);

	return ret;
}

static int platform_resume(struct device * dev)
{
	int ret = 0;

	if (dev->driver && dev->driver->resume)
		ret = dev->driver->resume(dev);

	return ret;
}

struct bus_type platform_bus_type = {
	.name		= "platform",
	.match		= platform_match,
	.suspend	= platform_suspend,
	.resume		= platform_resume,
};

int __init platform_bus_init(void)
{
	device_register(&platform_bus);
	return bus_register(&platform_bus_type);
}

#ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
u64 dma_get_required_mask(struct device *dev)
{
	u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
	u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
	u64 mask;

	if (!high_totalram) {
		/* convert to mask just covering totalram */
		low_totalram = (1 << (fls(low_totalram) - 1));
		low_totalram += low_totalram - 1;
		mask = low_totalram;
	} else {
		high_totalram = (1 << (fls(high_totalram) - 1));
		high_totalram += high_totalram - 1;
		mask = (((u64)high_totalram) << 32) + 0xffffffff;
	}
	return mask & *dev->dma_mask;
}
EXPORT_SYMBOL_GPL(dma_get_required_mask);
#endif

EXPORT_SYMBOL_GPL(platform_bus);
EXPORT_SYMBOL_GPL(platform_bus_type);
EXPORT_SYMBOL_GPL(platform_add_devices);
EXPORT_SYMBOL_GPL(platform_device_register);
EXPORT_SYMBOL_GPL(platform_device_register_simple);
EXPORT_SYMBOL_GPL(platform_device_unregister);
EXPORT_SYMBOL_GPL(platform_get_irq);
EXPORT_SYMBOL_GPL(platform_get_resource);
EXPORT_SYMBOL_GPL(platform_get_irq_byname);
EXPORT_SYMBOL_GPL(platform_get_resource_byname);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* platform.c - platform 'pseudo' bus for legacy devices
	3	*
	4	* Copyright (c) 2002-3 Patrick Mochel
	5	* Copyright (c) 2002-3 Open Source Development Labs
	6	*
	7	* This file is released under the GPLv2
	8	*
	9	* Please see Documentation/driver-model/platform.txt for more
	10	* information.
	11	*/
	12
	13	#include <linux/device.h>
	14	#include <linux/module.h>
	15	#include <linux/init.h>
	16	#include <linux/dma-mapping.h>
	17	#include <linux/bootmem.h>
	18	#include <linux/err.h>
4e57b681	19	#include <linux/slab.h>
1da177e4	20
a1bdc7aa BD	21	#include "base.h"
a1bdc7aa BD	22
1da177e4 LT	23	struct device platform_bus = {
	24	.bus_id = "platform",
	25	};
	26
	27	/**
	28	* platform_get_resource - get a resource for a device
	29	* @dev: platform device
	30	* @type: resource type
	31	* @num: resource index
	32	*/
	33	struct resource *
	34	platform_get_resource(struct platform_device *dev, unsigned int type,
	35	unsigned int num)
	36	{
	37	int i;
	38
	39	for (i = 0; i < dev->num_resources; i++) {
	40	struct resource *r = &dev->resource[i];
	41
	42	if ((r->flags & (IORESOURCE_IO\|IORESOURCE_MEM\|
	43	IORESOURCE_IRQ\|IORESOURCE_DMA))
	44	== type)
	45	if (num-- == 0)
	46	return r;
	47	}
	48	return NULL;
	49	}
	50
	51	/**
	52	* platform_get_irq - get an IRQ for a device
	53	* @dev: platform device
	54	* @num: IRQ number index
	55	*/
	56	int platform_get_irq(struct platform_device *dev, unsigned int num)
	57	{
	58	struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num);
	59
	60	return r ? r->start : 0;
	61	}
	62
	63	/**
	64	* platform_get_resource_byname - get a resource for a device by name
	65	* @dev: platform device
	66	* @type: resource type
	67	* @name: resource name
	68	*/
	69	struct resource *
	70	platform_get_resource_byname(struct platform_device *dev, unsigned int type,
	71	char *name)
	72	{
	73	int i;
	74
	75	for (i = 0; i < dev->num_resources; i++) {
	76	struct resource *r = &dev->resource[i];
	77
	78	if ((r->flags & (IORESOURCE_IO\|IORESOURCE_MEM\|
	79	IORESOURCE_IRQ\|IORESOURCE_DMA)) == type)
	80	if (!strcmp(r->name, name))
	81	return r;
	82	}
	83	return NULL;
	84	}
	85
	86	/**
87	* platform_get_irq - get an IRQ for a device
88	* @dev: platform device
89	* @name: IRQ name
90	*/
91	int platform_get_irq_byname(struct platform_device dev, char name)
92	{
93	struct resource *r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name);
94
95	return r ? r->start : 0;
96	}
97
98	/**
99	* platform_add_devices - add a numbers of platform devices
100	* @devs: array of platform devices to add
101	* @num: number of platform devices in array
102	*/
103	int platform_add_devices(struct platform_device **devs, int num)
104	{
105	int i, ret = 0;
106
107	for (i = 0; i < num; i++) {
108	ret = platform_device_register(devs[i]);
109	if (ret) {
110	while (--i >= 0)
111	platform_device_unregister(devs[i]);
112	break;
113	}
114	}
115
116	return ret;
117	}
118
119	/**
120	* platform_device_register - add a platform-level device
67be2dd1	121	* @pdev: platform device we're adding
1da177e4 LT	122	*
	123	*/
	124	int platform_device_register(struct platform_device * pdev)
	125	{
	126	int i, ret = 0;
	127
	128	if (!pdev)
	129	return -EINVAL;
	130
	131	if (!pdev->dev.parent)
	132	pdev->dev.parent = &platform_bus;
	133
	134	pdev->dev.bus = &platform_bus_type;
	135
	136	if (pdev->id != -1)
	137	snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%u", pdev->name, pdev->id);
	138	else
	139	strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);
	140
	141	for (i = 0; i < pdev->num_resources; i++) {
	142	struct resource p, r = &pdev->resource[i];
	143
	144	if (r->name == NULL)
	145	r->name = pdev->dev.bus_id;
	146
	147	p = r->parent;
	148	if (!p) {
	149	if (r->flags & IORESOURCE_MEM)
	150	p = &iomem_resource;
	151	else if (r->flags & IORESOURCE_IO)
	152	p = &ioport_resource;
	153	}
	154
	155	if (p && request_resource(p, r)) {
	156	printk(KERN_ERR
	157	"%s: failed to claim resource %d\n",
	158	pdev->dev.bus_id, i);
	159	ret = -EBUSY;
	160	goto failed;
	161	}
	162	}
	163
	164	pr_debug("Registering platform device '%s'. Parent at %s\n",
	165	pdev->dev.bus_id, pdev->dev.parent->bus_id);
	166
	167	ret = device_register(&pdev->dev);
	168	if (ret == 0)
	169	return ret;
	170
	171	failed:
	172	while (--i >= 0)
	173	if (pdev->resource[i].flags & (IORESOURCE_MEM\|IORESOURCE_IO))
	174	release_resource(&pdev->resource[i]);
	175	return ret;
	176	}
	177
	178	/**
	179	* platform_device_unregister - remove a platform-level device
67be2dd1	180	* @pdev: platform device we're removing
1da177e4 LT	181	*
	182	* Note that this function will also release all memory- and port-based
	183	* resources owned by the device (@dev->resource).
	184	*/
	185	void platform_device_unregister(struct platform_device * pdev)
	186	{
	187	int i;
	188
	189	if (pdev) {
	190	for (i = 0; i < pdev->num_resources; i++) {
	191	struct resource *r = &pdev->resource[i];
	192	if (r->flags & (IORESOURCE_MEM\|IORESOURCE_IO))
	193	release_resource(r);
	194	}
	195
	196	device_unregister(&pdev->dev);
	197	}
	198	}
	199
	200	struct platform_object {
	201	struct platform_device pdev;
	202	struct resource resources[0];
	203	};
	204
	205	static void platform_device_release_simple(struct device *dev)
	206	{
	207	struct platform_device *pdev = to_platform_device(dev);
	208
	209	kfree(container_of(pdev, struct platform_object, pdev));
	210	}
	211
	212	/**
	213	* platform_device_register_simple
	214	* @name: base name of the device we're adding
	215	* @id: instance id
	216	* @res: set of resources that needs to be allocated for the device
	217	* @num: number of resources
	218	*
	219	* This function creates a simple platform device that requires minimal
	220	* resource and memory management. Canned release function freeing
	221	* memory allocated for the device allows drivers using such devices
	222	* to be unloaded iwithout waiting for the last reference to the device
	223	* to be dropped.
	224	*/
	225	struct platform_device platform_device_register_simple(char name, unsigned int id,
	226	struct resource *res, unsigned int num)
	227	{
	228	struct platform_object *pobj;
	229	int retval;
	230
4aed0644	231	pobj = kzalloc(sizeof(pobj) + sizeof(struct resource) num, GFP_KERNEL);
1da177e4 LT	232	if (!pobj) {
	233	retval = -ENOMEM;
	234	goto error;
	235	}
	236
1da177e4 LT	237	pobj->pdev.name = name;
	238	pobj->pdev.id = id;
	239	pobj->pdev.dev.release = platform_device_release_simple;
	240
	241	if (num) {
	242	memcpy(pobj->resources, res, sizeof(struct resource) * num);
	243	pobj->pdev.resource = pobj->resources;
	244	pobj->pdev.num_resources = num;
	245	}
	246
	247	retval = platform_device_register(&pobj->pdev);
	248	if (retval)
	249	goto error;
	250
	251	return &pobj->pdev;
	252
	253	error:
	254	kfree(pobj);
	255	return ERR_PTR(retval);
	256	}
	257
	258
	259	/**
	260	* platform_match - bind platform device to platform driver.
	261	* @dev: device.
	262	* @drv: driver.
	263	*
	264	* Platform device IDs are assumed to be encoded like this:
	265	* "<name><instance>", where <name> is a short description of the
	266	* type of device, like "pci" or "floppy", and <instance> is the
	267	* enumerated instance of the device, like '0' or '42'.
	268	* Driver IDs are simply "<name>".
	269	* So, extract the <name> from the platform_device structure,
	270	* and compare it against the name of the driver. Return whether
	271	* they match or not.
	272	*/
	273
	274	static int platform_match(struct device * dev, struct device_driver * drv)
	275	{
	276	struct platform_device *pdev = container_of(dev, struct platform_device, dev);
	277
	278	return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
	279	}
	280
	281	static int platform_suspend(struct device * dev, pm_message_t state)
	282	{
	283	int ret = 0;
	284
9480e307 RK	285	if (dev->driver && dev->driver->suspend)
	286	ret = dev->driver->suspend(dev, state);
	287
1da177e4 LT	288	return ret;
	289	}
	290
	291	static int platform_resume(struct device * dev)
	292	{
	293	int ret = 0;
	294
9480e307 RK	295	if (dev->driver && dev->driver->resume)
	296	ret = dev->driver->resume(dev);
	297
1da177e4 LT	298	return ret;
	299	}
	300
	301	struct bus_type platform_bus_type = {
	302	.name = "platform",
	303	.match = platform_match,
	304	.suspend = platform_suspend,
	305	.resume = platform_resume,
	306	};
	307
	308	int __init platform_bus_init(void)
	309	{
	310	device_register(&platform_bus);
	311	return bus_register(&platform_bus_type);
	312	}
	313
	314	#ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
	315	u64 dma_get_required_mask(struct device *dev)
	316	{
	317	u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
	318	u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
	319	u64 mask;
	320
	321	if (!high_totalram) {
	322	/* convert to mask just covering totalram */
	323	low_totalram = (1 << (fls(low_totalram) - 1));
	324	low_totalram += low_totalram - 1;
	325	mask = low_totalram;
	326	} else {
	327	high_totalram = (1 << (fls(high_totalram) - 1));
	328	high_totalram += high_totalram - 1;
	329	mask = (((u64)high_totalram) << 32) + 0xffffffff;
	330	}
	331	return mask & *dev->dma_mask;
	332	}
	333	EXPORT_SYMBOL_GPL(dma_get_required_mask);
	334	#endif
	335
	336	EXPORT_SYMBOL_GPL(platform_bus);
	337	EXPORT_SYMBOL_GPL(platform_bus_type);
46ea0d6c	338	EXPORT_SYMBOL_GPL(platform_add_devices);
1da177e4 LT	339	EXPORT_SYMBOL_GPL(platform_device_register);
	340	EXPORT_SYMBOL_GPL(platform_device_register_simple);
	341	EXPORT_SYMBOL_GPL(platform_device_unregister);
	342	EXPORT_SYMBOL_GPL(platform_get_irq);
	343	EXPORT_SYMBOL_GPL(platform_get_resource);
	344	EXPORT_SYMBOL_GPL(platform_get_irq_byname);
	345	EXPORT_SYMBOL_GPL(platform_get_resource_byname);