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

/* ------------------------------------------------------------------------ *
 * i2c-parport.c I2C bus over parallel port                                 *
 * ------------------------------------------------------------------------ *
   Copyright (C) 2003-2007 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/parport.h>
#include <linux/i2c.h>
#include <linux/i2c-algo-bit.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_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 --------- */

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);
	adapter->pdev = parport_register_device(port, "i2c-parport",
		NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL);
	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;
	adapter->adapter.id = I2C_HW_B_LP;
	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);

	parport_release(adapter->pdev);

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

	/* Add the new adapter to the list */
	adapter->next = adapter_list;
	adapter_list = adapter;
        return;

ERROR1:
	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) {
			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_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	* ------------------------------------------------------------------------ *
3af07bd2	4	Copyright (C) 2003-2007 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>
	30	#include <linux/parport.h>
	31	#include <linux/i2c.h>
	32	#include <linux/i2c-algo-bit.h>
	33	#include "i2c-parport.h"
	34
	35	/* ----- Device list ------------------------------------------------------ */
	36
	37	struct i2c_par {
	38	struct pardevice *pdev;
	39	struct i2c_adapter adapter;
	40	struct i2c_algo_bit_data algo_data;
	41	struct i2c_par *next;
	42	};
	43
	44	static struct i2c_par *adapter_list;
	45
	46	/* ----- Low-level parallel port access ----------------------------------- */
	47
	48	static void port_write_data(struct parport *p, unsigned char d)
	49	{
	50	parport_write_data(p, d);
	51	}
	52
	53	static void port_write_control(struct parport *p, unsigned char d)
	54	{
	55	parport_write_control(p, d);
	56	}
	57
	58	static unsigned char port_read_data(struct parport *p)
	59	{
	60	return parport_read_data(p);
	61	}
	62
	63	static unsigned char port_read_status(struct parport *p)
	64	{
	65	return parport_read_status(p);
	66	}
	67
	68	static unsigned char port_read_control(struct parport *p)
	69	{
	70	return parport_read_control(p);
	71	}
	72
	73	static void (port_write[])(struct parport , unsigned char) = {
	74	port_write_data,
	75	NULL,
	76	port_write_control,
	77	};
	78
	79	static unsigned char (port_read[])(struct parport ) = {
	80	port_read_data,
	81	port_read_status,
	82	port_read_control,
	83	};
	84
	85	/* ----- Unified line operation functions --------------------------------- */
	86
	87	static inline void line_set(struct parport *data, int state,
	88	const struct lineop *op)
	89	{
	90	u8 oldval = port_read[op->port](data);
91
92	/* Touch only the bit(s) needed */
93	if ((op->inverted && !state) \|\| (!op->inverted && state))
94	port_write[op->port](data, oldval \| op->val);
95	else
96	port_write[op->port](data, oldval & ~op->val);
97	}
98
99	static inline int line_get(struct parport *data,
100	const struct lineop *op)
101	{
102	u8 oldval = port_read[op->port](data);
103
104	return ((op->inverted && (oldval & op->val) != op->val)
105	\|\| (!op->inverted && (oldval & op->val) == op->val));
106	}
107
108	/* ----- I2C algorithm call-back functions and structures ----------------- */
109
110	static void parport_setscl(void *data, int state)
111	{
112	line_set((struct parport *) data, state, &adapter_parm[type].setscl);
113	}
114
115	static void parport_setsda(void *data, int state)
116	{
117	line_set((struct parport *) data, state, &adapter_parm[type].setsda);
118	}
119
120	static int parport_getscl(void *data)
121	{
122	return line_get((struct parport *) data, &adapter_parm[type].getscl);
123	}
124
125	static int parport_getsda(void *data)
126	{
127	return line_get((struct parport *) data, &adapter_parm[type].getsda);
128	}
129
130	/* Encapsulate the functions above in the correct structure.
131	Note that this is only a template, from which the real structures are
132	copied. The attaching code will set getscl to NULL for adapters that
614e24be	133	cannot read SCL back, and will also make the data field point to
1da177e4 LT	134	the parallel port structure. */
	135	static struct i2c_algo_bit_data parport_algo_data = {
	136	.setsda = parport_setsda,
	137	.setscl = parport_setscl,
	138	.getsda = parport_getsda,
	139	.getscl = parport_getscl,
3af07bd2	140	.udelay = 10, /* ~50 kbps */
1da177e4 LT	141	.timeout = HZ,
	142	};
	143
	144	/* ----- I2c and parallel port call-back functions and structures --------- */
	145
1da177e4 LT	146	static void i2c_parport_attach (struct parport *port)
	147	{
	148	struct i2c_par *adapter;
	149
5263ebb5	150	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
1da177e4	151	if (adapter == NULL) {
5263ebb5	152	printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
1da177e4 LT	153	return;
1da177e4 LT	154	}
1da177e4 LT	155
	156	pr_debug("i2c-parport: attaching to %s\n", port->name);
	157	adapter->pdev = parport_register_device(port, "i2c-parport",
	158	NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL);
	159	if (!adapter->pdev) {
	160	printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
	161	goto ERROR0;
	162	}
	163
	164	/* Fill the rest of the structure */
cacf2269 JD	165	adapter->adapter.owner = THIS_MODULE;
	166	adapter->adapter.class = I2C_CLASS_HWMON;
	167	adapter->adapter.id = I2C_HW_B_LP;
	168	strlcpy(adapter->adapter.name, "Parallel port adapter",
	169	sizeof(adapter->adapter.name));
1da177e4	170	adapter->algo_data = parport_algo_data;
3af07bd2 JD	171	/* Slow down if we can't sense SCL */
3af07bd2 JD	172	if (!adapter_parm[type].getscl.val) {
1da177e4	173	adapter->algo_data.getscl = NULL;
3af07bd2 JD	174	adapter->algo_data.udelay = 50; /* ~10 kbps */
3af07bd2 JD	175	}
1da177e4 LT	176	adapter->algo_data.data = port;
1da177e4 LT	177	adapter->adapter.algo_data = &adapter->algo_data;
da675296	178	adapter->adapter.dev.parent = port->physport->dev;
1da177e4 LT	179
	180	if (parport_claim_or_block(adapter->pdev) < 0) {
	181	printk(KERN_ERR "i2c-parport: Could not claim parallel port\n");
	182	goto ERROR1;
	183	}
	184
	185	/* Reset hardware to a sane state (SCL and SDA high) */
	186	parport_setsda(port, 1);
	187	parport_setscl(port, 1);
	188	/* Other init if needed (power on...) */
	189	if (adapter_parm[type].init.val)
	190	line_set(port, 1, &adapter_parm[type].init);
	191
	192	parport_release(adapter->pdev);
	193
	194	if (i2c_bit_add_bus(&adapter->adapter) < 0) {
	195	printk(KERN_ERR "i2c-parport: Unable to register with I2C\n");
	196	goto ERROR1;
	197	}
	198
	199	/* Add the new adapter to the list */
	200	adapter->next = adapter_list;
	201	adapter_list = adapter;
	202	return;
	203
	204	ERROR1:
	205	parport_unregister_device(adapter->pdev);
	206	ERROR0:
	207	kfree(adapter);
	208	}
	209
	210	static void i2c_parport_detach (struct parport *port)
	211	{
	212	struct i2c_par adapter, prev;
	213
	214	/* Walk the list */
	215	for (prev = NULL, adapter = adapter_list; adapter;
	216	prev = adapter, adapter = adapter->next) {
	217	if (adapter->pdev->port == port) {
3af07bd2 JD	218	i2c_del_adapter(&adapter->adapter);
3af07bd2 JD	219
1da177e4 LT	220	/* Un-init if needed (power off...) */
	221	if (adapter_parm[type].init.val)
	222	line_set(port, 0, &adapter_parm[type].init);
	223
1da177e4 LT	224	parport_unregister_device(adapter->pdev);
	225	if (prev)
	226	prev->next = adapter->next;
	227	else
	228	adapter_list = adapter->next;
	229	kfree(adapter);
	230	return;
	231	}
	232	}
	233	}
	234
6c129be8	235	static struct parport_driver i2c_parport_driver = {
1da177e4 LT	236	.name = "i2c-parport",
	237	.attach = i2c_parport_attach,
	238	.detach = i2c_parport_detach,
	239	};
	240
	241	/* ----- Module loading, unloading and information ------------------------ */
	242
	243	static int __init i2c_parport_init(void)
	244	{
e97b81dd MH	245	if (type < 0) {
	246	printk(KERN_WARNING "i2c-parport: adapter type unspecified\n");
	247	return -ENODEV;
	248	}
	249
	250	if (type >= ARRAY_SIZE(adapter_parm)) {
1da177e4	251	printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
e97b81dd	252	return -ENODEV;
1da177e4	253	}
7e3d7db5	254
6c129be8	255	return parport_register_driver(&i2c_parport_driver);
1da177e4 LT	256	}
	257
	258	static void __exit i2c_parport_exit(void)
	259	{
6c129be8	260	parport_unregister_driver(&i2c_parport_driver);
1da177e4 LT	261	}
	262
	263	MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
	264	MODULE_DESCRIPTION("I2C bus over parallel port");
	265	MODULE_LICENSE("GPL");
	266
	267	module_init(i2c_parport_init);
	268	module_exit(i2c_parport_exit);