[GitHub/exynos8895/android_kernel_samsung_universal8895.git] / drivers / i2c / busses / i2c-parport.c

/* ------------------------------------------------------------------------ *
 * i2c-parport.c I2C bus over parallel port                                 *
 * ------------------------------------------------------------------------ *
   Copyright (C) 2003-2011 Jean Delvare <jdelvare@suse.de>

   Based on older i2c-philips-par.c driver
   Copyright (C) 1995-2000 Simon G. Vogl
   With some changes from:
   Frodo Looijaard <frodol@dds.nl>
   Kyösti Mälkki <kmalkki@cc.hut.fi>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 * ------------------------------------------------------------------------ */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/parport.h>
#include <linux/i2c.h>
#include <linux/i2c-algo-bit.h>
#include <linux/i2c-smbus.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include "i2c-parport.h"

/* ----- Device list ------------------------------------------------------ */

struct i2c_par {
	struct pardevice *pdev;
	struct i2c_adapter adapter;
	struct i2c_algo_bit_data algo_data;
	struct i2c_smbus_alert_setup alert_data;
	struct i2c_client *ara;
	struct list_head node;
};

static LIST_HEAD(adapter_list);
static DEFINE_MUTEX(adapter_list_lock);

/* ----- Low-level parallel port access ----------------------------------- */

static void port_write_data(struct parport *p, unsigned char d)
{
	parport_write_data(p, d);
}

static void port_write_control(struct parport *p, unsigned char d)
{
	parport_write_control(p, d);
}

static unsigned char port_read_data(struct parport *p)
{
	return parport_read_data(p);
}

static unsigned char port_read_status(struct parport *p)
{
	return parport_read_status(p);
}

static unsigned char port_read_control(struct parport *p)
{
	return parport_read_control(p);
}

static void (* const port_write[])(struct parport *, unsigned char) = {
	port_write_data,
	NULL,
	port_write_control,
};

static unsigned char (* const port_read[])(struct parport *) = {
	port_read_data,
	port_read_status,
	port_read_control,
};

/* ----- Unified line operation functions --------------------------------- */

static inline void line_set(struct parport *data, int state,
	const struct lineop *op)
{
	u8 oldval = port_read[op->port](data);

	/* Touch only the bit(s) needed */
	if ((op->inverted && !state) || (!op->inverted && state))
		port_write[op->port](data, oldval | op->val);
	else
		port_write[op->port](data, oldval & ~op->val);
}

static inline int line_get(struct parport *data,
	const struct lineop *op)
{
	u8 oldval = port_read[op->port](data);

	return ((op->inverted && (oldval & op->val) != op->val)
	    || (!op->inverted && (oldval & op->val) == op->val));
}

/* ----- I2C algorithm call-back functions and structures ----------------- */

static void parport_setscl(void *data, int state)
{
	line_set((struct parport *) data, state, &adapter_parm[type].setscl);
}

static void parport_setsda(void *data, int state)
{
	line_set((struct parport *) data, state, &adapter_parm[type].setsda);
}

static int parport_getscl(void *data)
{
	return line_get((struct parport *) data, &adapter_parm[type].getscl);
}

static int parport_getsda(void *data)
{
	return line_get((struct parport *) data, &adapter_parm[type].getsda);
}

/* Encapsulate the functions above in the correct structure.
   Note that this is only a template, from which the real structures are
   copied. The attaching code will set getscl to NULL for adapters that
   cannot read SCL back, and will also make the data field point to
   the parallel port structure. */
static const struct i2c_algo_bit_data parport_algo_data = {
	.setsda		= parport_setsda,
	.setscl		= parport_setscl,
	.getsda		= parport_getsda,
	.getscl		= parport_getscl,
	.udelay		= 10, /* ~50 kbps */
	.timeout	= HZ,
};

/* ----- I2c and parallel port call-back functions and structures --------- */

static void i2c_parport_irq(void *data)
{
	struct i2c_par *adapter = data;
	struct i2c_client *ara = adapter->ara;

	if (ara) {
		dev_dbg(&ara->dev, "SMBus alert received\n");
		i2c_handle_smbus_alert(ara);
	} else
		dev_dbg(&adapter->adapter.dev,
			"SMBus alert received but no ARA client!\n");
}

