[deliverable/linux.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);
#define MAX_DEVICE 4
static int parport[MAX_DEVICE] = {0, -1, -1, -1};


/* ----- 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;
	int i;
	struct pardev_cb i2c_parport_cb;

	for (i = 0; i < MAX_DEVICE; i++) {
		if (parport[i] == -1)
			continue;
		if (port->number == parport[i])
			break;
	}
	if (i == MAX_DEVICE) {
		pr_debug("i2c-parport: Not using parport%d.\n", port->number);
		return;
	}

	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
	if (adapter == NULL) {
		printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
		return;
	}
	memset(&i2c_parport_cb, 0, sizeof(i2c_parport_cb));
	i2c_parport_cb.flags = PARPORT_FLAG_EXCL;
	i2c_parport_cb.irq_func = i2c_parport_irq;
	i2c_parport_cb.private = adapter;

	pr_debug("i2c-parport: attaching to %s\n", port->name);
	parport_disable_irq(port);
	adapter->pdev = parport_register_dev_model(port, "i2c-parport",
						   &i2c_parport_cb, i);
	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) {
		dev_err(&adapter->pdev->dev,
			"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) {
		dev_err(&adapter->pdev->dev, "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
			dev_warn(&adapter->pdev->dev,
				 "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",
	.match_port = i2c_parport_attach,
	.detach = i2c_parport_detach,
	.devmodel = true,
};

/* ----- 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_param_array(parport, int, NULL, 0);
MODULE_PARM_DESC(parport,
		 "List of parallel ports to bind to, by index.\n"
		 " Atmost " __stringify(MAX_DEVICE) " devices are supported.\n"
		 " Default is one device connected to parport0.\n"
);

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);
19a4fb21 SM	49	#define MAX_DEVICE 4
	50	static int parport[MAX_DEVICE] = {0, -1, -1, -1};
	51
1da177e4 LT	52
	53	/* ----- Low-level parallel port access ----------------------------------- */
	54
	55	static void port_write_data(struct parport *p, unsigned char d)
	56	{
	57	parport_write_data(p, d);
	58	}
	59
	60	static void port_write_control(struct parport *p, unsigned char d)
	61	{
	62	parport_write_control(p, d);
	63	}
	64
	65	static unsigned char port_read_data(struct parport *p)
	66	{
	67	return parport_read_data(p);
	68	}
	69
	70	static unsigned char port_read_status(struct parport *p)
	71	{
	72	return parport_read_status(p);
	73	}
	74
	75	static unsigned char port_read_control(struct parport *p)
	76	{
	77	return parport_read_control(p);
	78	}
	79
07da0372	80	static void (* const port_write[])(struct parport *, unsigned char) = {
1da177e4 LT	81	port_write_data,
	82	NULL,
	83	port_write_control,
	84	};
	85
07da0372	86	static unsigned char (* const port_read[])(struct parport *) = {
1da177e4 LT	87	port_read_data,
	88	port_read_status,
	89	port_read_control,
	90	};
	91
	92	/* ----- Unified line operation functions --------------------------------- */
	93
	94	static inline void line_set(struct parport *data, int state,
	95	const struct lineop *op)
	96	{
	97	u8 oldval = port_read[op->port](data);
	98
	99	/* Touch only the bit(s) needed */
	100	if ((op->inverted && !state) \|\| (!op->inverted && state))
	101	port_write[op->port](data, oldval \| op->val);
	102	else
	103	port_write[op->port](data, oldval & ~op->val);
	104	}
	105
	106	static inline int line_get(struct parport *data,
	107	const struct lineop *op)
	108	{
	109	u8 oldval = port_read[op->port](data);
	110
	111	return ((op->inverted && (oldval & op->val) != op->val)
	112	\|\| (!op->inverted && (oldval & op->val) == op->val));
	113	}
	114
	115	/* ----- I2C algorithm call-back functions and structures ----------------- */
	116
	117	static void parport_setscl(void *data, int state)
	118	{
	119	line_set((struct parport *) data, state, &adapter_parm[type].setscl);
	120	}
	121
	122	static void parport_setsda(void *data, int state)
	123	{
	124	line_set((struct parport *) data, state, &adapter_parm[type].setsda);
	125	}
	126
	127	static int parport_getscl(void *data)
	128	{
	129	return line_get((struct parport *) data, &adapter_parm[type].getscl);
	130	}
	131
	132	static int parport_getsda(void *data)
	133	{
	134	return line_get((struct parport *) data, &adapter_parm[type].getsda);
	135	}
	136
	137	/* Encapsulate the functions above in the correct structure.
	138	Note that this is only a template, from which the real structures are
	139	copied. The attaching code will set getscl to NULL for adapters that
614e24be	140	cannot read SCL back, and will also make the data field point to
1da177e4	141	the parallel port structure. */
bfdcad90	142	static const struct i2c_algo_bit_data parport_algo_data = {
1da177e4 LT	143	.setsda = parport_setsda,
	144	.setscl = parport_setscl,
	145	.getsda = parport_getsda,
	146	.getscl = parport_getscl,
3af07bd2	147	.udelay = 10, /* ~50 kbps */
1da177e4	148	.timeout = HZ,
07da0372	149	};
1da177e4 LT	150
	151	/* ----- I2c and parallel port call-back functions and structures --------- */
	152
