Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0d1cde23 authored by Jon Smirl's avatar Jon Smirl Committed by Grant Likely
Browse files

powerpc/i2c: Convert i2c-mpc into an of_platform driver 



Convert i2c-mpc to an of_platform driver. Utilize the code in
drivers/of-i2c.c to make i2c modules dynamically loadable by the
device tree.

Signed-off-by: default avatarJon Smirl <jonsmirl@gmail.com>
Signed-off-by: default avatarGrant Likely <grant.likely@secretlab.ca>
parent 6eb9d322

arch/powerpc/sysdev/fsl_soc.c

+0 −133
Original line number Diff line number Diff line
@@ -414,139 +414,6 @@ static int __init gfar_of_init(void) 


arch_initcall(gfar_of_init);



#ifdef CONFIG_I2C_BOARDINFO

#include <linux/i2c.h>

struct i2c_driver_device {

	char	*of_device;

	char	*i2c_type;

};



static struct i2c_driver_device i2c_devices[] __initdata = {

	{"ricoh,rs5c372a", "rs5c372a"},

	{"ricoh,rs5c372b", "rs5c372b"},

	{"ricoh,rv5c386",  "rv5c386"},

	{"ricoh,rv5c387a", "rv5c387a"},

	{"dallas,ds1307",  "ds1307"},

	{"dallas,ds1337",  "ds1337"},

	{"dallas,ds1338",  "ds1338"},

	{"dallas,ds1339",  "ds1339"},

	{"dallas,ds1340",  "ds1340"},

	{"stm,m41t00",     "m41t00"},

	{"dallas,ds1374",  "ds1374"},

	{"cirrus,cs4270",  "cs4270"},

};



static int __init of_find_i2c_driver(struct device_node *node,

				     struct i2c_board_info *info)

{

	int i;



	for (i = 0; i < ARRAY_SIZE(i2c_devices); i++) {

		if (!of_device_is_compatible(node, i2c_devices[i].of_device))

			continue;

		if (strlcpy(info->type, i2c_devices[i].i2c_type,

			    I2C_NAME_SIZE) >= I2C_NAME_SIZE)

			return -ENOMEM;

		return 0;

	}



	pr_warning("fsl_soc.c: unrecognized i2c node %s\n",

		(const char *) of_get_property(node, "compatible", NULL));



	return -ENODEV;

}



static void __init of_register_i2c_devices(struct device_node *adap_node,

					   int bus_num)

{

	struct device_node *node = NULL;



	while ((node = of_get_next_child(adap_node, node))) {

		struct i2c_board_info info = {};

		const u32 *addr;

		int len;



		addr = of_get_property(node, "reg", &len);

		if (!addr || len < sizeof(int) || *addr > (1 << 10) - 1) {

			printk(KERN_WARNING "fsl_soc.c: invalid i2c device entry\n");

			continue;

		}



		info.irq = irq_of_parse_and_map(node, 0);

		if (info.irq == NO_IRQ)

			info.irq = -1;



		if (of_find_i2c_driver(node, &info) < 0)

			continue;



		info.addr = *addr;



		i2c_register_board_info(bus_num, &info, 1);

	}

}



static int __init fsl_i2c_of_init(void)

{

	struct device_node *np;

	unsigned int i = 0;

	struct platform_device *i2c_dev;

	int ret;



	for_each_compatible_node(np, NULL, "fsl-i2c") {

		struct resource r[2];

		struct fsl_i2c_platform_data i2c_data;

		const unsigned char *flags = NULL;

		int idx;

		const u32 *iprop;



		memset(&r, 0, sizeof(r));

		memset(&i2c_data, 0, sizeof(i2c_data));



		ret = of_address_to_resource(np, 0, &r[0]);

		if (ret)

			goto err;



		of_irq_to_resource(np, 0, &r[1]);



		iprop = of_get_property(np, "cell-index", NULL);

		idx = iprop ? *iprop : i;



		i2c_dev = platform_device_register_simple("fsl-i2c", idx, r, 2);

		if (IS_ERR(i2c_dev)) {

			ret = PTR_ERR(i2c_dev);

			goto err;

		}



		i2c_data.device_flags = 0;

		flags = of_get_property(np, "dfsrr", NULL);

		if (flags)

			i2c_data.device_flags |= FSL_I2C_DEV_SEPARATE_DFSRR;



		flags = of_get_property(np, "fsl5200-clocking", NULL);

		if (flags)

			i2c_data.device_flags |= FSL_I2C_DEV_CLOCK_5200;



		ret =

		    platform_device_add_data(i2c_dev, &i2c_data,

					     sizeof(struct

						    fsl_i2c_platform_data));

		if (ret)

			goto unreg;



		of_register_i2c_devices(np, idx);

		i++;

	}



	return 0;



unreg:

	platform_device_unregister(i2c_dev);

err:

	return ret;

}



arch_initcall(fsl_i2c_of_init);

#endif



#ifdef CONFIG_PPC_83xx

static int __init mpc83xx_wdt_init(void)

drivers/i2c/busses/i2c-mpc.c

+60 −44
Original line number Diff line number Diff line
@@ -17,7 +17,8 @@ 
#include <linux/module.h>

#include <linux/sched.h>

#include <linux/init.h>

#include <linux/platform_device.h>

#include <linux/of_platform.h>

#include <linux/of_i2c.h>



#include <asm/io.h>

#include <linux/fsl_devices.h>
@@ -25,13 +26,13 @@ 
#include <linux/interrupt.h>

#include <linux/delay.h>



#define MPC_I2C_ADDR  0x00

#define DRV_NAME "mpc-i2c"



#define MPC_I2C_FDR 	0x04

#define MPC_I2C_CR	0x08

#define MPC_I2C_SR	0x0c

#define MPC_I2C_DR	0x10

