Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * IEEE 1284.3 Parallel port daisy chain and multiplexor code | |
3 | * | |
4 | * Copyright (C) 1999, 2000 Tim Waugh <tim@cyberelk.demon.co.uk> | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License | |
8 | * as published by the Free Software Foundation; either version | |
9 | * 2 of the License, or (at your option) any later version. | |
10 | * | |
11 | * ??-12-1998: Initial implementation. | |
12 | * 31-01-1999: Make port-cloning transparent. | |
13 | * 13-02-1999: Move DeviceID technique from parport_probe. | |
14 | * 13-03-1999: Get DeviceID from non-IEEE 1284.3 devices too. | |
15 | * 22-02-2000: Count devices that are actually detected. | |
16 | * | |
17 | * Any part of this program may be used in documents licensed under | |
18 | * the GNU Free Documentation License, Version 1.1 or any later version | |
19 | * published by the Free Software Foundation. | |
20 | */ | |
21 | ||
22 | #include <linux/module.h> | |
23 | #include <linux/parport.h> | |
24 | #include <linux/delay.h> | |
5a0e3ad6 | 25 | #include <linux/slab.h> |
174cd4b1 | 26 | #include <linux/sched/signal.h> |
1da177e4 LT |
27 | |
28 | #include <asm/current.h> | |
7c0f6ba6 | 29 | #include <linux/uaccess.h> |
1da177e4 LT |
30 | |
31 | #undef DEBUG | |
32 | ||
1da177e4 LT |
33 | static struct daisydev { |
34 | struct daisydev *next; | |
35 | struct parport *port; | |
36 | int daisy; | |
37 | int devnum; | |
38 | } *topology = NULL; | |
39 | static DEFINE_SPINLOCK(topology_lock); | |
40 | ||
df4c756e | 41 | static int numdevs; |
60f8a59d | 42 | static bool daisy_init_done; |
1da177e4 LT |
43 | |
44 | /* Forward-declaration of lower-level functions. */ | |
d32ccc43 MM |
45 | static int mux_present(struct parport *port); |
46 | static int num_mux_ports(struct parport *port); | |
47 | static int select_port(struct parport *port); | |
48 | static int assign_addrs(struct parport *port); | |
1da177e4 LT |
49 | |
50 | /* Add a device to the discovered topology. */ | |
d32ccc43 | 51 | static void add_dev(int devnum, struct parport *port, int daisy) |
1da177e4 LT |
52 | { |
53 | struct daisydev *newdev, **p; | |
d32ccc43 | 54 | newdev = kmalloc(sizeof(struct daisydev), GFP_KERNEL); |
1da177e4 LT |
55 | if (newdev) { |
56 | newdev->port = port; | |
57 | newdev->daisy = daisy; | |
58 | newdev->devnum = devnum; | |
59 | spin_lock(&topology_lock); | |
60 | for (p = &topology; *p && (*p)->devnum<devnum; p = &(*p)->next) | |
61 | ; | |
62 | newdev->next = *p; | |
63 | *p = newdev; | |
64 | spin_unlock(&topology_lock); | |
65 | } | |
66 | } | |
67 | ||
68 | /* Clone a parport (actually, make an alias). */ | |
d32ccc43 | 69 | static struct parport *clone_parport(struct parport *real, int muxport) |
1da177e4 | 70 | { |
d32ccc43 | 71 | struct parport *extra = parport_register_port(real->base, |
1da177e4 LT |
72 | real->irq, |
73 | real->dma, | |
74 | real->ops); | |
75 | if (extra) { | |
76 | extra->portnum = real->portnum; | |
77 | extra->physport = real; | |
78 | extra->muxport = muxport; | |
79 | real->slaves[muxport-1] = extra; | |
80 | } | |
81 | ||
82 | return extra; | |
83 | } | |
84 | ||
60f8a59d SM |
85 | static int daisy_drv_probe(struct pardevice *par_dev) |
86 | { | |
87 | struct device_driver *drv = par_dev->dev.driver; | |
88 | ||
89 | if (strcmp(drv->name, "daisy_drv")) | |
90 | return -ENODEV; | |
91 | if (strcmp(par_dev->name, daisy_dev_name)) | |
92 | return -ENODEV; | |
93 | ||
94 | return 0; | |
95 | } | |
96 | ||
97 | static struct parport_driver daisy_driver = { | |
98 | .name = "daisy_drv", | |
99 | .probe = daisy_drv_probe, | |
100 | .devmodel = true, | |
101 | }; | |
102 | ||
1da177e4 LT |
103 | /* Discover the IEEE1284.3 topology on a port -- muxes and daisy chains. |
104 | * Return value is number of devices actually detected. */ | |
d32ccc43 | 105 | int parport_daisy_init(struct parport *port) |
1da177e4 LT |
106 | { |
107 | int detected = 0; | |
108 | char *deviceid; | |
109 | static const char *th[] = { /*0*/"th", "st", "nd", "rd", "th" }; | |
110 | int num_ports; | |
111 | int i; | |
112 | int last_try = 0; | |
113 | ||
60f8a59d SM |
114 | if (!daisy_init_done) { |
115 | /* | |
116 | * flag should be marked true first as | |
117 | * parport_register_driver() might try to load the low | |
118 | * level driver which will lead to announcing new ports | |
119 | * and which will again come back here at | |
120 | * parport_daisy_init() | |
121 | */ | |
122 | daisy_init_done = true; | |
123 | i = parport_register_driver(&daisy_driver); | |
124 | if (i) { | |
125 | pr_err("daisy registration failed\n"); | |
126 | daisy_init_done = false; | |
127 | return i; | |
128 | } | |
129 | } | |
130 | ||
1da177e4 LT |
131 | again: |
132 | /* Because this is called before any other devices exist, | |
133 | * we don't have to claim exclusive access. */ | |
134 | ||
135 | /* If mux present on normal port, need to create new | |
136 | * parports for each extra port. */ | |
d32ccc43 | 137 | if (port->muxport < 0 && mux_present(port) && |
1da177e4 | 138 | /* don't be fooled: a mux must have 2 or 4 ports. */ |
d32ccc43 | 139 | ((num_ports = num_mux_ports(port)) == 2 || num_ports == 4)) { |
1da177e4 LT |
140 | /* Leave original as port zero. */ |
141 | port->muxport = 0; | |
decf26f6 | 142 | pr_info("%s: 1st (default) port of %d-way multiplexor\n", |
1da177e4 LT |
143 | port->name, num_ports); |
144 | for (i = 1; i < num_ports; i++) { | |
145 | /* Clone the port. */ | |
d32ccc43 | 146 | struct parport *extra = clone_parport(port, i); |
1da177e4 | 147 | if (!extra) { |
d32ccc43 | 148 | if (signal_pending(current)) |
1da177e4 LT |
149 | break; |
150 | ||
d32ccc43 | 151 | schedule(); |
1da177e4 LT |
152 | continue; |
153 | } | |
154 | ||
decf26f6 | 155 | pr_info("%s: %d%s port of %d-way multiplexor on %s\n", |
1da177e4 LT |
156 | extra->name, i + 1, th[i + 1], num_ports, |
157 | port->name); | |
158 | ||
159 | /* Analyse that port too. We won't recurse | |
160 | forever because of the 'port->muxport < 0' | |
161 | test above. */ | |
162 | parport_daisy_init(extra); | |
163 | } | |
164 | } | |
165 | ||
166 | if (port->muxport >= 0) | |
d32ccc43 | 167 | select_port(port); |
1da177e4 | 168 | |
d32ccc43 MM |
169 | parport_daisy_deselect_all(port); |
170 | detected += assign_addrs(port); | |
1da177e4 LT |
171 | |
172 | /* Count the potential legacy device at the end. */ | |
d32ccc43 | 173 | add_dev(numdevs++, port, -1); |
1da177e4 LT |
174 | |
175 | /* Find out the legacy device's IEEE 1284 device ID. */ | |
d32ccc43 | 176 | deviceid = kmalloc(1024, GFP_KERNEL); |
1da177e4 | 177 | if (deviceid) { |
d32ccc43 | 178 | if (parport_device_id(numdevs - 1, deviceid, 1024) > 2) |
1da177e4 LT |
179 | detected++; |
180 | ||
d32ccc43 | 181 | kfree(deviceid); |
1da177e4 LT |
182 | } |
183 | ||
184 | if (!detected && !last_try) { | |
185 | /* No devices were detected. Perhaps they are in some | |
186 | funny state; let's try to reset them and see if | |
187 | they wake up. */ | |
d32ccc43 MM |
188 | parport_daisy_fini(port); |
189 | parport_write_control(port, PARPORT_CONTROL_SELECT); | |
190 | udelay(50); | |
191 | parport_write_control(port, | |
1da177e4 LT |
192 | PARPORT_CONTROL_SELECT | |
193 | PARPORT_CONTROL_INIT); | |
d32ccc43 | 194 | udelay(50); |
1da177e4 LT |
195 | last_try = 1; |
196 | goto again; | |
197 | } | |
198 | ||
199 | return detected; | |
200 | } | |
201 | ||
202 | /* Forget about devices on a physical port. */ | |
d32ccc43 | 203 | void parport_daisy_fini(struct parport *port) |
1da177e4 LT |
204 | { |
205 | struct daisydev **p; | |
206 | ||
207 | spin_lock(&topology_lock); | |
208 | p = &topology; | |
209 | while (*p) { | |
210 | struct daisydev *dev = *p; | |
211 | if (dev->port != port) { | |
212 | p = &dev->next; | |
213 | continue; | |
214 | } | |
215 | *p = dev->next; | |
216 | kfree(dev); | |
217 | } | |
218 | ||
219 | /* Gaps in the numbering could be handled better. How should | |
220 | someone enumerate through all IEEE1284.3 devices in the | |
221 | topology?. */ | |
222 | if (!topology) numdevs = 0; | |
223 | spin_unlock(&topology_lock); | |
224 | return; | |
225 | } | |
226 | ||
227 | /** | |
228 | * parport_open - find a device by canonical device number | |
229 | * @devnum: canonical device number | |
230 | * @name: name to associate with the device | |
1da177e4 LT |
231 | * |
232 | * This function is similar to parport_register_device(), except | |
233 | * that it locates a device by its number rather than by the port | |
234 | * it is attached to. | |
235 | * | |
236 | * All parameters except for @devnum are the same as for | |
237 | * parport_register_device(). The return value is the same as | |
238 | * for parport_register_device(). | |
239 | **/ | |
240 | ||
5712cb3d | 241 | struct pardevice *parport_open(int devnum, const char *name) |
1da177e4 LT |
242 | { |
243 | struct daisydev *p = topology; | |
60f8a59d | 244 | struct pardev_cb par_cb; |
1da177e4 LT |
245 | struct parport *port; |
246 | struct pardevice *dev; | |
247 | int daisy; | |
248 | ||
60f8a59d | 249 | memset(&par_cb, 0, sizeof(par_cb)); |
1da177e4 LT |
250 | spin_lock(&topology_lock); |
251 | while (p && p->devnum != devnum) | |
252 | p = p->next; | |
253 | ||
254 | if (!p) { | |
255 | spin_unlock(&topology_lock); | |
256 | return NULL; | |
257 | } | |
258 | ||
259 | daisy = p->daisy; | |
260 | port = parport_get_port(p->port); | |
261 | spin_unlock(&topology_lock); | |
262 | ||
60f8a59d | 263 | dev = parport_register_dev_model(port, name, &par_cb, devnum); |
1da177e4 LT |
264 | parport_put_port(port); |
265 | if (!dev) | |
266 | return NULL; | |
267 | ||
268 | dev->daisy = daisy; | |
269 | ||
270 | /* Check that there really is a device to select. */ | |
271 | if (daisy >= 0) { | |
272 | int selected; | |
d32ccc43 | 273 | parport_claim_or_block(dev); |
1da177e4 | 274 | selected = port->daisy; |
d32ccc43 | 275 | parport_release(dev); |
1da177e4 | 276 | |
c29a75ed | 277 | if (selected != daisy) { |
1da177e4 | 278 | /* No corresponding device. */ |
d32ccc43 | 279 | parport_unregister_device(dev); |
1da177e4 LT |
280 | return NULL; |
281 | } | |
282 | } | |
283 | ||
284 | return dev; | |
285 | } | |
286 | ||
287 | /** | |
288 | * parport_close - close a device opened with parport_open() | |
289 | * @dev: device to close | |
290 | * | |
291 | * This is to parport_open() as parport_unregister_device() is to | |
292 | * parport_register_device(). | |
293 | **/ | |
294 | ||
d32ccc43 | 295 | void parport_close(struct pardevice *dev) |
1da177e4 | 296 | { |
d32ccc43 | 297 | parport_unregister_device(dev); |
1da177e4 LT |
298 | } |
299 | ||
1da177e4 | 300 | /* Send a daisy-chain-style CPP command packet. */ |
d32ccc43 | 301 | static int cpp_daisy(struct parport *port, int cmd) |
1da177e4 LT |
302 | { |
303 | unsigned char s; | |
304 | ||
d32ccc43 MM |
305 | parport_data_forward(port); |
306 | parport_write_data(port, 0xaa); udelay(2); | |
307 | parport_write_data(port, 0x55); udelay(2); | |
308 | parport_write_data(port, 0x00); udelay(2); | |
309 | parport_write_data(port, 0xff); udelay(2); | |
310 | s = parport_read_status(port) & (PARPORT_STATUS_BUSY | |
1da177e4 LT |
311 | | PARPORT_STATUS_PAPEROUT |
312 | | PARPORT_STATUS_SELECT | |
313 | | PARPORT_STATUS_ERROR); | |
314 | if (s != (PARPORT_STATUS_BUSY | |
315 | | PARPORT_STATUS_PAPEROUT | |
316 | | PARPORT_STATUS_SELECT | |
317 | | PARPORT_STATUS_ERROR)) { | |
88c5cbde | 318 | pr_debug("%s: cpp_daisy: aa5500ff(%02x)\n", port->name, s); |
1da177e4 LT |
319 | return -ENXIO; |
320 | } | |
321 | ||
d32ccc43 MM |
322 | parport_write_data(port, 0x87); udelay(2); |
323 | s = parport_read_status(port) & (PARPORT_STATUS_BUSY | |
1da177e4 LT |
324 | | PARPORT_STATUS_PAPEROUT |
325 | | PARPORT_STATUS_SELECT | |
326 | | PARPORT_STATUS_ERROR); | |
327 | if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) { | |
88c5cbde | 328 | pr_debug("%s: cpp_daisy: aa5500ff87(%02x)\n", port->name, s); |
1da177e4 LT |
329 | return -ENXIO; |
330 | } | |
331 | ||
d32ccc43 MM |
332 | parport_write_data(port, 0x78); udelay(2); |
333 | parport_write_data(port, cmd); udelay(2); | |
334 | parport_frob_control(port, | |
1da177e4 LT |
335 | PARPORT_CONTROL_STROBE, |
336 | PARPORT_CONTROL_STROBE); | |
d32ccc43 MM |
337 | udelay(1); |
338 | s = parport_read_status(port); | |
339 | parport_frob_control(port, PARPORT_CONTROL_STROBE, 0); | |
340 | udelay(1); | |
341 | parport_write_data(port, 0xff); udelay(2); | |
1da177e4 LT |
342 | |
343 | return s; | |
344 | } | |
345 | ||
346 | /* Send a mux-style CPP command packet. */ | |
d32ccc43 | 347 | static int cpp_mux(struct parport *port, int cmd) |
1da177e4 LT |
348 | { |
349 | unsigned char s; | |
350 | int rc; | |
351 | ||
d32ccc43 MM |
352 | parport_data_forward(port); |
353 | parport_write_data(port, 0xaa); udelay(2); | |
354 | parport_write_data(port, 0x55); udelay(2); | |
355 | parport_write_data(port, 0xf0); udelay(2); | |
356 | parport_write_data(port, 0x0f); udelay(2); | |
357 | parport_write_data(port, 0x52); udelay(2); | |
358 | parport_write_data(port, 0xad); udelay(2); | |
359 | parport_write_data(port, cmd); udelay(2); | |
1da177e4 | 360 | |
d32ccc43 | 361 | s = parport_read_status(port); |
1da177e4 | 362 | if (!(s & PARPORT_STATUS_ACK)) { |
88c5cbde | 363 | pr_debug("%s: cpp_mux: aa55f00f52ad%02x(%02x)\n", |
1da177e4 LT |
364 | port->name, cmd, s); |
365 | return -EIO; | |
366 | } | |
367 | ||
368 | rc = (((s & PARPORT_STATUS_SELECT ? 1 : 0) << 0) | | |
369 | ((s & PARPORT_STATUS_PAPEROUT ? 1 : 0) << 1) | | |
370 | ((s & PARPORT_STATUS_BUSY ? 0 : 1) << 2) | | |
371 | ((s & PARPORT_STATUS_ERROR ? 0 : 1) << 3)); | |
372 | ||
373 | return rc; | |
374 | } | |
375 | ||
d32ccc43 | 376 | void parport_daisy_deselect_all(struct parport *port) |
1da177e4 | 377 | { |
d32ccc43 | 378 | cpp_daisy(port, 0x30); |
1da177e4 LT |
379 | } |
380 | ||
d32ccc43 | 381 | int parport_daisy_select(struct parport *port, int daisy, int mode) |
1da177e4 LT |
382 | { |
383 | switch (mode) | |
384 | { | |
385 | // For these modes we should switch to EPP mode: | |
386 | case IEEE1284_MODE_EPP: | |
387 | case IEEE1284_MODE_EPPSL: | |
388 | case IEEE1284_MODE_EPPSWE: | |
d32ccc43 | 389 | return !(cpp_daisy(port, 0x20 + daisy) & |
7c9cc3be | 390 | PARPORT_STATUS_ERROR); |
1da177e4 LT |
391 | |
392 | // For these modes we should switch to ECP mode: | |
393 | case IEEE1284_MODE_ECP: | |
394 | case IEEE1284_MODE_ECPRLE: | |
395 | case IEEE1284_MODE_ECPSWE: | |
d32ccc43 | 396 | return !(cpp_daisy(port, 0xd0 + daisy) & |
7c9cc3be | 397 | PARPORT_STATUS_ERROR); |
1da177e4 LT |
398 | |
399 | // Nothing was told for BECP in Daisy chain specification. | |
400 | // May be it's wise to use ECP? | |
401 | case IEEE1284_MODE_BECP: | |
402 | // Others use compat mode | |
403 | case IEEE1284_MODE_NIBBLE: | |
404 | case IEEE1284_MODE_BYTE: | |
405 | case IEEE1284_MODE_COMPAT: | |
406 | default: | |
d32ccc43 | 407 | return !(cpp_daisy(port, 0xe0 + daisy) & |
7c9cc3be | 408 | PARPORT_STATUS_ERROR); |
1da177e4 LT |
409 | } |
410 | } | |
411 | ||
d32ccc43 | 412 | static int mux_present(struct parport *port) |
1da177e4 | 413 | { |
d32ccc43 | 414 | return cpp_mux(port, 0x51) == 3; |
1da177e4 LT |
415 | } |
416 | ||
d32ccc43 | 417 | static int num_mux_ports(struct parport *port) |
1da177e4 | 418 | { |
d32ccc43 | 419 | return cpp_mux(port, 0x58); |
1da177e4 LT |
420 | } |
421 | ||
d32ccc43 | 422 | static int select_port(struct parport *port) |
1da177e4 LT |
423 | { |
424 | int muxport = port->muxport; | |
d32ccc43 | 425 | return cpp_mux(port, 0x60 + muxport) == muxport; |
1da177e4 LT |
426 | } |
427 | ||
d32ccc43 | 428 | static int assign_addrs(struct parport *port) |
1da177e4 | 429 | { |
310c8c32 | 430 | unsigned char s; |
1da177e4 LT |
431 | unsigned char daisy; |
432 | int thisdev = numdevs; | |
433 | int detected; | |
434 | char *deviceid; | |
435 | ||
d32ccc43 MM |
436 | parport_data_forward(port); |
437 | parport_write_data(port, 0xaa); udelay(2); | |
438 | parport_write_data(port, 0x55); udelay(2); | |
439 | parport_write_data(port, 0x00); udelay(2); | |
440 | parport_write_data(port, 0xff); udelay(2); | |
441 | s = parport_read_status(port) & (PARPORT_STATUS_BUSY | |
1da177e4 LT |
442 | | PARPORT_STATUS_PAPEROUT |
443 | | PARPORT_STATUS_SELECT | |
444 | | PARPORT_STATUS_ERROR); | |
445 | if (s != (PARPORT_STATUS_BUSY | |
446 | | PARPORT_STATUS_PAPEROUT | |
447 | | PARPORT_STATUS_SELECT | |
448 | | PARPORT_STATUS_ERROR)) { | |
88c5cbde | 449 | pr_debug("%s: assign_addrs: aa5500ff(%02x)\n", port->name, s); |
1da177e4 LT |
450 | return 0; |
451 | } | |
452 | ||
d32ccc43 MM |
453 | parport_write_data(port, 0x87); udelay(2); |
454 | s = parport_read_status(port) & (PARPORT_STATUS_BUSY | |
1da177e4 LT |
455 | | PARPORT_STATUS_PAPEROUT |
456 | | PARPORT_STATUS_SELECT | |
457 | | PARPORT_STATUS_ERROR); | |
458 | if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) { | |
88c5cbde | 459 | pr_debug("%s: assign_addrs: aa5500ff87(%02x)\n", port->name, s); |
1da177e4 LT |
460 | return 0; |
461 | } | |
462 | ||
d32ccc43 MM |
463 | parport_write_data(port, 0x78); udelay(2); |
464 | s = parport_read_status(port); | |
1da177e4 | 465 | |
310c8c32 MK |
466 | for (daisy = 0; |
467 | (s & (PARPORT_STATUS_PAPEROUT|PARPORT_STATUS_SELECT)) | |
468 | == (PARPORT_STATUS_PAPEROUT|PARPORT_STATUS_SELECT) | |
469 | && daisy < 4; | |
470 | ++daisy) { | |
d32ccc43 MM |
471 | parport_write_data(port, daisy); |
472 | udelay(2); | |
473 | parport_frob_control(port, | |
1da177e4 LT |
474 | PARPORT_CONTROL_STROBE, |
475 | PARPORT_CONTROL_STROBE); | |
d32ccc43 MM |
476 | udelay(1); |
477 | parport_frob_control(port, PARPORT_CONTROL_STROBE, 0); | |
478 | udelay(1); | |
1da177e4 | 479 | |
d32ccc43 | 480 | add_dev(numdevs++, port, daisy); |
1da177e4 | 481 | |
310c8c32 MK |
482 | /* See if this device thought it was the last in the |
483 | * chain. */ | |
484 | if (!(s & PARPORT_STATUS_BUSY)) | |
485 | break; | |
1da177e4 | 486 | |
310c8c32 MK |
487 | /* We are seeing pass through status now. We see |
488 | last_dev from next device or if last_dev does not | |
489 | work status lines from some non-daisy chain | |
490 | device. */ | |
d32ccc43 | 491 | s = parport_read_status(port); |
1da177e4 LT |
492 | } |
493 | ||
d32ccc43 | 494 | parport_write_data(port, 0xff); udelay(2); |
1da177e4 | 495 | detected = numdevs - thisdev; |
88c5cbde | 496 | pr_debug("%s: Found %d daisy-chained devices\n", port->name, detected); |
1da177e4 LT |
497 | |
498 | /* Ask the new devices to introduce themselves. */ | |
d32ccc43 | 499 | deviceid = kmalloc(1024, GFP_KERNEL); |
1da177e4 LT |
500 | if (!deviceid) return 0; |
501 | ||
502 | for (daisy = 0; thisdev < numdevs; thisdev++, daisy++) | |
d32ccc43 | 503 | parport_device_id(thisdev, deviceid, 1024); |
1da177e4 | 504 | |
d32ccc43 | 505 | kfree(deviceid); |
1da177e4 LT |
506 | return detected; |
507 | } |