static void i2c_parport_attach(struct parport *port)
{
	struct i2c_par *adapter;

	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
	if (adapter == NULL) {
		printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
		return;
	}

	pr_debug("i2c-parport: attaching to %s\n", port->name);
	parport_disable_irq(port);
	adapter->pdev = parport_register_device(port, "i2c-parport",
		NULL, NULL, i2c_parport_irq, PARPORT_FLAG_EXCL, adapter);
	if (!adapter->pdev) {
		printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
		goto err_free;
	}

	/* Fill the rest of the structure */
	adapter->adapter.owner = THIS_MODULE;
	adapter->adapter.class = I2C_CLASS_HWMON;
	strlcpy(adapter->adapter.name, "Parallel port adapter",
		sizeof(adapter->adapter.name));
	adapter->algo_data = parport_algo_data;
	/* Slow down if we can't sense SCL */
	if (!adapter_parm[type].getscl.val) {
		adapter->algo_data.getscl = NULL;
		adapter->algo_data.udelay = 50; /* ~10 kbps */
	}
	adapter->algo_data.data = port;
	adapter->adapter.algo_data = &adapter->algo_data;
	adapter->adapter.dev.parent = port->physport->dev;

	if (parport_claim_or_block(adapter->pdev) < 0) {
		printk(KERN_ERR "i2c-parport: Could not claim parallel port\n");
		goto err_unregister;
	}

	/* Reset hardware to a sane state (SCL and SDA high) */
	parport_setsda(port, 1);
	parport_setscl(port, 1);
	/* Other init if needed (power on...) */
	if (adapter_parm[type].init.val) {
		line_set(port, 1, &adapter_parm[type].init);
		/* Give powered devices some time to settle */
		msleep(100);
	}

	if (i2c_bit_add_bus(&adapter->adapter) < 0) {
		printk(KERN_ERR "i2c-parport: Unable to register with I2C\n");
		goto err_unregister;
	}

	/* Setup SMBus alert if supported */
	if (adapter_parm[type].smbus_alert) {
		adapter->alert_data.alert_edge_triggered = 1;
		adapter->ara = i2c_setup_smbus_alert(&adapter->adapter,
						     &adapter->alert_data);
		if (adapter->ara)
			parport_enable_irq(port);
		else
			printk(KERN_WARNING "i2c-parport: Failed to register "
			       "ARA client\n");
	}

	/* Add the new adapter to the list */
	mutex_lock(&adapter_list_lock);
	list_add_tail(&adapter->node, &adapter_list);
	mutex_unlock(&adapter_list_lock);
	return;

 err_unregister:
	parport_release(adapter->pdev);
	parport_unregister_device(adapter->pdev);
 err_free:
	kfree(adapter);
}

static void i2c_parport_detach(struct parport *port)
{
	struct i2c_par *adapter, *_n;

	/* Walk the list */
	mutex_lock(&adapter_list_lock);
	list_for_each_entry_safe(adapter, _n, &adapter_list, node) {
		if (adapter->pdev->port == port) {
			if (adapter->ara) {
				parport_disable_irq(port);
				i2c_unregister_device(adapter->ara);
			}
			i2c_del_adapter(&adapter->adapter);

			/* Un-init if needed (power off...) */
			if (adapter_parm[type].init.val)
				line_set(port, 0, &adapter_parm[type].init);

			parport_release(adapter->pdev);
			parport_unregister_device(adapter->pdev);
			list_del(&adapter->node);
			kfree(adapter);
		}
	}
	mutex_unlock(&adapter_list_lock);
}

static struct parport_driver i2c_parport_driver = {
	.name	= "i2c-parport",
	.attach	= i2c_parport_attach,
	.detach	= i2c_parport_detach,
};

/* ----- Module loading, unloading and information ------------------------ */

static int __init i2c_parport_init(void)
{
	if (type < 0) {
		printk(KERN_WARNING "i2c-parport: adapter type unspecified\n");
		return -ENODEV;
	}

	if (type >= ARRAY_SIZE(adapter_parm)) {
		printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
		return -ENODEV;
	}

	return parport_register_driver(&i2c_parport_driver);
}

static void __exit i2c_parport_exit(void)
{
	parport_unregister_driver(&i2c_parport_driver);
}

MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
MODULE_DESCRIPTION("I2C bus over parallel port");
MODULE_LICENSE("GPL");

