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 #include "i2c-parport.h"
29
30 /* ----- Device list ------------------------------------------------------ */
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 /* ----- Low-level parallel port access ----------------------------------- */
48
port_write_data(struct parport * p,unsigned char d)49 static void port_write_data(struct parport *p, unsigned char d)
50 {
51 parport_write_data(p, d);
52 }
53
port_write_control(struct parport * p,unsigned char d)54 static void port_write_control(struct parport *p, unsigned char d)
55 {
56 parport_write_control(p, d);
57 }
58
port_read_data(struct parport * p)59 static unsigned char port_read_data(struct parport *p)
60 {
61 return parport_read_data(p);
62 }
63
port_read_status(struct parport * p)64 static unsigned char port_read_status(struct parport *p)
65 {
66 return parport_read_status(p);
67 }
68
port_read_control(struct parport * p)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 /* ----- Unified line operation functions --------------------------------- */
87
line_set(struct parport * data,int state,const struct lineop * op)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 /* Touch only the bit(s) needed */
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
line_get(struct parport * data,const struct lineop * op)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 /* ----- I2C algorithm call-back functions and structures ----------------- */
110
parport_setscl(void * data,int state)111 static void parport_setscl(void *data, int state)
112 {
113 line_set((struct parport *) data, state, &adapter_parm[type].setscl);
114 }
115
parport_setsda(void * data,int state)116 static void parport_setsda(void *data, int state)
117 {
118 line_set((struct parport *) data, state, &adapter_parm[type].setsda);
119 }
120
parport_getscl(void * data)121 static int parport_getscl(void *data)
122 {
123 return line_get((struct parport *) data, &adapter_parm[type].getscl);
124 }
125
parport_getsda(void * data)126 static int parport_getsda(void *data)
127 {
128 return line_get((struct parport *) data, &adapter_parm[type].getsda);
129 }
130
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 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, /* ~50 kbps */
142 .timeout = HZ,
143 };
144
145 /* ----- I2c and parallel port call-back functions and structures --------- */
146
i2c_parport_irq(void * data)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
i2c_parport_attach(struct parport * port)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 /* Fill the rest of the structure */
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 /* Slow down if we can't sense SCL */
201 if (!adapter_parm[type].getscl.val) {
202 adapter->algo_data.getscl = NULL;
203 adapter->algo_data.udelay = 50; /* ~10 kbps */
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 /* Reset hardware to a sane state (SCL and SDA high) */
216 parport_setsda(port, 1);
217 parport_setscl(port, 1);
218 /* Other init if needed (power on...) */
219 if (adapter_parm[type].init.val) {
220 line_set(port, 1, &adapter_parm[type].init);
221 /* Give powered devices some time to settle */
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 /* Setup SMBus alert if supported */
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 /* Add the new adapter to the list */
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
i2c_parport_detach(struct parport * port)254 static void i2c_parport_detach(struct parport *port)
255 {
256 struct i2c_par *adapter, *_n;
257
258 /* Walk the list */
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 /* Un-init if needed (power off...) */
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 /* ----- Module loading, unloading and information ------------------------ */
289
i2c_parport_init(void)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
i2c_parport_exit(void)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);
323