7fe442a1	153	static void i2c_parport_irq(void *data)
35859254 JD	154	{
	155	struct i2c_par *adapter = data;
	156	struct i2c_client *ara = adapter->ara;
	157
	158	if (ara) {
	159	dev_dbg(&ara->dev, "SMBus alert received\n");
	160	i2c_handle_smbus_alert(ara);
	161	} else
	162	dev_dbg(&adapter->adapter.dev,
	163	"SMBus alert received but no ARA client!\n");
	164	}
	165
07da0372	166	static void i2c_parport_attach(struct parport *port)
1da177e4 LT	167	{
1da177e4 LT	168	struct i2c_par *adapter;
19a4fb21 SM	169	int i;
	170	struct pardev_cb i2c_parport_cb;
	171
	172	for (i = 0; i < MAX_DEVICE; i++) {
	173	if (parport[i] == -1)
	174	continue;
	175	if (port->number == parport[i])
	176	break;
	177	}
	178	if (i == MAX_DEVICE) {
	179	pr_debug("i2c-parport: Not using parport%d.\n", port->number);
	180	return;
	181	}
07da0372	182
5263ebb5	183	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
1da177e4	184	if (adapter == NULL) {
5263ebb5	185	printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
1da177e4 LT	186	return;
1da177e4 LT	187	}
8891f41a SM	188	memset(&i2c_parport_cb, 0, sizeof(i2c_parport_cb));
	189	i2c_parport_cb.flags = PARPORT_FLAG_EXCL;
	190	i2c_parport_cb.irq_func = i2c_parport_irq;
	191	i2c_parport_cb.private = adapter;
1da177e4 LT	192
1da177e4 LT	193	pr_debug("i2c-parport: attaching to %s\n", port->name);
35859254	194	parport_disable_irq(port);
8891f41a SM	195	adapter->pdev = parport_register_dev_model(port, "i2c-parport",
8891f41a SM	196	&i2c_parport_cb, i);
1da177e4 LT	197	if (!adapter->pdev) {
1da177e4 LT	198	printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
07da0372	199	goto err_free;
1da177e4 LT	200	}
	201
	202	/* Fill the rest of the structure */
cacf2269 JD	203	adapter->adapter.owner = THIS_MODULE;
cacf2269 JD	204	adapter->adapter.class = I2C_CLASS_HWMON;
cacf2269 JD	205	strlcpy(adapter->adapter.name, "Parallel port adapter",
cacf2269 JD	206	sizeof(adapter->adapter.name));
1da177e4	207	adapter->algo_data = parport_algo_data;
3af07bd2 JD	208	/* Slow down if we can't sense SCL */
3af07bd2 JD	209	if (!adapter_parm[type].getscl.val) {
1da177e4	210	adapter->algo_data.getscl = NULL;
3af07bd2 JD	211	adapter->algo_data.udelay = 50; /* ~10 kbps */
3af07bd2 JD	212	}
1da177e4 LT	213	adapter->algo_data.data = port;
1da177e4 LT	214	adapter->adapter.algo_data = &adapter->algo_data;
da675296	215	adapter->adapter.dev.parent = port->physport->dev;
1da177e4 LT	216
1da177e4 LT	217	if (parport_claim_or_block(adapter->pdev) < 0) {
c5f3d544 SM	218	dev_err(&adapter->pdev->dev,
c5f3d544 SM	219	"Could not claim parallel port\n");
07da0372	220	goto err_unregister;
1da177e4 LT	221	}
	222
	223	/* Reset hardware to a sane state (SCL and SDA high) */
	224	parport_setsda(port, 1);
	225	parport_setscl(port, 1);
	226	/* Other init if needed (power on...) */
6d376fcc	227	if (adapter_parm[type].init.val) {
1da177e4	228	line_set(port, 1, &adapter_parm[type].init);
6d376fcc JD	229	/* Give powered devices some time to settle */
	230	msleep(100);
	231	}
1da177e4	232
1da177e4	233	if (i2c_bit_add_bus(&adapter->adapter) < 0) {
c5f3d544	234	dev_err(&adapter->pdev->dev, "Unable to register with I2C\n");
07da0372	235	goto err_unregister;
1da177e4 LT	236	}
1da177e4 LT	237
35859254 JD	238	/* Setup SMBus alert if supported */
	239	if (adapter_parm[type].smbus_alert) {
	240	adapter->alert_data.alert_edge_triggered = 1;
	241	adapter->ara = i2c_setup_smbus_alert(&adapter->adapter,
	242	&adapter->alert_data);
	243	if (adapter->ara)
	244	parport_enable_irq(port);
	245	else
c5f3d544 SM	246	dev_warn(&adapter->pdev->dev,
c5f3d544 SM	247	"Failed to register ARA client\n");
35859254 JD	248	}
35859254 JD	249
1da177e4	250	/* Add the new adapter to the list */
56acc7a3 JD	251	mutex_lock(&adapter_list_lock);
	252	list_add_tail(&adapter->node, &adapter_list);
	253	mutex_unlock(&adapter_list_lock);
07da0372	254	return;
1da177e4	255
07da0372	256	err_unregister:
7b964f73	257	parport_release(adapter->pdev);
1da177e4	258	parport_unregister_device(adapter->pdev);
07da0372	259	err_free:
1da177e4 LT	260	kfree(adapter);
	261	}
	262
