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

// SPDX-License-Identifier: GPL-2.0-or-later
/* ------------------------------------------------------------------------ *
 * 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>

 * ------------------------------------------------------------------------ */

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