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