07da0372	263	static void i2c_parport_detach(struct parport *port)
1da177e4	264	{
56acc7a3	265	struct i2c_par adapter, _n;
1da177e4 LT	266
1da177e4 LT	267	/* Walk the list */
56acc7a3 JD	268	mutex_lock(&adapter_list_lock);
56acc7a3 JD	269	list_for_each_entry_safe(adapter, _n, &adapter_list, node) {
1da177e4	270	if (adapter->pdev->port == port) {
35859254 JD	271	if (adapter->ara) {
	272	parport_disable_irq(port);
	273	i2c_unregister_device(adapter->ara);
	274	}
3af07bd2 JD	275	i2c_del_adapter(&adapter->adapter);
3af07bd2 JD	276
1da177e4 LT	277	/* Un-init if needed (power off...) */
	278	if (adapter_parm[type].init.val)
	279	line_set(port, 0, &adapter_parm[type].init);
07da0372	280
7b964f73	281	parport_release(adapter->pdev);
1da177e4	282	parport_unregister_device(adapter->pdev);
56acc7a3	283	list_del(&adapter->node);
1da177e4	284	kfree(adapter);
1da177e4 LT	285	}
1da177e4 LT	286	}
56acc7a3	287	mutex_unlock(&adapter_list_lock);
1da177e4 LT	288	}
1da177e4 LT	289
6c129be8	290	static struct parport_driver i2c_parport_driver = {
8891f41a SM	291	.name = "i2c-parport",
	292	.match_port = i2c_parport_attach,
	293	.detach = i2c_parport_detach,
	294	.devmodel = true,
1da177e4 LT	295	};
	296
	297	/* ----- Module loading, unloading and information ------------------------ */
	298
	299	static int __init i2c_parport_init(void)
	300	{
e97b81dd MH	301	if (type < 0) {
	302	printk(KERN_WARNING "i2c-parport: adapter type unspecified\n");
	303	return -ENODEV;
	304	}
	305
	306	if (type >= ARRAY_SIZE(adapter_parm)) {
1da177e4	307	printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
e97b81dd	308	return -ENODEV;
1da177e4	309	}
7e3d7db5	310
6c129be8	311	return parport_register_driver(&i2c_parport_driver);
1da177e4 LT	312	}
	313
	314	static void __exit i2c_parport_exit(void)
	315	{
6c129be8	316	parport_unregister_driver(&i2c_parport_driver);
1da177e4 LT	317	}
1da177e4 LT	318
7c81c60f	319	MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1da177e4 LT	320	MODULE_DESCRIPTION("I2C bus over parallel port");
	321	MODULE_LICENSE("GPL");
	322
19a4fb21 SM	323	module_param_array(parport, int, NULL, 0);
	324	MODULE_PARM_DESC(parport,
	325	"List of parallel ports to bind to, by index.\n"
	326	" Atmost " __stringify(MAX_DEVICE) " devices are supported.\n"
	327	" Default is one device connected to parport0.\n"
	328	);
	329
1da177e4 LT	330	module_init(i2c_parport_init);
1da177e4 LT	331	module_exit(i2c_parport_exit);