1 /* ------------------------------------------------------------------------ *
2 * i2c-parport.c I2C bus over parallel port *
3 * ------------------------------------------------------------------------ *
4 Copyright (C) 2003-2007 Jean Delvare <khali@linux-fr.org>
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>
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.
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.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * ------------------------------------------------------------------------ */
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/delay.h>
31 #include <linux/parport.h>
32 #include <linux/i2c.h>
33 #include <linux/i2c-algo-bit.h>
34 #include "i2c-parport.h"
36 /* ----- Device list ------------------------------------------------------ */
39 struct pardevice *pdev;
40 struct i2c_adapter adapter;
41 struct i2c_algo_bit_data algo_data;
45 static struct i2c_par *adapter_list;
47 /* ----- Low-level parallel port access ----------------------------------- */
49 static void port_write_data(struct parport *p, unsigned char d)
51 parport_write_data(p, d);
54 static void port_write_control(struct parport *p, unsigned char d)
56 parport_write_control(p, d);
59 static unsigned char port_read_data(struct parport *p)
61 return parport_read_data(p);
64 static unsigned char port_read_status(struct parport *p)
66 return parport_read_status(p);
69 static unsigned char port_read_control(struct parport *p)
71 return parport_read_control(p);
74 static void (*port_write[])(struct parport *, unsigned char) = {
80 static unsigned char (*port_read[])(struct parport *) = {
86 /* ----- Unified line operation functions --------------------------------- */
88 static inline void line_set(struct parport *data, int state,
89 const struct lineop *op)
91 u8 oldval = port_read[op->port](data);
93 /* Touch only the bit(s) needed */
94 if ((op->inverted && !state) || (!op->inverted && state))
95 port_write[op->port](data, oldval | op->val);
97 port_write[op->port](data, oldval & ~op->val);
100 static inline int line_get(struct parport *data,
101 const struct lineop *op)
103 u8 oldval = port_read[op->port](data);
105 return ((op->inverted && (oldval & op->val) != op->val)
106 || (!op->inverted && (oldval & op->val) == op->val));
109 /* ----- I2C algorithm call-back functions and structures ----------------- */
111 static void parport_setscl(void *data, int state)
113 line_set((struct parport *) data, state, &adapter_parm[type].setscl);
116 static void parport_setsda(void *data, int state)
118 line_set((struct parport *) data, state, &adapter_parm[type].setsda);
121 static int parport_getscl(void *data)
123 return line_get((struct parport *) data, &adapter_parm[type].getscl);
126 static int parport_getsda(void *data)
128 return line_get((struct parport *) data, &adapter_parm[type].getsda);
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
134 cannot read SCL back, and will also make the data field point to
135 the parallel port structure. */
136 static struct i2c_algo_bit_data parport_algo_data = {
137 .setsda = parport_setsda,
138 .setscl = parport_setscl,
139 .getsda = parport_getsda,
140 .getscl = parport_getscl,
141 .udelay = 10, /* ~50 kbps */
145 /* ----- I2c and parallel port call-back functions and structures --------- */
147 static void i2c_parport_attach (struct parport *port)
149 struct i2c_par *adapter;
151 adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
152 if (adapter == NULL) {
153 printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
157 pr_debug("i2c-parport: attaching to %s\n", port->name);
158 adapter->pdev = parport_register_device(port, "i2c-parport",
159 NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL);
160 if (!adapter->pdev) {
161 printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
165 /* Fill the rest of the structure */
166 adapter->adapter.owner = THIS_MODULE;
167 adapter->adapter.class = I2C_CLASS_HWMON;
168 strlcpy(adapter->adapter.name, "Parallel port adapter",
169 sizeof(adapter->adapter.name));
170 adapter->algo_data = parport_algo_data;
171 /* Slow down if we can't sense SCL */
172 if (!adapter_parm[type].getscl.val) {
173 adapter->algo_data.getscl = NULL;
174 adapter->algo_data.udelay = 50; /* ~10 kbps */
176 adapter->algo_data.data = port;
177 adapter->adapter.algo_data = &adapter->algo_data;
178 adapter->adapter.dev.parent = port->physport->dev;
180 if (parport_claim_or_block(adapter->pdev) < 0) {
181 printk(KERN_ERR "i2c-parport: Could not claim parallel port\n");
185 /* Reset hardware to a sane state (SCL and SDA high) */
186 parport_setsda(port, 1);
187 parport_setscl(port, 1);
188 /* Other init if needed (power on...) */
189 if (adapter_parm[type].init.val) {
190 line_set(port, 1, &adapter_parm[type].init);
191 /* Give powered devices some time to settle */
195 if (i2c_bit_add_bus(&adapter->adapter) < 0) {
196 printk(KERN_ERR "i2c-parport: Unable to register with I2C\n");
200 /* Add the new adapter to the list */
201 adapter->next = adapter_list;
202 adapter_list = adapter;
206 parport_release(adapter->pdev);
207 parport_unregister_device(adapter->pdev);
212 static void i2c_parport_detach (struct parport *port)
214 struct i2c_par *adapter, *prev;
217 for (prev = NULL, adapter = adapter_list; adapter;
218 prev = adapter, adapter = adapter->next) {
219 if (adapter->pdev->port == port) {
220 i2c_del_adapter(&adapter->adapter);
222 /* Un-init if needed (power off...) */
223 if (adapter_parm[type].init.val)
224 line_set(port, 0, &adapter_parm[type].init);
226 parport_release(adapter->pdev);
227 parport_unregister_device(adapter->pdev);
229 prev->next = adapter->next;
231 adapter_list = adapter->next;
238 static struct parport_driver i2c_parport_driver = {
239 .name = "i2c-parport",
240 .attach = i2c_parport_attach,
241 .detach = i2c_parport_detach,
244 /* ----- Module loading, unloading and information ------------------------ */
246 static int __init i2c_parport_init(void)
249 printk(KERN_WARNING "i2c-parport: adapter type unspecified\n");
253 if (type >= ARRAY_SIZE(adapter_parm)) {
254 printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
258 return parport_register_driver(&i2c_parport_driver);
261 static void __exit i2c_parport_exit(void)
263 parport_unregister_driver(&i2c_parport_driver);
266 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
267 MODULE_DESCRIPTION("I2C bus over parallel port");
268 MODULE_LICENSE("GPL");
270 module_init(i2c_parport_init);
271 module_exit(i2c_parport_exit);