1 /* ------------------------------------------------------------------------ *
2 * i2c-parport.c I2C bus over parallel port *
3 * ------------------------------------------------------------------------ *
4 Copyright (C) 2003-2007 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 = 10, /* ~50 kbps */
141 .timeout = HZ,
142 };
143
144 /* ----- I2c and parallel port call-back functions and structures --------- */
145
146 static void i2c_parport_attach (struct parport *port)
147 {
148 struct i2c_par *adapter;
149
150 adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
151 if (adapter == NULL) {
152 printk(KERN_ERR "i2c-parport: Failed to kzalloc\n");
153 return;
154 }
155
156 pr_debug("i2c-parport: attaching to %s\n", port->name);
157 adapter->pdev = parport_register_device(port, "i2c-parport",
158 NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL);
159 if (!adapter->pdev) {
160 printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
161 goto ERROR0;
162 }
163
164 /* Fill the rest of the structure */
165 adapter->adapter.owner = THIS_MODULE;
166 adapter->adapter.class = I2C_CLASS_HWMON;
167 strlcpy(adapter->adapter.name, "Parallel port adapter",
168 sizeof(adapter->adapter.name));
169 adapter->algo_data = parport_algo_data;
170 /* Slow down if we can't sense SCL */
171 if (!adapter_parm[type].getscl.val) {
172 adapter->algo_data.getscl = NULL;
173 adapter->algo_data.udelay = 50; /* ~10 kbps */
174 }
175 adapter->algo_data.data = port;
176 adapter->adapter.algo_data = &adapter->algo_data;
177 adapter->adapter.dev.parent = port->physport->dev;
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 if (i2c_bit_add_bus(&adapter->adapter) < 0) {
192 printk(KERN_ERR "i2c-parport: Unable to register with I2C\n");
193 goto ERROR1;
194 }
195
196 /* Add the new adapter to the list */
197 adapter->next = adapter_list;
198 adapter_list = adapter;
199 return;
200
201 ERROR1:
202 parport_release(adapter->pdev);
203 parport_unregister_device(adapter->pdev);
204 ERROR0:
205 kfree(adapter);
206 }
207
208 static void i2c_parport_detach (struct parport *port)
209 {
210 struct i2c_par *adapter, *prev;
211
212 /* Walk the list */
213 for (prev = NULL, adapter = adapter_list; adapter;
214 prev = adapter, adapter = adapter->next) {
215 if (adapter->pdev->port == port) {
216 i2c_del_adapter(&adapter->adapter);
217
218 /* Un-init if needed (power off...) */
219 if (adapter_parm[type].init.val)
220 line_set(port, 0, &adapter_parm[type].init);
221
222 parport_release(adapter->pdev);
223 parport_unregister_device(adapter->pdev);
224 if (prev)
225 prev->next = adapter->next;
226 else
227 adapter_list = adapter->next;
228 kfree(adapter);
229 return;
230 }
231 }
232 }
233
234 static struct parport_driver i2c_parport_driver = {
235 .name = "i2c-parport",
236 .attach = i2c_parport_attach,
237 .detach = i2c_parport_detach,
238 };
239
240 /* ----- Module loading, unloading and information ------------------------ */
241
242 static int __init i2c_parport_init(void)
243 {
244 if (type < 0) {
245 printk(KERN_WARNING "i2c-parport: adapter type unspecified\n");
246 return -ENODEV;
247 }
248
249 if (type >= ARRAY_SIZE(adapter_parm)) {
250 printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
251 return -ENODEV;
252 }
253
254 return parport_register_driver(&i2c_parport_driver);
255 }
256
257 static void __exit i2c_parport_exit(void)
258 {
259 parport_unregister_driver(&i2c_parport_driver);
260 }
261
262 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
263 MODULE_DESCRIPTION("I2C bus over parallel port");
264 MODULE_LICENSE("GPL");
265
266 module_init(i2c_parport_init);
267 module_exit(i2c_parport_exit);
268
|
This page was automatically generated by the
LXR engine.
|