module_init(i2c_parport_init);
module_exit(i2c_parport_exit);
Commit	Line	Data
1da177e4 LT	1	/* ------------------------------------------------------------------------ *
	2	* i2c-parport.c I2C bus over parallel port *
	3	* ------------------------------------------------------------------------ *
7c81c60f	4	Copyright (C) 2003-2011 Jean Delvare <jdelvare@suse.de>
07da0372	5
1da177e4 LT	6	Based on older i2c-philips-par.c driver
	7	Copyright (C) 1995-2000 Simon G. Vogl
	8	With some changes from:
	9	Frodo Looijaard <frodol@dds.nl>
96de0e25	10	Kyösti Mälkki <kmalkki@cc.hut.fi>
07da0372	11
1da177e4 LT	12	This program is free software; you can redistribute it and/or modify
	13	it under the terms of the GNU General Public License as published by
	14	the Free Software Foundation; either version 2 of the License, or
	15	(at your option) any later version.
	16
	17	This program is distributed in the hope that it will be useful,
	18	but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	GNU General Public License for more details.
1da177e4 LT	21	* ------------------------------------------------------------------------ */
1da177e4 LT	22
1da177e4 LT	23	#include <linux/kernel.h>
	24	#include <linux/module.h>
	25	#include <linux/init.h>
6d376fcc	26	#include <linux/delay.h>
1da177e4 LT	27	#include <linux/parport.h>
	28	#include <linux/i2c.h>
	29	#include <linux/i2c-algo-bit.h>
35859254	30	#include <linux/i2c-smbus.h>
5a0e3ad6	31	#include <linux/slab.h>
56acc7a3 JD	32	#include <linux/list.h>
56acc7a3 JD	33	#include <linux/mutex.h>
1da177e4 LT	34	#include "i2c-parport.h"
	35
	36	/* ----- Device list ------------------------------------------------------ */
	37
	38	struct i2c_par {
	39	struct pardevice *pdev;
	40	struct i2c_adapter adapter;
	41	struct i2c_algo_bit_data algo_data;
35859254 JD	42	struct i2c_smbus_alert_setup alert_data;
35859254 JD	43	struct i2c_client *ara;
56acc7a3	44	struct list_head node;
1da177e4 LT	45	};
1da177e4 LT	46
56acc7a3 JD	47	static LIST_HEAD(adapter_list);
56acc7a3 JD	48	static DEFINE_MUTEX(adapter_list_lock);
1da177e4 LT	49
	50	/* ----- Low-level parallel port access ----------------------------------- */
	51
	52	static void port_write_data(struct parport *p, unsigned char d)
	53	{
	54	parport_write_data(p, d);
	55	}
	56
	57	static void port_write_control(struct parport *p, unsigned char d)
	58	{
	59	parport_write_control(p, d);
	60	}
	61
	62	static unsigned char port_read_data(struct parport *p)
	63	{
	64	return parport_read_data(p);
	65	}
	66
	67	static unsigned char port_read_status(struct parport *p)
	68	{
	69	return parport_read_status(p);
	70	}
	71
	72	static unsigned char port_read_control(struct parport *p)
	73	{
	74	return parport_read_control(p);
	75	}
	76
07da0372	77	static void (* const port_write[])(struct parport *, unsigned char) = {
1da177e4 LT	78	port_write_data,
	79	NULL,
	80	port_write_control,
	81	};
	82
