[linux-block.git] / drivers / i2c / busses / i2c-parport.c

/* ------------------------------------------------------------------------ *
 * i2c-parport.c I2C bus over parallel port                                 *
 * ------------------------------------------------------------------------ *
   Copyright (C) 2003-2010 Jean Delvare <khali@linux-fr.org>
   
   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.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * ------------------------------------------------------------------------ */

#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 "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 i2c_par *next;
};

static struct i2c_par *adapter_list;

/* ----- 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 (*port_write[])(struct parport *, unsigned char) = {
	port_write_data,
	NULL,
	port_write_control,
};

static unsigned char (*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 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 --------- */

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 ERROR0;
	}

	/* 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 ERROR1;
	}

	/* 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 ERROR1;
	}

	/* 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 */
	adapter->next = adapter_list;
	adapter_list = adapter;
        return;

ERROR1:
	parport_release(adapter->pdev);
	parport_unregister_device(adapter->pdev);
ERROR0:
	kfree(adapter);
}

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

	/* Walk the list */
	for (prev = NULL, adapter = adapter_list; adapter;
	     prev = adapter, adapter = adapter->next) {
		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);
			if (prev)
				prev->next = adapter->next;
			else
				adapter_list = adapter->next;
			kfree(adapter);
			return;
		}
	}
}

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 <khali@linux-fr.org>");
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	* ------------------------------------------------------------------------ *
35859254	4	Copyright (C) 2003-2010 Jean Delvare <khali@linux-fr.org>
1da177e4 LT	5
	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>
1da177e4 LT	11
	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.
	21
	22	You should have received a copy of the GNU General Public License
	23	along with this program; if not, write to the Free Software
	24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	25	* ------------------------------------------------------------------------ */
	26
1da177e4 LT	27	#include <linux/kernel.h>
	28	#include <linux/module.h>
	29	#include <linux/init.h>
6d376fcc	30	#include <linux/delay.h>
1da177e4 LT	31	#include <linux/parport.h>
	32	#include <linux/i2c.h>
	33	#include <linux/i2c-algo-bit.h>
