This source file includes following definitions.
- port_write_data
- port_write_control
- port_read_data
- port_read_status
- port_read_control
- line_set
- line_get
- parport_setscl
- parport_setsda
- parport_getscl
- parport_getsda
- i2c_parport_irq
- i2c_parport_attach
- i2c_parport_detach
- i2c_parport_init
- i2c_parport_exit
1
2
3
4
5
6
7
8
9
10
11
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 #include "i2c-parport.h"
29
30
31
32 struct i2c_par {
33 struct pardevice *pdev;
34 struct i2c_adapter adapter;
35 struct i2c_algo_bit_data algo_data;
36 struct i2c_smbus_alert_setup alert_data;
37 struct i2c_client *ara;
38 struct list_head node;
39 };
40
41 static LIST_HEAD(adapter_list);
42 static DEFINE_MUTEX(adapter_list_lock);
43 #define MAX_DEVICE 4
44 static int parport[MAX_DEVICE] = {0, -1, -1, -1};
45
46
47
48
49 static void port_write_data(struct parport *p, unsigned char d)
50 {
51 parport_write_data(p, d);
52 }
53
54 static void port_write_control(struct parport *p, unsigned char d)
55 {
56 parport_write_control(p, d);
57 }
58
59 static unsigned char port_read_data(struct parport *p)
60 {
61 return parport_read_data(p);
62 }
63
64 static unsigned char port_read_status(struct parport *p)
65 {
66 return parport_read_status(p);
67 }
68
69 static unsigned char port_read_control(struct parport *p)
70 {
71 return parport_read_control(p);
72 }
73
74 static void (* const port_write[])(struct parport *, unsigned char) = {
75 port_write_data,
76 NULL,
77 port_write_control,
78 };
79
80 static unsigned char (* const port_read[])(struct parport *) = {
81 port_read_data,
82 port_read_status,
83 port_read_control,
84 };
85
86
87
88 static inline void line_set(struct parport *data, int state,
89 const struct lineop *op)
90 {
91 u8 oldval = port_read[op->port](data);
92
93
94 if ((op->inverted && !state) || (!op->inverted && state))
95 port_write[op->port](data, oldval | op->val);
96 else
97 port_write[op->port](data, oldval & ~op->val);
98 }
99
100 static inline int line_get(struct parport *data,
101 const struct lineop *op)
102 {
103 u8 oldval = port_read[op->port](data);
104
105 return ((op->inverted && (oldval & op->val) != op->val)
106 || (!op->inverted && (oldval & op->val) == op->val));
107 }
108
109
110
111 static void parport_setscl(void *data, int state)
112 {
113 line_set((struct parport *) data, state, &adapter_parm[type].setscl);
114 }
115
116 static void parport_setsda(void *data, int state)
117 {
118 line_set((struct parport *) data, state, &adapter_parm[type].setsda);
119 }
120
121 static int parport_getscl(void *data)
122 {
123 return line_get((struct parport *) data, &adapter_parm[type].getscl);
124 }
125
126 static int parport_getsda(void *data)
127 {
128 return line_get((struct parport *) data, &adapter_parm[type].getsda);
129 }
130
131
132
133
134
135
136 static const 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,
142 .timeout = HZ,
143 };
144
145
146
147 static void i2c_parport_irq(void *data)
148 {
149 struct i2c_par *adapter = data;
150 struct i2c_client *ara = adapter->ara;
151
152 if (ara) {
153 dev_dbg(&ara->dev, "SMBus alert received\n");
154 i2c_handle_smbus_alert(ara);
155 } else
156 dev_dbg(&adapter->adapter.dev,
157 "SMBus alert received but no ARA client!\n");
158 }
159
160 static void i2c_parport_attach(struct parport *port)
161 {
162 struct i2c_par *adapter;
163 int i;
164 struct pardev_cb i2c_parport_cb;
165
166 for (i = 0; i < MAX_DEVICE; i++) {
167 if (parport[i] == -1)
168 continue;
169 if (port->number == parport[i])
170 break;
171 }
172 if (i == MAX_DEVICE) {
173 pr_debug("Not using parport%d.\n", port->number);
174 return;
175 }
176
177 adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
178 if (!adapter)
179 return;
180 memset(&i2c_parport_cb, 0, sizeof(i2c_parport_cb));
181 i2c_parport_cb.flags = PARPORT_FLAG_EXCL;
182 i2c_parport_cb.irq_func = i2c_parport_irq;
183 i2c_parport_cb.private = adapter;
184
185 pr_debug("attaching to %s\n", port->name);
186 parport_disable_irq(port);
187 adapter->pdev = parport_register_dev_model(port, "i2c-parport",
188 &i2c_parport_cb, i);
189 if (!adapter->pdev) {
190 pr_err("Unable to register with parport\n");
191 goto err_free;
192 }
193
194
195 adapter->adapter.owner = THIS_MODULE;
196 adapter->adapter.class = I2C_CLASS_HWMON;
197 strlcpy(adapter->adapter.name, "Parallel port adapter",
198 sizeof(adapter->adapter.name));
199 adapter->algo_data = parport_algo_data;
200
201 if (!adapter_parm[type].getscl.val) {
202 adapter->algo_data.getscl = NULL;
203 adapter->algo_data.udelay = 50;
204 }
205 adapter->algo_data.data = port;
206 adapter->adapter.algo_data = &adapter->algo_data;
207 adapter->adapter.dev.parent = port->physport->dev;
208
209 if (parport_claim_or_block(adapter->pdev) < 0) {
210 dev_err(&adapter->pdev->dev,
211 "Could not claim parallel port\n");
212 goto err_unregister;
213 }
214
215
216 parport_setsda(port, 1);
217 parport_setscl(port, 1);
218
219 if (adapter_parm[type].init.val) {
220 line_set(port, 1, &adapter_parm[type].init);
221
222 msleep(100);
223 }
224
225 if (i2c_bit_add_bus(&adapter->adapter) < 0) {
226 dev_err(&adapter->pdev->dev, "Unable to register with I2C\n");
227 goto err_unregister;
228 }
229
230
231 if (adapter_parm[type].smbus_alert) {
232 adapter->ara = i2c_setup_smbus_alert(&adapter->adapter,
233 &adapter->alert_data);
234 if (adapter->ara)
235 parport_enable_irq(port);
236 else
237 dev_warn(&adapter->pdev->dev,
238 "Failed to register ARA client\n");
239 }
240
241
242 mutex_lock(&adapter_list_lock);
243 list_add_tail(&adapter->node, &adapter_list);
244 mutex_unlock(&adapter_list_lock);
245 return;
246
247 err_unregister:
248 parport_release(adapter->pdev);
249 parport_unregister_device(adapter->pdev);
250 err_free:
251 kfree(adapter);
252 }
253
254 static void i2c_parport_detach(struct parport *port)
255 {
256 struct i2c_par *adapter, *_n;
257
258
259 mutex_lock(&adapter_list_lock);
260 list_for_each_entry_safe(adapter, _n, &adapter_list, node) {
261 if (adapter->pdev->port == port) {
262 if (adapter->ara) {
263 parport_disable_irq(port);
264 i2c_unregister_device(adapter->ara);
265 }
266 i2c_del_adapter(&adapter->adapter);
267
268
269 if (adapter_parm[type].init.val)
270 line_set(port, 0, &adapter_parm[type].init);
271
272 parport_release(adapter->pdev);
273 parport_unregister_device(adapter->pdev);
274 list_del(&adapter->node);
275 kfree(adapter);
276 }
277 }
278 mutex_unlock(&adapter_list_lock);
279 }
280
281 static struct parport_driver i2c_parport_driver = {
282 .name = "i2c-parport",
283 .match_port = i2c_parport_attach,
284 .detach = i2c_parport_detach,
285 .devmodel = true,
286 };
287
288
289
290 static int __init i2c_parport_init(void)
291 {
292 if (type < 0) {
293 pr_warn("adapter type unspecified\n");
294 return -ENODEV;
295 }
296
297 if (type >= ARRAY_SIZE(adapter_parm)) {
298 pr_warn("invalid type (%d)\n", type);
299 return -ENODEV;
300 }
301
302 return parport_register_driver(&i2c_parport_driver);
303 }
304
305 static void __exit i2c_parport_exit(void)
306 {
307 parport_unregister_driver(&i2c_parport_driver);
308 }
309
310 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
311 MODULE_DESCRIPTION("I2C bus over parallel port");
312 MODULE_LICENSE("GPL");
313
314 module_param_array(parport, int, NULL, 0);
315 MODULE_PARM_DESC(parport,
316 "List of parallel ports to bind to, by index.\n"
317 " Atmost " __stringify(MAX_DEVICE) " devices are supported.\n"
318 " Default is one device connected to parport0.\n"
319 );
320
321 module_init(i2c_parport_init);
322 module_exit(i2c_parport_exit);