07da0372	83	static unsigned char (* const port_read[])(struct parport *) = {
1da177e4 LT	84	port_read_data,
	85	port_read_status,
	86	port_read_control,
	87	};
	88
	89	/* ----- Unified line operation functions --------------------------------- */
	90
	91	static inline void line_set(struct parport *data, int state,
	92	const struct lineop *op)
	93	{
	94	u8 oldval = port_read[op->port](data);
	95
	96	/* Touch only the bit(s) needed */
	97	if ((op->inverted && !state) \|\| (!op->inverted && state))
	98	port_write[op->port](data, oldval \| op->val);
	99	else
	100	port_write[op->port](data, oldval & ~op->val);
	101	}
	102
	103	static inline int line_get(struct parport *data,
	104	const struct lineop *op)
	105	{
	106	u8 oldval = port_read[op->port](data);
	107
	108	return ((op->inverted && (oldval & op->val) != op->val)
	109	\|\| (!op->inverted && (oldval & op->val) == op->val));
	110	}
	111
	112	/* ----- I2C algorithm call-back functions and structures ----------------- */
	113
	114	static void parport_setscl(void *data, int state)
	115	{
	116	line_set((struct parport *) data, state, &adapter_parm[type].setscl);
	117	}
	118
	119	static void parport_setsda(void *data, int state)
	120	{
	121	line_set((struct parport *) data, state, &adapter_parm[type].setsda);
	122	}
	123
	124	static int parport_getscl(void *data)
	125	{
	126	return line_get((struct parport *) data, &adapter_parm[type].getscl);
	127	}
	128
	129	static int parport_getsda(void *data)
	130	{
	131	return line_get((struct parport *) data, &adapter_parm[type].getsda);
	132	}
	133
	134	/* Encapsulate the functions above in the correct structure.
	135	Note that this is only a template, from which the real structures are
	136	copied. The attaching code will set getscl to NULL for adapters that
614e24be	137	cannot read SCL back, and will also make the data field point to
1da177e4	138	the parallel port structure. */
bfdcad90	139	static const struct i2c_algo_bit_data parport_algo_data = {
1da177e4 LT	140	.setsda = parport_setsda,
	141	.setscl = parport_setscl,
	142	.getsda = parport_getsda,
	143	.getscl = parport_getscl,
3af07bd2	144	.udelay = 10, /* ~50 kbps */
1da177e4	145	.timeout = HZ,
07da0372	146	};
1da177e4 LT	147
	148	/* ----- I2c and parallel port call-back functions and structures --------- */
	149
7fe442a1	150	static void i2c_parport_irq(void *data)
35859254 JD	151	{
	152	struct i2c_par *adapter = data;
	153	struct i2c_client *ara = adapter->ara;
	154
	155	if (ara) {
	156	dev_dbg(&ara->dev, "SMBus alert received\n");
	157	i2c_handle_smbus_alert(ara);
	158	} else
	159	dev_dbg(&adapter->adapter.dev,
	160	"SMBus alert received but no ARA client!\n");
	161	}
	162
07da0372	163	static void i2c_parport_attach(struct parport *port)
1da177e4 LT	164	{
1da177e4 LT	165	struct i2c_par *adapter;
07da0372	166
5263ebb5	167	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
1da177e4	168	if (adapter == NULL) {
5263ebb5	169	printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
1da177e4 LT	170	return;
1da177e4 LT	171	}
1da177e4 LT	172
1da177e4 LT	173	pr_debug("i2c-parport: attaching to %s\n", port->name);
35859254	174	parport_disable_irq(port);
1da177e4	175	adapter->pdev = parport_register_device(port, "i2c-parport",
35859254	176	NULL, NULL, i2c_parport_irq, PARPORT_FLAG_EXCL, adapter);
1da177e4 LT	177	if (!adapter->pdev) {
1da177e4 LT	178	printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
07da0372	179	goto err_free;
1da177e4 LT	180	}
	181
	182	/* Fill the rest of the structure */
cacf2269 JD	183	adapter->adapter.owner = THIS_MODULE;
cacf2269 JD	184	adapter->adapter.class = I2C_CLASS_HWMON;
cacf2269 JD	185	strlcpy(adapter->adapter.name, "Parallel port adapter",
cacf2269 JD	186	sizeof(adapter->adapter.name));
1da177e4	187	adapter->algo_data = parport_algo_data;
3af07bd2 JD	188	/* Slow down if we can't sense SCL */
3af07bd2 JD	189	if (!adapter_parm[type].getscl.val) {
1da177e4	190	adapter->algo_data.getscl = NULL;
3af07bd2 JD	191	adapter->algo_data.udelay = 50; /* ~10 kbps */
3af07bd2 JD	192	}
1da177e4 LT	193	adapter->algo_data.data = port;
1da177e4 LT	194	adapter->adapter.algo_data = &adapter->algo_data;
da675296	195	adapter->adapter.dev.parent = port->physport->dev;
1da177e4 LT	196
	197	if (parport_claim_or_block(adapter->pdev) < 0) {
	198	printk(KERN_ERR "i2c-parport: Could not claim parallel port\n");
07da0372	199	goto err_unregister;
1da177e4 LT	200	}
	201
	202	/* Reset hardware to a sane state (SCL and SDA high) */
	203	parport_setsda(port, 1);
	204	parport_setscl(port, 1);
	205	/* Other init if needed (power on...) */
6d376fcc	206	if (adapter_parm[type].init.val) {
1da177e4	207	line_set(port, 1, &adapter_parm[type].init);
6d376fcc JD	208	/* Give powered devices some time to settle */
	209	msleep(100);
	210	}
1da177e4	211
1da177e4 LT	212	if (i2c_bit_add_bus(&adapter->adapter) < 0) {
1da177e4 LT	213	printk(KERN_ERR "i2c-parport: Unable to register with I2C\n");
07da0372	214	goto err_unregister;
1da177e4 LT	215	}
1da177e4 LT	216
35859254 JD	217	/* Setup SMBus alert if supported */
	218	if (adapter_parm[type].smbus_alert) {
	219	adapter->alert_data.alert_edge_triggered = 1;
	220	adapter->ara = i2c_setup_smbus_alert(&adapter->adapter,
	221	&adapter->alert_data);
	222	if (adapter->ara)
	223	parport_enable_irq(port);
	224	else
	225	printk(KERN_WARNING "i2c-parport: Failed to register "
	226	"ARA client\n");
	227	}
	228
1da177e4	229	/* Add the new adapter to the list */
56acc7a3 JD	230	mutex_lock(&adapter_list_lock);
	231	list_add_tail(&adapter->node, &adapter_list);
	232	mutex_unlock(&adapter_list_lock);
07da0372	233	return;
1da177e4	234
07da0372	235	err_unregister:
7b964f73	236	parport_release(adapter->pdev);
1da177e4	237	parport_unregister_device(adapter->pdev);
07da0372	238	err_free:
1da177e4 LT	239	kfree(adapter);
	240	}
	241
