[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.
 * ------------------------------------------------------------------------ */

#define pr_fmt(fmt) "i2c-parport: " fmt

#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("Not using parport%d.\n", port->number);
		return;
	}

	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
	if (!adapter)
		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("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) {
		pr_err("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) {
		pr_warn("adapter type unspecified\n");
		return -ENODEV;
	}

	if (type >= ARRAY_SIZE(adapter_parm)) {
		pr_warn("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
20226118 SM	23	#define pr_fmt(fmt) "i2c-parport: " fmt
20226118 SM	24
1da177e4 LT	25	#include <linux/kernel.h>
	26	#include <linux/module.h>
	27	#include <linux/init.h>
6d376fcc	28	#include <linux/delay.h>
1da177e4 LT	29	#include <linux/parport.h>
	30	#include <linux/i2c.h>
	31	#include <linux/i2c-algo-bit.h>
35859254	32	#include <linux/i2c-smbus.h>
5a0e3ad6	33	#include <linux/slab.h>
56acc7a3 JD	34	#include <linux/list.h>
56acc7a3 JD	35	#include <linux/mutex.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;
56acc7a3	46	struct list_head node;
1da177e4 LT	47	};
1da177e4 LT	48
56acc7a3 JD	49	static LIST_HEAD(adapter_list);
56acc7a3 JD	50	static DEFINE_MUTEX(adapter_list_lock);
19a4fb21 SM	51	#define MAX_DEVICE 4
	52	static int parport[MAX_DEVICE] = {0, -1, -1, -1};
	53
1da177e4 LT	54
	55	/* ----- Low-level parallel port access ----------------------------------- */
	56
	57	static void port_write_data(struct parport *p, unsigned char d)
	58	{
	59	parport_write_data(p, d);
	60	}
	61
	62	static void port_write_control(struct parport *p, unsigned char d)
	63	{
	64	parport_write_control(p, d);
	65	}
	66
	67	static unsigned char port_read_data(struct parport *p)
	68	{
	69	return parport_read_data(p);
	70	}
	71
	72	static unsigned char port_read_status(struct parport *p)
	73	{
	74	return parport_read_status(p);
	75	}
	76
	77	static unsigned char port_read_control(struct parport *p)
	78	{
	79	return parport_read_control(p);
	80	}
	81
07da0372	82	static void (* const port_write[])(struct parport *, unsigned char) = {
1da177e4 LT	83	port_write_data,
	84	NULL,
	85	port_write_control,
	86	};
	87
07da0372	88	static unsigned char (* const port_read[])(struct parport *) = {
1da177e4 LT	89	port_read_data,
	90	port_read_status,
	91	port_read_control,
	92	};
	93
	94	/* ----- Unified line operation functions --------------------------------- */
	95
	96	static inline void line_set(struct parport *data, int state,
	97	const struct lineop *op)
	98	{
	99	u8 oldval = port_read[op->port](data);
	100
	101	/* Touch only the bit(s) needed */
	102	if ((op->inverted && !state) \|\| (!op->inverted && state))
	103	port_write[op->port](data, oldval \| op->val);
	104	else
	105	port_write[op->port](data, oldval & ~op->val);
	106	}
	107
	108	static inline int line_get(struct parport *data,
	109	const struct lineop *op)
	110	{
	111	u8 oldval = port_read[op->port](data);
	112
	113	return ((op->inverted && (oldval & op->val) != op->val)
	114	\|\| (!op->inverted && (oldval & op->val) == op->val));
	115	}
	116
	117	/* ----- I2C algorithm call-back functions and structures ----------------- */
	118
	119	static void parport_setscl(void *data, int state)
	120	{
	121	line_set((struct parport *) data, state, &adapter_parm[type].setscl);
	122	}
	123
	124	static void parport_setsda(void *data, int state)
	125	{
	126	line_set((struct parport *) data, state, &adapter_parm[type].setsda);
	127	}
	128
	129	static int parport_getscl(void *data)
	130	{
	131	return line_get((struct parport *) data, &adapter_parm[type].getscl);
	132	}
	133
	134	static int parport_getsda(void *data)
	135	{
	136	return line_get((struct parport *) data, &adapter_parm[type].getsda);
	137	}
	138
	139	/* Encapsulate the functions above in the correct structure.
	140	Note that this is only a template, from which the real structures are
	141	copied. The attaching code will set getscl to NULL for adapters that
614e24be	142	cannot read SCL back, and will also make the data field point to
1da177e4	143	the parallel port structure. */
bfdcad90	144	static const struct i2c_algo_bit_data parport_algo_data = {
1da177e4 LT	145	.setsda = parport_setsda,
	146	.setscl = parport_setscl,
	147	.getsda = parport_getsda,
	148	.getscl = parport_getscl,
3af07bd2	149	.udelay = 10, /* ~50 kbps */
1da177e4	150	.timeout = HZ,
07da0372	151	};
1da177e4 LT	152
	153	/* ----- I2c and parallel port call-back functions and structures --------- */
	154
7fe442a1	155	static void i2c_parport_irq(void *data)
35859254 JD	156	{
	157	struct i2c_par *adapter = data;
	158	struct i2c_client *ara = adapter->ara;
	159
	160	if (ara) {
	161	dev_dbg(&ara->dev, "SMBus alert received\n");
	162	i2c_handle_smbus_alert(ara);
	163	} else
	164	dev_dbg(&adapter->adapter.dev,
	165	"SMBus alert received but no ARA client!\n");
	166	}
	167
07da0372	168	static void i2c_parport_attach(struct parport *port)
1da177e4 LT	169	{
1da177e4 LT	170	struct i2c_par *adapter;
19a4fb21 SM	171	int i;
	172	struct pardev_cb i2c_parport_cb;
	173
	174	for (i = 0; i < MAX_DEVICE; i++) {
	175	if (parport[i] == -1)
	176	continue;
	177	if (port->number == parport[i])
	178	break;
	179	}
	180	if (i == MAX_DEVICE) {
20226118	181	pr_debug("Not using parport%d.\n", port->number);
19a4fb21 SM	182	return;
19a4fb21 SM	183	}
07da0372	184
5263ebb5	185	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
20226118	186	if (!adapter)
1da177e4	187	return;
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	192
20226118	193	pr_debug("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	197	if (!adapter->pdev) {
20226118	198	pr_err("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	301	if (type < 0) {
20226118	302	pr_warn("adapter type unspecified\n");
e97b81dd MH	303	return -ENODEV;
	304	}
	305
	306	if (type >= ARRAY_SIZE(adapter_parm)) {
20226118	307	pr_warn("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);