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