35859254	34	#include <linux/i2c-smbus.h>
5a0e3ad6	35	#include <linux/slab.h>
1da177e4 LT	36	#include "i2c-parport.h"
	37
	38	/* ----- Device list ------------------------------------------------------ */
	39
	40	struct i2c_par {
	41	struct pardevice *pdev;
	42	struct i2c_adapter adapter;
	43	struct i2c_algo_bit_data algo_data;
35859254 JD	44	struct i2c_smbus_alert_setup alert_data;
35859254 JD	45	struct i2c_client *ara;
1da177e4 LT	46	struct i2c_par *next;
	47	};
	48
	49	static struct i2c_par *adapter_list;
	50
	51	/* ----- Low-level parallel port access ----------------------------------- */
	52
	53	static void port_write_data(struct parport *p, unsigned char d)
	54	{
	55	parport_write_data(p, d);
	56	}
	57
	58	static void port_write_control(struct parport *p, unsigned char d)
	59	{
	60	parport_write_control(p, d);
	61	}
	62
	63	static unsigned char port_read_data(struct parport *p)
	64	{
	65	return parport_read_data(p);
	66	}
	67
	68	static unsigned char port_read_status(struct parport *p)
	69	{
	70	return parport_read_status(p);
	71	}
	72
	73	static unsigned char port_read_control(struct parport *p)
	74	{
	75	return parport_read_control(p);
	76	}
	77
	78	static void (port_write[])(struct parport , unsigned char) = {
	79	port_write_data,
	80	NULL,
	81	port_write_control,
	82	};
	83
	84	static unsigned char (port_read[])(struct parport ) = {
	85	port_read_data,
	86	port_read_status,
	87	port_read_control,
	88	};
	89
	90	/* ----- Unified line operation functions --------------------------------- */
	91
	92	static inline void line_set(struct parport *data, int state,
	93	const struct lineop *op)
	94	{
	95	u8 oldval = port_read[op->port](data);
	96
	97	/* Touch only the bit(s) needed */
	98	if ((op->inverted && !state) \|\| (!op->inverted && state))
	99	port_write[op->port](data, oldval \| op->val);
	100	else
	101	port_write[op->port](data, oldval & ~op->val);
	102	}
	103
	104	static inline int line_get(struct parport *data,
	105	const struct lineop *op)
	106	{
	107	u8 oldval = port_read[op->port](data);
	108
	109	return ((op->inverted && (oldval & op->val) != op->val)
110	\|\| (!op->inverted && (oldval & op->val) == op->val));
111	}
112
113	/* ----- I2C algorithm call-back functions and structures ----------------- */
114
115	static void parport_setscl(void *data, int state)
116	{
117	line_set((struct parport *) data, state, &adapter_parm[type].setscl);
118	}
119
120	static void parport_setsda(void *data, int state)
121	{
122	line_set((struct parport *) data, state, &adapter_parm[type].setsda);
123	}
124
125	static int parport_getscl(void *data)
126	{
127	return line_get((struct parport *) data, &adapter_parm[type].getscl);
128	}
129
130	static int parport_getsda(void *data)
131	{
132	return line_get((struct parport *) data, &adapter_parm[type].getsda);
133	}
134
135	/* Encapsulate the functions above in the correct structure.
136	Note that this is only a template, from which the real structures are
137	copied. The attaching code will set getscl to NULL for adapters that
614e24be	138	cannot read SCL back, and will also make the data field point to
1da177e4 LT	139	the parallel port structure. */
	140	static struct i2c_algo_bit_data parport_algo_data = {
	141	.setsda = parport_setsda,
	142	.setscl = parport_setscl,
	143	.getsda = parport_getsda,
	144	.getscl = parport_getscl,
3af07bd2	145	.udelay = 10, /* ~50 kbps */
1da177e4 LT	146	.timeout = HZ,
	147	};
	148
	149	/* ----- I2c and parallel port call-back functions and structures --------- */
	150
35859254 JD	151	void i2c_parport_irq(void *data)
	152	{
	153	struct i2c_par *adapter = data;
	154	struct i2c_client *ara = adapter->ara;
	155
	156	if (ara) {
	157	dev_dbg(&ara->dev, "SMBus alert received\n");
	158	i2c_handle_smbus_alert(ara);
	159	} else
	160	dev_dbg(&adapter->adapter.dev,
	161	"SMBus alert received but no ARA client!\n");
	162	}
	163