07da0372	242	static void i2c_parport_detach(struct parport *port)
1da177e4	243	{
56acc7a3	244	struct i2c_par adapter, _n;
1da177e4 LT	245
1da177e4 LT	246	/* Walk the list */
56acc7a3 JD	247	mutex_lock(&adapter_list_lock);
56acc7a3 JD	248	list_for_each_entry_safe(adapter, _n, &adapter_list, node) {
1da177e4	249	if (adapter->pdev->port == port) {
35859254 JD	250	if (adapter->ara) {
	251	parport_disable_irq(port);
	252	i2c_unregister_device(adapter->ara);
	253	}
3af07bd2 JD	254	i2c_del_adapter(&adapter->adapter);
3af07bd2 JD	255
1da177e4 LT	256	/* Un-init if needed (power off...) */
	257	if (adapter_parm[type].init.val)
	258	line_set(port, 0, &adapter_parm[type].init);
07da0372	259
7b964f73	260	parport_release(adapter->pdev);
1da177e4	261	parport_unregister_device(adapter->pdev);
56acc7a3	262	list_del(&adapter->node);
1da177e4	263	kfree(adapter);
1da177e4 LT	264	}
1da177e4 LT	265	}
56acc7a3	266	mutex_unlock(&adapter_list_lock);
1da177e4 LT	267	}
1da177e4 LT	268
6c129be8	269	static struct parport_driver i2c_parport_driver = {
1da177e4 LT	270	.name = "i2c-parport",
	271	.attach = i2c_parport_attach,
	272	.detach = i2c_parport_detach,
	273	};
	274
	275	/* ----- Module loading, unloading and information ------------------------ */
	276
	277	static int __init i2c_parport_init(void)
	278	{
e97b81dd MH	279	if (type < 0) {
	280	printk(KERN_WARNING "i2c-parport: adapter type unspecified\n");
	281	return -ENODEV;
	282	}
	283
	284	if (type >= ARRAY_SIZE(adapter_parm)) {
1da177e4	285	printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
e97b81dd	286	return -ENODEV;
1da177e4	287	}
7e3d7db5	288
6c129be8	289	return parport_register_driver(&i2c_parport_driver);
1da177e4 LT	290	}
	291
	292	static void __exit i2c_parport_exit(void)
	293	{
6c129be8	294	parport_unregister_driver(&i2c_parport_driver);
1da177e4 LT	295	}
1da177e4 LT	296
7c81c60f	297	MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1da177e4 LT	298	MODULE_DESCRIPTION("I2C bus over parallel port");
	299	MODULE_LICENSE("GPL");
	300
	301	module_init(i2c_parport_init);
	302	module_exit(i2c_parport_exit);