#define MPC_I2C_DFSRR 0x14

#define MPC_I2C_REGION 0x20



#define CCR_MEN  0x80

#define CCR_MIEN 0x40
@@ -315,102 +316,117 @@ static struct i2c_adapter mpc_ops = { 
	.timeout = 1,

};



static int fsl_i2c_probe(struct platform_device *pdev)

static int __devinit fsl_i2c_probe(struct of_device *op, const struct of_device_id *match)

{

	int result = 0;

	struct mpc_i2c *i2c;

	struct fsl_i2c_platform_data *pdata;

	struct resource *r = platform_get_resource(pdev, IORESOURCE_MEM, 0);



	pdata = (struct fsl_i2c_platform_data *) pdev->dev.platform_data;



	i2c = kzalloc(sizeof(*i2c), GFP_KERNEL);

	if (!i2c)

		return -ENOMEM;



	i2c->irq = platform_get_irq(pdev, 0);

	if (i2c->irq < 0)

		i2c->irq = NO_IRQ; /* Use polling */

	if (of_get_property(op->node, "dfsrr", NULL))

		i2c->flags |= FSL_I2C_DEV_SEPARATE_DFSRR;



	i2c->flags = pdata->device_flags;

	init_waitqueue_head(&i2c->queue);

	if (of_device_is_compatible(op->node, "fsl,mpc5200-i2c") ||

			of_device_is_compatible(op->node, "mpc5200-i2c"))

		i2c->flags |= FSL_I2C_DEV_CLOCK_5200;



	i2c->base = ioremap((phys_addr_t)r->start, MPC_I2C_REGION);

	init_waitqueue_head(&i2c->queue);



	i2c->base = of_iomap(op->node, 0);

	if (!i2c->base) {

		printk(KERN_ERR "i2c-mpc - failed to map controller\n");

		result = -ENOMEM;

		goto fail_map;

	}



	if (i2c->irq != NO_IRQ)

		if ((result = request_irq(i2c->irq, mpc_i2c_isr,

					  IRQF_SHARED, "i2c-mpc", i2c)) < 0) {

			printk(KERN_ERR

			       "i2c-mpc - failed to attach interrupt\n");

			goto fail_irq;

	i2c->irq = irq_of_parse_and_map(op->node, 0);

	if (i2c->irq != NO_IRQ) { /* i2c->irq = NO_IRQ implies polling */

		result = request_irq(i2c->irq, mpc_i2c_isr,

				     IRQF_SHARED, "i2c-mpc", i2c);

		if (result < 0) {

			printk(KERN_ERR "i2c-mpc - failed to attach interrupt\n");

			goto fail_request;

		}

	}

	

	mpc_i2c_setclock(i2c);

	platform_set_drvdata(pdev, i2c);



	dev_set_drvdata(&op->dev, i2c);



	i2c->adap = mpc_ops;

	i2c->adap.nr = pdev->id;

	i2c_set_adapdata(&i2c->adap, i2c);

	i2c->adap.dev.parent = &pdev->dev;

	if ((result = i2c_add_numbered_adapter(&i2c->adap)) < 0) {

	i2c->adap.dev.parent = &op->dev;



	result = i2c_add_adapter(&i2c->adap);

	if (result < 0) {

		printk(KERN_ERR "i2c-mpc - failed to add adapter\n");

		goto fail_add;

	}

	of_register_i2c_devices(&i2c->adap, op->node);



	return result;



 fail_add:

	if (i2c->irq != NO_IRQ)

	dev_set_drvdata(&op->dev, NULL);

	free_irq(i2c->irq, i2c);

      fail_irq:

 fail_request:

	irq_dispose_mapping(i2c->irq);

 	iounmap(i2c->base);

 fail_map:

	kfree(i2c);

	return result;

};



static int fsl_i2c_remove(struct platform_device *pdev)

static int __devexit fsl_i2c_remove(struct of_device *op)

{

	struct mpc_i2c *i2c = platform_get_drvdata(pdev);

	struct mpc_i2c *i2c = dev_get_drvdata(&op->dev);



	i2c_del_adapter(&i2c->adap);

	platform_set_drvdata(pdev, NULL);

	dev_set_drvdata(&op->dev, NULL);



	if (i2c->irq != NO_IRQ)

		free_irq(i2c->irq, i2c);



	irq_dispose_mapping(i2c->irq);

	iounmap(i2c->base);

	kfree(i2c);

	return 0;

};



/* work with hotplug and coldplug */

MODULE_ALIAS("platform:fsl-i2c");

static const struct of_device_id mpc_i2c_of_match[] = {

	{.compatible = "fsl-i2c",},

	{},

};

MODULE_DEVICE_TABLE(of, mpc_i2c_of_match);





/* Structure for a device driver */

static struct platform_driver fsl_i2c_driver = {

static struct of_platform_driver mpc_i2c_driver = {

	.match_table	= mpc_i2c_of_match,

	.probe		= fsl_i2c_probe,

	.remove = fsl_i2c_remove,

	.remove		= __devexit_p(fsl_i2c_remove),

	.driver		= {

		.owner	= THIS_MODULE,

		.name = "fsl-i2c",

		.name	= DRV_NAME,

	},

};



static int __init fsl_i2c_init(void)

{

	return platform_driver_register(&fsl_i2c_driver);

	int rv;



	rv = of_register_platform_driver(&mpc_i2c_driver);

	if (rv)

		printk(KERN_ERR DRV_NAME 

		       " of_register_platform_driver failed (%i)\n", rv);

	return rv;

}



static void __exit fsl_i2c_exit(void)

{

	platform_driver_unregister(&fsl_i2c_driver);

	of_unregister_platform_driver(&mpc_i2c_driver);

}



module_init(fsl_i2c_init);