1// SPDX-License-Identifier: GPL-2.0-or-later
2/* ------------------------------------------------------------------------ *
3 * i2c-parport.c I2C bus over parallel port                                 *
4 * ------------------------------------------------------------------------ *
5   Copyright (C) 2003-2011 Jean Delvare <jdelvare@suse.de>
6
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>
11   Kyösti Mälkki <kmalkki@cc.hut.fi>
12
13 * ------------------------------------------------------------------------ */
14
15#define pr_fmt(fmt) "i2c-parport: " fmt
16
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/init.h>
20#include <linux/delay.h>
21#include <linux/parport.h>
22#include <linux/i2c.h>
23#include <linux/i2c-algo-bit.h>
24#include <linux/i2c-smbus.h>
25#include <linux/slab.h>
26#include <linux/list.h>
27#include <linux/mutex.h>
28
29#define PORT_DATA	0
30#define PORT_STAT	1
31#define PORT_CTRL	2
32
33struct lineop {
34	u8 val;
35	u8 port;
36	u8 inverted;
37};
38
39struct adapter_parm {
40	struct lineop setsda;
41	struct lineop setscl;
42	struct lineop getsda;
43	struct lineop getscl;
44	struct lineop init;
45	unsigned int smbus_alert:1;
46};
47
48static const struct adapter_parm adapter_parm[] = {
49	/* type 0: Philips adapter */
50	{
51		.setsda	= { 0x80, PORT_DATA, 1 },
52		.setscl	= { 0x08, PORT_CTRL, 0 },
53		.getsda	= { 0x80, PORT_STAT, 0 },
54		.getscl	= { 0x08, PORT_STAT, 0 },
55	},
56	/* type 1: home brew teletext adapter */
57	{
58		.setsda	= { 0x02, PORT_DATA, 0 },
59		.setscl	= { 0x01, PORT_DATA, 0 },
60		.getsda	= { 0x80, PORT_STAT, 1 },
61	},
62	/* type 2: Velleman K8000 adapter */
63	{
64		.setsda	= { 0x02, PORT_CTRL, 1 },
65		.setscl	= { 0x08, PORT_CTRL, 1 },
66		.getsda	= { 0x10, PORT_STAT, 0 },
67	},
68	/* type 3: ELV adapter */
69	{
70		.setsda	= { 0x02, PORT_DATA, 1 },
71		.setscl	= { 0x01, PORT_DATA, 1 },
72		.getsda	= { 0x40, PORT_STAT, 1 },
73		.getscl	= { 0x08, PORT_STAT, 1 },
74	},
75	/* type 4: ADM1032 evaluation board */
76	{
77		.setsda	= { 0x02, PORT_DATA, 1 },
78		.setscl	= { 0x01, PORT_DATA, 1 },
79		.getsda	= { 0x10, PORT_STAT, 1 },
80		.init	= { 0xf0, PORT_DATA, 0 },
81		.smbus_alert = 1,
82	},
83	/* type 5: ADM1025, ADM1030 and ADM1031 evaluation boards */
84	{
85		.setsda	= { 0x02, PORT_DATA, 1 },
86		.setscl	= { 0x01, PORT_DATA, 1 },
87		.getsda	= { 0x10, PORT_STAT, 1 },
88	},
89	/* type 6: Barco LPT->DVI (K5800236) adapter */
90	{
91		.setsda	= { 0x02, PORT_DATA, 1 },
92		.setscl	= { 0x01, PORT_DATA, 1 },
93		.getsda	= { 0x20, PORT_STAT, 0 },
94		.getscl	= { 0x40, PORT_STAT, 0 },
95		.init	= { 0xfc, PORT_DATA, 0 },
96	},
97	/* type 7: One For All JP1 parallel port adapter */
98	{
99		.setsda	= { 0x01, PORT_DATA, 0 },
100		.setscl	= { 0x02, PORT_DATA, 0 },
101		.getsda	= { 0x80, PORT_STAT, 1 },
102		.init	= { 0x04, PORT_DATA, 1 },
103	},
104	/* type 8: VCT-jig */
105	{
106		.setsda	= { 0x04, PORT_DATA, 1 },
107		.setscl	= { 0x01, PORT_DATA, 1 },
108		.getsda	= { 0x40, PORT_STAT, 0 },
109		.getscl	= { 0x80, PORT_STAT, 1 },
110	},
111};
112
113/* ----- Device list ------------------------------------------------------ */
114
115struct i2c_par {
116	struct pardevice *pdev;
117	struct i2c_adapter adapter;
118	struct i2c_algo_bit_data algo_data;
119	struct i2c_smbus_alert_setup alert_data;
120	struct i2c_client *ara;
121	struct list_head node;
122};
123
124static LIST_HEAD(adapter_list);
125static DEFINE_MUTEX(adapter_list_lock);
126
127#define MAX_DEVICE 4
128static int parport[MAX_DEVICE] = {0, -1, -1, -1};
129module_param_array(parport, int, NULL, 0);
130MODULE_PARM_DESC(parport,
131		 "List of parallel ports to bind to, by index.\n"
132		 " At most " __stringify(MAX_DEVICE) " devices are supported.\n"
133		 " Default is one device connected to parport0.\n"
134);
135
136static int type = -1;
137module_param(type, int, 0);
138MODULE_PARM_DESC(type,
139	"Type of adapter:\n"
140	" 0 = Philips adapter\n"
141	" 1 = home brew teletext adapter\n"
142	" 2 = Velleman K8000 adapter\n"
143	" 3 = ELV adapter\n"
144	" 4 = ADM1032 evaluation board\n"
145	" 5 = ADM1025, ADM1030 and ADM1031 evaluation boards\n"
146	" 6 = Barco LPT->DVI (K5800236) adapter\n"
147	" 7 = One For All JP1 parallel port adapter\n"
148	" 8 = VCT-jig\n"
149);
150
151/* ----- Low-level parallel port access ----------------------------------- */
152
153static void port_write_data(struct parport *p, unsigned char d)
154{
155	parport_write_data(p, d);
156}
157
158static void port_write_control(struct parport *p, unsigned char d)
159{
160	parport_write_control(p, d);
161}
162
163static unsigned char port_read_data(struct parport *p)
164{
165	return parport_read_data(p);
166}
167
168static unsigned char port_read_status(struct parport *p)
169{
170	return parport_read_status(p);
171}
172
173static unsigned char port_read_control(struct parport *p)
174{
175	return parport_read_control(p);
176}
177
178static void (* const port_write[])(struct parport *, unsigned char) = {
179	port_write_data,
180	NULL,
181	port_write_control,
182};
183
184static unsigned char (* const port_read[])(struct parport *) = {
185	port_read_data,
186	port_read_status,
187	port_read_control,
188};
189
190/* ----- Unified line operation functions --------------------------------- */
191
192static inline void line_set(struct parport *data, int state,
193	const struct lineop *op)
194{
195	u8 oldval = port_read[op->port](data);
196
197	/* Touch only the bit(s) needed */
198	if ((op->inverted && !state) || (!op->inverted && state))
199		port_write[op->port](data, oldval | op->val);
200	else
201		port_write[op->port](data, oldval & ~op->val);
202}
203
204static inline int line_get(struct parport *data,
205	const struct lineop *op)
206{
207	u8 oldval = port_read[op->port](data);
208
209	return ((op->inverted && (oldval & op->val) != op->val)
210	    || (!op->inverted && (oldval & op->val) == op->val));
211}
212
213/* ----- I2C algorithm call-back functions and structures ----------------- */
214
215static void parport_setscl(void *data, int state)
216{
217	line_set((struct parport *) data, state, &adapter_parm[type].setscl);
218}
219
220static void parport_setsda(void *data, int state)
221{
222	line_set((struct parport *) data, state, &adapter_parm[type].setsda);
223}
224
225static int parport_getscl(void *data)
226{
227	return line_get((struct parport *) data, &adapter_parm[type].getscl);
228}
229
230static int parport_getsda(void *data)
231{
232	return line_get((struct parport *) data, &adapter_parm[type].getsda);
233}
234
235/* Encapsulate the functions above in the correct structure.
236   Note that this is only a template, from which the real structures are
237   copied. The attaching code will set getscl to NULL for adapters that
238   cannot read SCL back, and will also make the data field point to
239   the parallel port structure. */
240static const struct i2c_algo_bit_data parport_algo_data = {
241	.setsda		= parport_setsda,
242	.setscl		= parport_setscl,
243	.getsda		= parport_getsda,
244	.getscl		= parport_getscl,
245	.udelay		= 10, /* ~50 kbps */
246	.timeout	= HZ,
247};
248
249/* ----- I2c and parallel port call-back functions and structures --------- */
250
251static void i2c_parport_irq(void *data)
252{
253	struct i2c_par *adapter = data;
254	struct i2c_client *ara = adapter->ara;
255
256	if (ara) {
257		dev_dbg(&ara->dev, "SMBus alert received\n");
258		i2c_handle_smbus_alert(ara);
259	} else
260		dev_dbg(&adapter->adapter.dev,
261			"SMBus alert received but no ARA client!\n");
262}
263
264static void i2c_parport_attach(struct parport *port)
265{
266	struct i2c_par *adapter;
267	int i;
268	struct pardev_cb i2c_parport_cb;
269
270	for (i = 0; i < MAX_DEVICE; i++) {
271		if (parport[i] == -1)
272			continue;
273		if (port->number == parport[i])
274			break;
275	}
276	if (i == MAX_DEVICE) {
277		pr_debug("Not using parport%d.\n", port->number);
278		return;
279	}
280
281	adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
282	if (!adapter)
283		return;
284	memset(&i2c_parport_cb, 0, sizeof(i2c_parport_cb));
285	i2c_parport_cb.flags = PARPORT_FLAG_EXCL;
286	i2c_parport_cb.irq_func = i2c_parport_irq;
287	i2c_parport_cb.private = adapter;
288
289	pr_debug("attaching to %s\n", port->name);
290	parport_disable_irq(port);
291	adapter->pdev = parport_register_dev_model(port, "i2c-parport",
292						   &i2c_parport_cb, i);
293	if (!adapter->pdev) {
294		pr_err("Unable to register with parport\n");
295		goto err_free;
296	}
297
298	/* Fill the rest of the structure */
299	adapter->adapter.owner = THIS_MODULE;
300	adapter->adapter.class = I2C_CLASS_HWMON;
301	strlcpy(adapter->adapter.name, "Parallel port adapter",
302		sizeof(adapter->adapter.name));
303	adapter->algo_data = parport_algo_data;
304	/* Slow down if we can't sense SCL */
305	if (!adapter_parm[type].getscl.val) {
306		adapter->algo_data.getscl = NULL;
307		adapter->algo_data.udelay = 50; /* ~10 kbps */
308	}
309	adapter->algo_data.data = port;
310	adapter->adapter.algo_data = &adapter->algo_data;
311	adapter->adapter.dev.parent = port->physport->dev;
312
313	if (parport_claim_or_block(adapter->pdev) < 0) {
314		dev_err(&adapter->pdev->dev,
315			"Could not claim parallel port\n");
316		goto err_unregister;
317	}
318
319	/* Reset hardware to a sane state (SCL and SDA high) */
320	parport_setsda(port, 1);
321	parport_setscl(port, 1);
322	/* Other init if needed (power on...) */
323	if (adapter_parm[type].init.val) {
324		line_set(port, 1, &adapter_parm[type].init);
325		/* Give powered devices some time to settle */
326		msleep(100);
327	}
328
329	if (i2c_bit_add_bus(&adapter->adapter) < 0) {
330		dev_err(&adapter->pdev->dev, "Unable to register with I2C\n");
331		goto err_unregister;
332	}
333
334	/* Setup SMBus alert if supported */
335	if (adapter_parm[type].smbus_alert) {
336		struct i2c_client *ara;
337
338		ara = i2c_new_smbus_alert_device(&adapter->adapter,
339						 &adapter->alert_data);
340		if (!IS_ERR(ara)) {
341			adapter->ara = ara;
342			parport_enable_irq(port);
343		} else {
344			dev_warn(&adapter->pdev->dev,
345				 "Failed to register ARA client\n");
346		}
347	}
348
349	/* Add the new adapter to the list */
350	mutex_lock(&adapter_list_lock);
351	list_add_tail(&adapter->node, &adapter_list);
352	mutex_unlock(&adapter_list_lock);
353	return;
354
355 err_unregister:
356	parport_release(adapter->pdev);
357	parport_unregister_device(adapter->pdev);
358 err_free:
359	kfree(adapter);
360}
361
362static void i2c_parport_detach(struct parport *port)
363{
364	struct i2c_par *adapter, *_n;
365
366	/* Walk the list */
367	mutex_lock(&adapter_list_lock);
368	list_for_each_entry_safe(adapter, _n, &adapter_list, node) {
369		if (adapter->pdev->port == port) {
370			if (adapter->ara) {
371				parport_disable_irq(port);
372				i2c_unregister_device(adapter->ara);
373			}
374			i2c_del_adapter(&adapter->adapter);
375
376			/* Un-init if needed (power off...) */
377			if (adapter_parm[type].init.val)
378				line_set(port, 0, &adapter_parm[type].init);
379
380			parport_release(adapter->pdev);
381			parport_unregister_device(adapter->pdev);
382			list_del(&adapter->node);
383			kfree(adapter);
384		}
385	}
386	mutex_unlock(&adapter_list_lock);
387}
388
389static struct parport_driver i2c_parport_driver = {
390	.name = "i2c-parport",
391	.match_port = i2c_parport_attach,
392	.detach = i2c_parport_detach,
393	.devmodel = true,
394};
395
396/* ----- Module loading, unloading and information ------------------------ */
397
398static int __init i2c_parport_init(void)
399{
400	if (type < 0) {
401		pr_warn("adapter type unspecified\n");
402		return -ENODEV;
403	}
404
405	if (type >= ARRAY_SIZE(adapter_parm)) {
406		pr_warn("invalid type (%d)\n", type);
407		return -ENODEV;
408	}
409
410	return parport_register_driver(&i2c_parport_driver);
411}
412
413static void __exit i2c_parport_exit(void)
414{
415	parport_unregister_driver(&i2c_parport_driver);
416}
417
418MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
419MODULE_DESCRIPTION("I2C bus over parallel port");
420MODULE_LICENSE("GPL");
421
422module_init(i2c_parport_init);
423module_exit(i2c_parport_exit);
424