xref: /openbmc/linux/drivers/char/ppdev.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
2  * linux/drivers/char/ppdev.c
3  *
4  * This is the code behind /dev/parport* -- it allows a user-space
5  * application to use the parport subsystem.
6  *
7  * Copyright (C) 1998-2000, 2002 Tim Waugh <tim@cyberelk.net>
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version
12  * 2 of the License, or (at your option) any later version.
13  *
14  * A /dev/parportx device node represents an arbitrary device
15  * on port 'x'.  The following operations are possible:
16  *
17  * open		do nothing, set up default IEEE 1284 protocol to be COMPAT
18  * close	release port and unregister device (if necessary)
19  * ioctl
20  *   EXCL	register device exclusively (may fail)
21  *   CLAIM	(register device first time) parport_claim_or_block
22  *   RELEASE	parport_release
23  *   SETMODE	set the IEEE 1284 protocol to use for read/write
24  *   SETPHASE	set the IEEE 1284 phase of a particular mode.  Not to be
25  *              confused with ioctl(fd, SETPHASER, &stun). ;-)
26  *   DATADIR	data_forward / data_reverse
27  *   WDATA	write_data
28  *   RDATA	read_data
29  *   WCONTROL	write_control
30  *   RCONTROL	read_control
31  *   FCONTROL	frob_control
32  *   RSTATUS	read_status
33  *   NEGOT	parport_negotiate
34  *   YIELD	parport_yield_blocking
35  *   WCTLONIRQ	on interrupt, set control lines
36  *   CLRIRQ	clear (and return) interrupt count
37  *   SETTIME	sets device timeout (struct timeval)
38  *   GETTIME	gets device timeout (struct timeval)
39  *   GETMODES	gets hardware supported modes (unsigned int)
40  *   GETMODE	gets the current IEEE1284 mode
41  *   GETPHASE   gets the current IEEE1284 phase
42  *   GETFLAGS   gets current (user-visible) flags
43  *   SETFLAGS   sets current (user-visible) flags
44  * read/write	read or write in current IEEE 1284 protocol
45  * select	wait for interrupt (in readfds)
46  *
47  * Changes:
48  * Added SETTIME/GETTIME ioctl, Fred Barnes, 1999.
49  *
50  * Arnaldo Carvalho de Melo <acme@conectiva.com.br> 2000/08/25
51  * - On error, copy_from_user and copy_to_user do not return -EFAULT,
52  *   They return the positive number of bytes *not* copied due to address
53  *   space errors.
54  *
55  * Added GETMODES/GETMODE/GETPHASE ioctls, Fred Barnes <frmb2@ukc.ac.uk>, 03/01/2001.
56  * Added GETFLAGS/SETFLAGS ioctls, Fred Barnes, 04/2001
57  */
58 
59 #include <linux/module.h>
60 #include <linux/init.h>
61 #include <linux/sched.h>
62 #include <linux/device.h>
63 #include <linux/ioctl.h>
64 #include <linux/parport.h>
65 #include <linux/ctype.h>
66 #include <linux/poll.h>
67 #include <linux/major.h>
68 #include <linux/ppdev.h>
69 #include <linux/device.h>
70 #include <asm/uaccess.h>
71 
72 #define PP_VERSION "ppdev: user-space parallel port driver"
73 #define CHRDEV "ppdev"
74 
75 struct pp_struct {
76 	struct pardevice * pdev;
77 	wait_queue_head_t irq_wait;
78 	atomic_t irqc;
79 	unsigned int flags;
80 	int irqresponse;
81 	unsigned char irqctl;
82 	struct ieee1284_info state;
83 	struct ieee1284_info saved_state;
84 	long default_inactivity;
85 };
86 
87 /* pp_struct.flags bitfields */
88 #define PP_CLAIMED    (1<<0)
89 #define PP_EXCL       (1<<1)
90 
91 /* Other constants */
92 #define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
93 #define PP_BUFFER_SIZE 1024
94 #define PARDEVICE_MAX 8
95 
96 /* ROUND_UP macro from fs/select.c */
97 #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
98 
99 static inline void pp_enable_irq (struct pp_struct *pp)
100 {
101 	struct parport *port = pp->pdev->port;
102 	port->ops->enable_irq (port);
103 }
104 
105 static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
106 			loff_t * ppos)
107 {
108 	unsigned int minor = iminor(file->f_path.dentry->d_inode);
109 	struct pp_struct *pp = file->private_data;
110 	char * kbuffer;
111 	ssize_t bytes_read = 0;
112 	struct parport *pport;
113 	int mode;
114 
115 	if (!(pp->flags & PP_CLAIMED)) {
116 		/* Don't have the port claimed */
117 		printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
118 			minor);
119 		return -EINVAL;
120 	}
121 
122 	/* Trivial case. */
123 	if (count == 0)
124 		return 0;
125 
126 	kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
127 	if (!kbuffer) {
128 		return -ENOMEM;
129 	}
130 	pport = pp->pdev->port;
131 	mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
132 
133 	parport_set_timeout (pp->pdev,
134 			     (file->f_flags & O_NONBLOCK) ?
135 			     PARPORT_INACTIVITY_O_NONBLOCK :
136 			     pp->default_inactivity);
137 
138 	while (bytes_read == 0) {
139 		ssize_t need = min_t(unsigned long, count, PP_BUFFER_SIZE);
140 
141 		if (mode == IEEE1284_MODE_EPP) {
142 			/* various specials for EPP mode */
143 			int flags = 0;
144 			size_t (*fn)(struct parport *, void *, size_t, int);
145 
146 			if (pp->flags & PP_W91284PIC) {
147 				flags |= PARPORT_W91284PIC;
148 			}
149 			if (pp->flags & PP_FASTREAD) {
150 				flags |= PARPORT_EPP_FAST;
151 			}
152 			if (pport->ieee1284.mode & IEEE1284_ADDR) {
153 				fn = pport->ops->epp_read_addr;
154 			} else {
155 				fn = pport->ops->epp_read_data;
156 			}
157 			bytes_read = (*fn)(pport, kbuffer, need, flags);
158 		} else {
159 			bytes_read = parport_read (pport, kbuffer, need);
160 		}
161 
162 		if (bytes_read != 0)
163 			break;
164 
165 		if (file->f_flags & O_NONBLOCK) {
166 			bytes_read = -EAGAIN;
167 			break;
168 		}
169 
170 		if (signal_pending (current)) {
171 			bytes_read = -ERESTARTSYS;
172 			break;
173 		}
174 
175 		cond_resched();
176 	}
177 
178 	parport_set_timeout (pp->pdev, pp->default_inactivity);
179 
180 	if (bytes_read > 0 && copy_to_user (buf, kbuffer, bytes_read))
181 		bytes_read = -EFAULT;
182 
183 	kfree (kbuffer);
184 	pp_enable_irq (pp);
185 	return bytes_read;
186 }
187 
188 static ssize_t pp_write (struct file * file, const char __user * buf,
189 			 size_t count, loff_t * ppos)
190 {
191 	unsigned int minor = iminor(file->f_path.dentry->d_inode);
192 	struct pp_struct *pp = file->private_data;
193 	char * kbuffer;
194 	ssize_t bytes_written = 0;
195 	ssize_t wrote;
196 	int mode;
197 	struct parport *pport;
198 
199 	if (!(pp->flags & PP_CLAIMED)) {
200 		/* Don't have the port claimed */
201 		printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
202 			minor);
203 		return -EINVAL;
204 	}
205 
206 	kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
207 	if (!kbuffer) {
208 		return -ENOMEM;
209 	}
210 	pport = pp->pdev->port;
211 	mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
212 
213 	parport_set_timeout (pp->pdev,
214 			     (file->f_flags & O_NONBLOCK) ?
215 			     PARPORT_INACTIVITY_O_NONBLOCK :
216 			     pp->default_inactivity);
217 
218 	while (bytes_written < count) {
219 		ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
220 
221 		if (copy_from_user (kbuffer, buf + bytes_written, n)) {
222 			bytes_written = -EFAULT;
223 			break;
224 		}
225 
226 		if ((pp->flags & PP_FASTWRITE) && (mode == IEEE1284_MODE_EPP)) {
227 			/* do a fast EPP write */
228 			if (pport->ieee1284.mode & IEEE1284_ADDR) {
229 				wrote = pport->ops->epp_write_addr (pport,
230 					kbuffer, n, PARPORT_EPP_FAST);
231 			} else {
232 				wrote = pport->ops->epp_write_data (pport,
233 					kbuffer, n, PARPORT_EPP_FAST);
234 			}
235 		} else {
236 			wrote = parport_write (pp->pdev->port, kbuffer, n);
237 		}
238 
239 		if (wrote <= 0) {
240 			if (!bytes_written) {
241 				bytes_written = wrote;
242 			}
243 			break;
244 		}
245 
246 		bytes_written += wrote;
247 
248 		if (file->f_flags & O_NONBLOCK) {
249 			if (!bytes_written)
250 				bytes_written = -EAGAIN;
251 			break;
252 		}
253 
254 		if (signal_pending (current)) {
255 			if (!bytes_written) {
256 				bytes_written = -EINTR;
257 			}
258 			break;
259 		}
260 
261 		cond_resched();
262 	}
263 
264 	parport_set_timeout (pp->pdev, pp->default_inactivity);
265 
266 	kfree (kbuffer);
267 	pp_enable_irq (pp);
268 	return bytes_written;
269 }
270 
271 static void pp_irq (int irq, void * private)
272 {
273 	struct pp_struct * pp = (struct pp_struct *) private;
274 
275 	if (pp->irqresponse) {
276 		parport_write_control (pp->pdev->port, pp->irqctl);
277 		pp->irqresponse = 0;
278 	}
279 
280 	atomic_inc (&pp->irqc);
281 	wake_up_interruptible (&pp->irq_wait);
282 }
283 
284 static int register_device (int minor, struct pp_struct *pp)
285 {
286 	struct parport *port;
287 	struct pardevice * pdev = NULL;
288 	char *name;
289 	int fl;
290 
291 	name = kmalloc (strlen (CHRDEV) + 3, GFP_KERNEL);
292 	if (name == NULL)
293 		return -ENOMEM;
294 
295 	sprintf (name, CHRDEV "%x", minor);
296 
297 	port = parport_find_number (minor);
298 	if (!port) {
299 		printk (KERN_WARNING "%s: no associated port!\n", name);
300 		kfree (name);
301 		return -ENXIO;
302 	}
303 
304 	fl = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0;
305 	pdev = parport_register_device (port, name, NULL,
306 					NULL, pp_irq, fl, pp);
307 	parport_put_port (port);
308 
309 	if (!pdev) {
310 		printk (KERN_WARNING "%s: failed to register device!\n", name);
311 		kfree (name);
312 		return -ENXIO;
313 	}
314 
315 	pp->pdev = pdev;
316 	printk (KERN_DEBUG "%s: registered pardevice\n", name);
317 	return 0;
318 }
319 
320 static enum ieee1284_phase init_phase (int mode)
321 {
322 	switch (mode & ~(IEEE1284_DEVICEID
323 			 | IEEE1284_ADDR)) {
324 	case IEEE1284_MODE_NIBBLE:
325 	case IEEE1284_MODE_BYTE:
326 		return IEEE1284_PH_REV_IDLE;
327 	}
328 	return IEEE1284_PH_FWD_IDLE;
329 }
330 
331 static int pp_ioctl(struct inode *inode, struct file *file,
332 		    unsigned int cmd, unsigned long arg)
333 {
334 	unsigned int minor = iminor(inode);
335 	struct pp_struct *pp = file->private_data;
336 	struct parport * port;
337 	void __user *argp = (void __user *)arg;
338 
339 	/* First handle the cases that don't take arguments. */
340 	switch (cmd) {
341 	case PPCLAIM:
342 	    {
343 		struct ieee1284_info *info;
344 		int ret;
345 
346 		if (pp->flags & PP_CLAIMED) {
347 			printk (KERN_DEBUG CHRDEV
348 				"%x: you've already got it!\n", minor);
349 			return -EINVAL;
350 		}
351 
352 		/* Deferred device registration. */
353 		if (!pp->pdev) {
354 			int err = register_device (minor, pp);
355 			if (err) {
356 				return err;
357 			}
358 		}
359 
360 		ret = parport_claim_or_block (pp->pdev);
361 		if (ret < 0)
362 			return ret;
363 
364 		pp->flags |= PP_CLAIMED;
365 
366 		/* For interrupt-reporting to work, we need to be
367 		 * informed of each interrupt. */
368 		pp_enable_irq (pp);
369 
370 		/* We may need to fix up the state machine. */
371 		info = &pp->pdev->port->ieee1284;
372 		pp->saved_state.mode = info->mode;
373 		pp->saved_state.phase = info->phase;
374 		info->mode = pp->state.mode;
375 		info->phase = pp->state.phase;
376 		pp->default_inactivity = parport_set_timeout (pp->pdev, 0);
377 		parport_set_timeout (pp->pdev, pp->default_inactivity);
378 
379 		return 0;
380 	    }
381 	case PPEXCL:
382 		if (pp->pdev) {
383 			printk (KERN_DEBUG CHRDEV "%x: too late for PPEXCL; "
384 				"already registered\n", minor);
385 			if (pp->flags & PP_EXCL)
386 				/* But it's not really an error. */
387 				return 0;
388 			/* There's no chance of making the driver happy. */
389 			return -EINVAL;
390 		}
391 
392 		/* Just remember to register the device exclusively
393 		 * when we finally do the registration. */
394 		pp->flags |= PP_EXCL;
395 		return 0;
396 	case PPSETMODE:
397 	    {
398 		int mode;
399 		if (copy_from_user (&mode, argp, sizeof (mode)))
400 			return -EFAULT;
401 		/* FIXME: validate mode */
402 		pp->state.mode = mode;
403 		pp->state.phase = init_phase (mode);
404 
405 		if (pp->flags & PP_CLAIMED) {
406 			pp->pdev->port->ieee1284.mode = mode;
407 			pp->pdev->port->ieee1284.phase = pp->state.phase;
408 		}
409 
410 		return 0;
411 	    }
412 	case PPGETMODE:
413 	    {
414 		int mode;
415 
416 		if (pp->flags & PP_CLAIMED) {
417 			mode = pp->pdev->port->ieee1284.mode;
418 		} else {
419 			mode = pp->state.mode;
420 		}
421 		if (copy_to_user (argp, &mode, sizeof (mode))) {
422 			return -EFAULT;
423 		}
424 		return 0;
425 	    }
426 	case PPSETPHASE:
427 	    {
428 		int phase;
429 		if (copy_from_user (&phase, argp, sizeof (phase))) {
430 			return -EFAULT;
431 		}
432 		/* FIXME: validate phase */
433 		pp->state.phase = phase;
434 
435 		if (pp->flags & PP_CLAIMED) {
436 			pp->pdev->port->ieee1284.phase = phase;
437 		}
438 
439 		return 0;
440 	    }
441 	case PPGETPHASE:
442 	    {
443 		int phase;
444 
445 		if (pp->flags & PP_CLAIMED) {
446 			phase = pp->pdev->port->ieee1284.phase;
447 		} else {
448 			phase = pp->state.phase;
449 		}
450 		if (copy_to_user (argp, &phase, sizeof (phase))) {
451 			return -EFAULT;
452 		}
453 		return 0;
454 	    }
455 	case PPGETMODES:
456 	    {
457 		unsigned int modes;
458 
459 		port = parport_find_number (minor);
460 		if (!port)
461 			return -ENODEV;
462 
463 		modes = port->modes;
464 		if (copy_to_user (argp, &modes, sizeof (modes))) {
465 			return -EFAULT;
466 		}
467 		return 0;
468 	    }
469 	case PPSETFLAGS:
470 	    {
471 		int uflags;
472 
473 		if (copy_from_user (&uflags, argp, sizeof (uflags))) {
474 			return -EFAULT;
475 		}
476 		pp->flags &= ~PP_FLAGMASK;
477 		pp->flags |= (uflags & PP_FLAGMASK);
478 		return 0;
479 	    }
480 	case PPGETFLAGS:
481 	    {
482 		int uflags;
483 
484 		uflags = pp->flags & PP_FLAGMASK;
485 		if (copy_to_user (argp, &uflags, sizeof (uflags))) {
486 			return -EFAULT;
487 		}
488 		return 0;
489 	    }
490 	}	/* end switch() */
491 
492 	/* Everything else requires the port to be claimed, so check
493 	 * that now. */
494 	if ((pp->flags & PP_CLAIMED) == 0) {
495 		printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
496 			minor);
497 		return -EINVAL;
498 	}
499 
500 	port = pp->pdev->port;
501 	switch (cmd) {
502 		struct ieee1284_info *info;
503 		unsigned char reg;
504 		unsigned char mask;
505 		int mode;
506 		int ret;
507 		struct timeval par_timeout;
508 		long to_jiffies;
509 
510 	case PPRSTATUS:
511 		reg = parport_read_status (port);
512 		if (copy_to_user (argp, &reg, sizeof (reg)))
513 			return -EFAULT;
514 		return 0;
515 	case PPRDATA:
516 		reg = parport_read_data (port);
517 		if (copy_to_user (argp, &reg, sizeof (reg)))
518 			return -EFAULT;
519 		return 0;
520 	case PPRCONTROL:
521 		reg = parport_read_control (port);
522 		if (copy_to_user (argp, &reg, sizeof (reg)))
523 			return -EFAULT;
524 		return 0;
525 	case PPYIELD:
526 		parport_yield_blocking (pp->pdev);
527 		return 0;
528 
529 	case PPRELEASE:
530 		/* Save the state machine's state. */
531 		info = &pp->pdev->port->ieee1284;
532 		pp->state.mode = info->mode;
533 		pp->state.phase = info->phase;
534 		info->mode = pp->saved_state.mode;
535 		info->phase = pp->saved_state.phase;
536 		parport_release (pp->pdev);
537 		pp->flags &= ~PP_CLAIMED;
538 		return 0;
539 
540 	case PPWCONTROL:
541 		if (copy_from_user (&reg, argp, sizeof (reg)))
542 			return -EFAULT;
543 		parport_write_control (port, reg);
544 		return 0;
545 
546 	case PPWDATA:
547 		if (copy_from_user (&reg, argp, sizeof (reg)))
548 			return -EFAULT;
549 		parport_write_data (port, reg);
550 		return 0;
551 
552 	case PPFCONTROL:
553 		if (copy_from_user (&mask, argp,
554 				    sizeof (mask)))
555 			return -EFAULT;
556 		if (copy_from_user (&reg, 1 + (unsigned char __user *) arg,
557 				    sizeof (reg)))
558 			return -EFAULT;
559 		parport_frob_control (port, mask, reg);
560 		return 0;
561 
562 	case PPDATADIR:
563 		if (copy_from_user (&mode, argp, sizeof (mode)))
564 			return -EFAULT;
565 		if (mode)
566 			port->ops->data_reverse (port);
567 		else
568 			port->ops->data_forward (port);
569 		return 0;
570 
571 	case PPNEGOT:
572 		if (copy_from_user (&mode, argp, sizeof (mode)))
573 			return -EFAULT;
574 		switch ((ret = parport_negotiate (port, mode))) {
575 		case 0: break;
576 		case -1: /* handshake failed, peripheral not IEEE 1284 */
577 			ret = -EIO;
578 			break;
579 		case 1:  /* handshake succeeded, peripheral rejected mode */
580 			ret = -ENXIO;
581 			break;
582 		}
583 		pp_enable_irq (pp);
584 		return ret;
585 
586 	case PPWCTLONIRQ:
587 		if (copy_from_user (&reg, argp, sizeof (reg)))
588 			return -EFAULT;
589 
590 		/* Remember what to set the control lines to, for next
591 		 * time we get an interrupt. */
592 		pp->irqctl = reg;
593 		pp->irqresponse = 1;
594 		return 0;
595 
596 	case PPCLRIRQ:
597 		ret = atomic_read (&pp->irqc);
598 		if (copy_to_user (argp, &ret, sizeof (ret)))
599 			return -EFAULT;
600 		atomic_sub (ret, &pp->irqc);
601 		return 0;
602 
603 	case PPSETTIME:
604 		if (copy_from_user (&par_timeout, argp, sizeof(struct timeval))) {
605 			return -EFAULT;
606 		}
607 		/* Convert to jiffies, place in pp->pdev->timeout */
608 		if ((par_timeout.tv_sec < 0) || (par_timeout.tv_usec < 0)) {
609 			return -EINVAL;
610 		}
611 		to_jiffies = ROUND_UP(par_timeout.tv_usec, 1000000/HZ);
612 		to_jiffies += par_timeout.tv_sec * (long)HZ;
613 		if (to_jiffies <= 0) {
614 			return -EINVAL;
615 		}
616 		pp->pdev->timeout = to_jiffies;
617 		return 0;
618 
619 	case PPGETTIME:
620 		to_jiffies = pp->pdev->timeout;
621 		par_timeout.tv_sec = to_jiffies / HZ;
622 		par_timeout.tv_usec = (to_jiffies % (long)HZ) * (1000000/HZ);
623 		if (copy_to_user (argp, &par_timeout, sizeof(struct timeval)))
624 			return -EFAULT;
625 		return 0;
626 
627 	default:
628 		printk (KERN_DEBUG CHRDEV "%x: What? (cmd=0x%x)\n", minor,
629 			cmd);
630 		return -EINVAL;
631 	}
632 
633 	/* Keep the compiler happy */
634 	return 0;
635 }
636 
637 static int pp_open (struct inode * inode, struct file * file)
638 {
639 	unsigned int minor = iminor(inode);
640 	struct pp_struct *pp;
641 
642 	if (minor >= PARPORT_MAX)
643 		return -ENXIO;
644 
645 	pp = kmalloc (sizeof (struct pp_struct), GFP_KERNEL);
646 	if (!pp)
647 		return -ENOMEM;
648 
649 	pp->state.mode = IEEE1284_MODE_COMPAT;
650 	pp->state.phase = init_phase (pp->state.mode);
651 	pp->flags = 0;
652 	pp->irqresponse = 0;
653 	atomic_set (&pp->irqc, 0);
654 	init_waitqueue_head (&pp->irq_wait);
655 
656 	/* Defer the actual device registration until the first claim.
657 	 * That way, we know whether or not the driver wants to have
658 	 * exclusive access to the port (PPEXCL).
659 	 */
660 	pp->pdev = NULL;
661 	file->private_data = pp;
662 
663 	return 0;
664 }
665 
666 static int pp_release (struct inode * inode, struct file * file)
667 {
668 	unsigned int minor = iminor(inode);
669 	struct pp_struct *pp = file->private_data;
670 	int compat_negot;
671 
672 	compat_negot = 0;
673 	if (!(pp->flags & PP_CLAIMED) && pp->pdev &&
674 	    (pp->state.mode != IEEE1284_MODE_COMPAT)) {
675 	    	struct ieee1284_info *info;
676 
677 		/* parport released, but not in compatibility mode */
678 		parport_claim_or_block (pp->pdev);
679 		pp->flags |= PP_CLAIMED;
680 		info = &pp->pdev->port->ieee1284;
681 		pp->saved_state.mode = info->mode;
682 		pp->saved_state.phase = info->phase;
683 		info->mode = pp->state.mode;
684 		info->phase = pp->state.phase;
685 		compat_negot = 1;
686 	} else if ((pp->flags & PP_CLAIMED) && pp->pdev &&
687 	    (pp->pdev->port->ieee1284.mode != IEEE1284_MODE_COMPAT)) {
688 		compat_negot = 2;
689 	}
690 	if (compat_negot) {
691 		parport_negotiate (pp->pdev->port, IEEE1284_MODE_COMPAT);
692 		printk (KERN_DEBUG CHRDEV
693 			"%x: negotiated back to compatibility mode because "
694 			"user-space forgot\n", minor);
695 	}
696 
697 	if (pp->flags & PP_CLAIMED) {
698 		struct ieee1284_info *info;
699 
700 		info = &pp->pdev->port->ieee1284;
701 		pp->state.mode = info->mode;
702 		pp->state.phase = info->phase;
703 		info->mode = pp->saved_state.mode;
704 		info->phase = pp->saved_state.phase;
705 		parport_release (pp->pdev);
706 		if (compat_negot != 1) {
707 			printk (KERN_DEBUG CHRDEV "%x: released pardevice "
708 				"because user-space forgot\n", minor);
709 		}
710 	}
711 
712 	if (pp->pdev) {
713 		const char *name = pp->pdev->name;
714 		parport_unregister_device (pp->pdev);
715 		kfree (name);
716 		pp->pdev = NULL;
717 		printk (KERN_DEBUG CHRDEV "%x: unregistered pardevice\n",
718 			minor);
719 	}
720 
721 	kfree (pp);
722 
723 	return 0;
724 }
725 
726 /* No kernel lock held - fine */
727 static unsigned int pp_poll (struct file * file, poll_table * wait)
728 {
729 	struct pp_struct *pp = file->private_data;
730 	unsigned int mask = 0;
731 
732 	poll_wait (file, &pp->irq_wait, wait);
733 	if (atomic_read (&pp->irqc))
734 		mask |= POLLIN | POLLRDNORM;
735 
736 	return mask;
737 }
738 
739 static struct class *ppdev_class;
740 
741 static const struct file_operations pp_fops = {
742 	.owner		= THIS_MODULE,
743 	.llseek		= no_llseek,
744 	.read		= pp_read,
745 	.write		= pp_write,
746 	.poll		= pp_poll,
747 	.ioctl		= pp_ioctl,
748 	.open		= pp_open,
749 	.release	= pp_release,
750 };
751 
752 static void pp_attach(struct parport *port)
753 {
754 	device_create(ppdev_class, port->dev, MKDEV(PP_MAJOR, port->number),
755 			"parport%d", port->number);
756 }
757 
758 static void pp_detach(struct parport *port)
759 {
760 	device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
761 }
762 
763 static struct parport_driver pp_driver = {
764 	.name		= CHRDEV,
765 	.attach		= pp_attach,
766 	.detach		= pp_detach,
767 };
768 
769 static int __init ppdev_init (void)
770 {
771 	int err = 0;
772 
773 	if (register_chrdev (PP_MAJOR, CHRDEV, &pp_fops)) {
774 		printk (KERN_WARNING CHRDEV ": unable to get major %d\n",
775 			PP_MAJOR);
776 		return -EIO;
777 	}
778 	ppdev_class = class_create(THIS_MODULE, CHRDEV);
779 	if (IS_ERR(ppdev_class)) {
780 		err = PTR_ERR(ppdev_class);
781 		goto out_chrdev;
782 	}
783 	if (parport_register_driver(&pp_driver)) {
784 		printk (KERN_WARNING CHRDEV ": unable to register with parport\n");
785 		goto out_class;
786 	}
787 
788 	printk (KERN_INFO PP_VERSION "\n");
789 	goto out;
790 
791 out_class:
792 	class_destroy(ppdev_class);
793 out_chrdev:
794 	unregister_chrdev(PP_MAJOR, CHRDEV);
795 out:
796 	return err;
797 }
798 
799 static void __exit ppdev_cleanup (void)
800 {
801 	/* Clean up all parport stuff */
802 	parport_unregister_driver(&pp_driver);
803 	class_destroy(ppdev_class);
804 	unregister_chrdev (PP_MAJOR, CHRDEV);
805 }
806 
807 module_init(ppdev_init);
808 module_exit(ppdev_cleanup);
809 
810 MODULE_LICENSE("GPL");
811 MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR);
812