1da177e4 LT	164	static void i2c_parport_attach (struct parport *port)
	165	{
	166	struct i2c_par *adapter;
	167
5263ebb5	168	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
1da177e4	169	if (adapter == NULL) {
5263ebb5	170	printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
1da177e4 LT	171	return;
1da177e4 LT	172	}
1da177e4 LT	173
1da177e4 LT	174	pr_debug("i2c-parport: attaching to %s\n", port->name);
35859254	175	parport_disable_irq(port);
1da177e4	176	adapter->pdev = parport_register_device(port, "i2c-parport",
35859254	177	NULL, NULL, i2c_parport_irq, PARPORT_FLAG_EXCL, adapter);
1da177e4 LT	178	if (!adapter->pdev) {
	179	printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
	180	goto ERROR0;
	181	}
	182
	183	/* Fill the rest of the structure */
cacf2269 JD	184	adapter->adapter.owner = THIS_MODULE;
cacf2269 JD	185	adapter->adapter.class = I2C_CLASS_HWMON;
cacf2269 JD	186	strlcpy(adapter->adapter.name, "Parallel port adapter",
cacf2269 JD	187	sizeof(adapter->adapter.name));
1da177e4	188	adapter->algo_data = parport_algo_data;
3af07bd2 JD	189	/* Slow down if we can't sense SCL */
3af07bd2 JD	190	if (!adapter_parm[type].getscl.val) {
1da177e4	191	adapter->algo_data.getscl = NULL;
3af07bd2 JD	192	adapter->algo_data.udelay = 50; /* ~10 kbps */
3af07bd2 JD	193	}
1da177e4 LT	194	adapter->algo_data.data = port;
1da177e4 LT	195	adapter->adapter.algo_data = &adapter->algo_data;
da675296	196	adapter->adapter.dev.parent = port->physport->dev;
1da177e4 LT	197
	198	if (parport_claim_or_block(adapter->pdev) < 0) {
	199	printk(KERN_ERR "i2c-parport: Could not claim parallel port\n");
	200	goto ERROR1;
	201	}
	202
	203	/* Reset hardware to a sane state (SCL and SDA high) */
	204	parport_setsda(port, 1);
	205	parport_setscl(port, 1);
	206	/* Other init if needed (power on...) */
6d376fcc	207	if (adapter_parm[type].init.val) {
1da177e4	208	line_set(port, 1, &adapter_parm[type].init);
6d376fcc JD	209	/* Give powered devices some time to settle */
	210	msleep(100);
	211	}
1da177e4	212
1da177e4 LT	213	if (i2c_bit_add_bus(&adapter->adapter) < 0) {
	214	printk(KERN_ERR "i2c-parport: Unable to register with I2C\n");
	215	goto ERROR1;
	216	}
	217
35859254 JD	218	/* Setup SMBus alert if supported */
	219	if (adapter_parm[type].smbus_alert) {
	220	adapter->alert_data.alert_edge_triggered = 1;
	221	adapter->ara = i2c_setup_smbus_alert(&adapter->adapter,
	222	&adapter->alert_data);
	223	if (adapter->ara)
	224	parport_enable_irq(port);
	225	else
	226	printk(KERN_WARNING "i2c-parport: Failed to register "
	227	"ARA client\n");
	228	}
	229
1da177e4 LT	230	/* Add the new adapter to the list */
	231	adapter->next = adapter_list;
	232	adapter_list = adapter;
	233	return;
	234
	235	ERROR1:
7b964f73	236	parport_release(adapter->pdev);
1da177e4 LT	237	parport_unregister_device(adapter->pdev);
	238	ERROR0:
	239	kfree(adapter);
	240	}
	241
	242	static void i2c_parport_detach (struct parport *port)
	243	{
	244	struct i2c_par adapter, prev;
	245
	246	/* Walk the list */
	247	for (prev = NULL, adapter = adapter_list; adapter;
	248	prev = adapter, adapter = adapter->next) {
	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);
	259
7b964f73	260	parport_release(adapter->pdev);
1da177e4 LT	261	parport_unregister_device(adapter->pdev);
	262	if (prev)
	263	prev->next = adapter->next;
	264	else
	265	adapter_list = adapter->next;
	266	kfree(adapter);
	267	return;
	268	}
	269	}
	270	}
	271
6c129be8	272	static struct parport_driver i2c_parport_driver = {
1da177e4 LT	273	.name = "i2c-parport",
	274	.attach = i2c_parport_attach,
	275	.detach = i2c_parport_detach,
	276	};
	277
	278	/* ----- Module loading, unloading and information ------------------------ */
	279
	280	static int __init i2c_parport_init(void)
	281	{
e97b81dd MH	282	if (type < 0) {
	283	printk(KERN_WARNING "i2c-parport: adapter type unspecified\n");
	284	return -ENODEV;
	285	}
	286
	287	if (type >= ARRAY_SIZE(adapter_parm)) {
1da177e4	288	printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
e97b81dd	289	return -ENODEV;
1da177e4	290	}
7e3d7db5	291
6c129be8	292	return parport_register_driver(&i2c_parport_driver);
1da177e4 LT	293	}
	294
	295	static void __exit i2c_parport_exit(void)
	296	{
6c129be8	297	parport_unregister_driver(&i2c_parport_driver);
1da177e4 LT	298	}
	299
	300	MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
	301	MODULE_DESCRIPTION("I2C bus over parallel port");
	302	MODULE_LICENSE("GPL");
	303
	304	module_init(i2c_parport_init);
	305	module_exit(i2c_parport_exit);