Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfashe...
[linux-2.6] / drivers / i2c / busses / i2c-parport.c
1 /* ------------------------------------------------------------------------ *
2  * i2c-parport.c I2C bus over parallel port                                 *
3  * ------------------------------------------------------------------------ *
4    Copyright (C) 2003-2004 Jean Delvare <khali@linux-fr.org>
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    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  * ------------------------------------------------------------------------ */
26
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/parport.h>
31 #include <linux/i2c.h>
32 #include <linux/i2c-algo-bit.h>
33 #include "i2c-parport.h"
34
35 /* ----- Device list ------------------------------------------------------ */
36
37 struct i2c_par {
38         struct pardevice *pdev;
39         struct i2c_adapter adapter;
40         struct i2c_algo_bit_data algo_data;
41         struct i2c_par *next;
42 };
43
44 static struct i2c_par *adapter_list;
45
46 /* ----- Low-level parallel port access ----------------------------------- */
47
48 static void port_write_data(struct parport *p, unsigned char d)
49 {
50         parport_write_data(p, d);
51 }
52
53 static void port_write_control(struct parport *p, unsigned char d)
54 {
55         parport_write_control(p, d);
56 }
57
58 static unsigned char port_read_data(struct parport *p)
59 {
60         return parport_read_data(p);
61 }
62
63 static unsigned char port_read_status(struct parport *p)
64 {
65         return parport_read_status(p);
66 }
67
68 static unsigned char port_read_control(struct parport *p)
69 {
70         return parport_read_control(p);
71 }
72
73 static void (*port_write[])(struct parport *, unsigned char) = {
74         port_write_data,
75         NULL,
76         port_write_control,
77 };
78
79 static unsigned char (*port_read[])(struct parport *) = {
80         port_read_data,
81         port_read_status,
82         port_read_control,
83 };
84
85 /* ----- Unified line operation functions --------------------------------- */
86
87 static inline void line_set(struct parport *data, int state,
88         const struct lineop *op)
89 {
90         u8 oldval = port_read[op->port](data);
91
92         /* Touch only the bit(s) needed */
93         if ((op->inverted && !state) || (!op->inverted && state))
94                 port_write[op->port](data, oldval | op->val);
95         else
96                 port_write[op->port](data, oldval & ~op->val);
97 }
98
99 static inline int line_get(struct parport *data,
100         const struct lineop *op)
101 {
102         u8 oldval = port_read[op->port](data);
103
104         return ((op->inverted && (oldval & op->val) != op->val)
105             || (!op->inverted && (oldval & op->val) == op->val));
106 }
107
108 /* ----- I2C algorithm call-back functions and structures ----------------- */
109
110 static void parport_setscl(void *data, int state)
111 {
112         line_set((struct parport *) data, state, &adapter_parm[type].setscl);
113 }
114
115 static void parport_setsda(void *data, int state)
116 {
117         line_set((struct parport *) data, state, &adapter_parm[type].setsda);
118 }
119
120 static int parport_getscl(void *data)
121 {
122         return line_get((struct parport *) data, &adapter_parm[type].getscl);
123 }
124
125 static int parport_getsda(void *data)
126 {
127         return line_get((struct parport *) data, &adapter_parm[type].getsda);
128 }
129
130 /* Encapsulate the functions above in the correct structure.
131    Note that this is only a template, from which the real structures are
132    copied. The attaching code will set getscl to NULL for adapters that
133    cannot read SCL back, and will also make the data field point to
134    the parallel port structure. */
135 static struct i2c_algo_bit_data parport_algo_data = {
136         .setsda         = parport_setsda,
137         .setscl         = parport_setscl,
138         .getsda         = parport_getsda,
139         .getscl         = parport_getscl,
140         .udelay         = 60,
141         .timeout        = HZ,
142 }; 
143
144 /* ----- I2c and parallel port call-back functions and structures --------- */
145
146 static struct i2c_adapter parport_adapter = {
147         .owner          = THIS_MODULE,
148         .class          = I2C_CLASS_HWMON,
149         .id             = I2C_HW_B_LP,
150         .name           = "Parallel port adapter",
151 };
152
153 static void i2c_parport_attach (struct parport *port)
154 {
155         struct i2c_par *adapter;
156         
157         adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
158         if (adapter == NULL) {
159                 printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
160                 return;
161         }
162
163         pr_debug("i2c-parport: attaching to %s\n", port->name);
164         adapter->pdev = parport_register_device(port, "i2c-parport",
165                 NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL);
166         if (!adapter->pdev) {
167                 printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
168                 goto ERROR0;
169         }
170
171         /* Fill the rest of the structure */
172         adapter->adapter = parport_adapter;
173         adapter->algo_data = parport_algo_data;
174         if (!adapter_parm[type].getscl.val)
175                 adapter->algo_data.getscl = NULL;
176         adapter->algo_data.data = port;
177         adapter->adapter.algo_data = &adapter->algo_data;
178
179         if (parport_claim_or_block(adapter->pdev) < 0) {
180                 printk(KERN_ERR "i2c-parport: Could not claim parallel port\n");
181                 goto ERROR1;
182         }
183
184         /* Reset hardware to a sane state (SCL and SDA high) */
185         parport_setsda(port, 1);
186         parport_setscl(port, 1);
187         /* Other init if needed (power on...) */
188         if (adapter_parm[type].init.val)
189                 line_set(port, 1, &adapter_parm[type].init);
190
191         parport_release(adapter->pdev);
192
193         if (i2c_bit_add_bus(&adapter->adapter) < 0) {
194                 printk(KERN_ERR "i2c-parport: Unable to register with I2C\n");
195                 goto ERROR1;
196         }
197
198         /* Add the new adapter to the list */
199         adapter->next = adapter_list;
200         adapter_list = adapter;
201         return;
202
203 ERROR1:
204         parport_unregister_device(adapter->pdev);
205 ERROR0:
206         kfree(adapter);
207 }
208
209 static void i2c_parport_detach (struct parport *port)
210 {
211         struct i2c_par *adapter, *prev;
212
213         /* Walk the list */
214         for (prev = NULL, adapter = adapter_list; adapter;
215              prev = adapter, adapter = adapter->next) {
216                 if (adapter->pdev->port == port) {
217                         /* Un-init if needed (power off...) */
218                         if (adapter_parm[type].init.val)
219                                 line_set(port, 0, &adapter_parm[type].init);
220                                 
221                         i2c_del_adapter(&adapter->adapter);
222                         parport_unregister_device(adapter->pdev);
223                         if (prev)
224                                 prev->next = adapter->next;
225                         else
226                                 adapter_list = adapter->next;
227                         kfree(adapter);
228                         return;
229                 }
230         }
231 }
232
233 static struct parport_driver i2c_parport_driver = {
234         .name   = "i2c-parport",
235         .attach = i2c_parport_attach,
236         .detach = i2c_parport_detach,
237 };
238
239 /* ----- Module loading, unloading and information ------------------------ */
240
241 static int __init i2c_parport_init(void)
242 {
243         if (type < 0) {
244                 printk(KERN_WARNING "i2c-parport: adapter type unspecified\n");
245                 return -ENODEV;
246         }
247
248         if (type >= ARRAY_SIZE(adapter_parm)) {
249                 printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
250                 return -ENODEV;
251         }
252
253         return parport_register_driver(&i2c_parport_driver);
254 }
255
256 static void __exit i2c_parport_exit(void)
257 {
258         parport_unregister_driver(&i2c_parport_driver);
259 }
260
261 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
262 MODULE_DESCRIPTION("I2C bus over parallel port");
263 MODULE_LICENSE("GPL");
264
265 module_init(i2c_parport_init);
266 module_exit(i2c_parport_exit);