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/slab.h>
 68#include <linux/major.h>
 69#include <linux/ppdev.h>
 70#include <linux/mutex.h>
 71#include <linux/uaccess.h>
 72
 73#define PP_VERSION "ppdev: user-space parallel port driver"
 74#define CHRDEV "ppdev"
 75
 76struct pp_struct {
 77	struct pardevice * pdev;
 78	wait_queue_head_t irq_wait;
 79	atomic_t irqc;
 80	unsigned int flags;
 81	int irqresponse;
 82	unsigned char irqctl;
 83	struct ieee1284_info state;
 84	struct ieee1284_info saved_state;
 85	long default_inactivity;
 86};
 87
 88/* pp_struct.flags bitfields */
 89#define PP_CLAIMED    (1<<0)
 90#define PP_EXCL       (1<<1)
 91
 92/* Other constants */
 93#define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
 94#define PP_BUFFER_SIZE 1024
 95#define PARDEVICE_MAX 8
 96
 97/* ROUND_UP macro from fs/select.c */
 98#define ROUND_UP(x,y) (((x)+(y)-1)/(y))
 99
100static DEFINE_MUTEX(pp_do_mutex);
101static inline void pp_enable_irq (struct pp_struct *pp)
102{
103	struct parport *port = pp->pdev->port;
104	port->ops->enable_irq (port);
105}
106
107static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
108			loff_t * ppos)
109{
110	unsigned int minor = iminor(file->f_path.dentry->d_inode);
111	struct pp_struct *pp = file->private_data;
112	char * kbuffer;
113	ssize_t bytes_read = 0;
114	struct parport *pport;
115	int mode;
116
117	if (!(pp->flags & PP_CLAIMED)) {
118		/* Don't have the port claimed */
119		pr_debug(CHRDEV "%x: claim the port first\n", minor);
120		return -EINVAL;
121	}
122
123	/* Trivial case. */
124	if (count == 0)
125		return 0;
126
127	kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
128	if (!kbuffer) {
129		return -ENOMEM;
130	}
131	pport = pp->pdev->port;
132	mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
133
134	parport_set_timeout (pp->pdev,
135			     (file->f_flags & O_NONBLOCK) ?
136			     PARPORT_INACTIVITY_O_NONBLOCK :
137			     pp->default_inactivity);
138
139	while (bytes_read == 0) {
140		ssize_t need = min_t(unsigned long, count, PP_BUFFER_SIZE);
141
142		if (mode == IEEE1284_MODE_EPP) {
143			/* various specials for EPP mode */
144			int flags = 0;
145			size_t (*fn)(struct parport *, void *, size_t, int);
146
147			if (pp->flags & PP_W91284PIC) {
148				flags |= PARPORT_W91284PIC;
149			}
150			if (pp->flags & PP_FASTREAD) {
151				flags |= PARPORT_EPP_FAST;
152			}
153			if (pport->ieee1284.mode & IEEE1284_ADDR) {
154				fn = pport->ops->epp_read_addr;
155			} else {
156				fn = pport->ops->epp_read_data;
157			}
158			bytes_read = (*fn)(pport, kbuffer, need, flags);
159		} else {
160			bytes_read = parport_read (pport, kbuffer, need);
161		}
162
163		if (bytes_read != 0)
164			break;
165
166		if (file->f_flags & O_NONBLOCK) {
167			bytes_read = -EAGAIN;
168			break;
169		}
170
171		if (signal_pending (current)) {
172			bytes_read = -ERESTARTSYS;
173			break;
174		}
175
176		cond_resched();
177	}
178
179	parport_set_timeout (pp->pdev, pp->default_inactivity);
180
181	if (bytes_read > 0 && copy_to_user (buf, kbuffer, bytes_read))
182		bytes_read = -EFAULT;
183
184	kfree (kbuffer);
185	pp_enable_irq (pp);
186	return bytes_read;
187}
188
189static ssize_t pp_write (struct file * file, const char __user * buf,
190			 size_t count, loff_t * ppos)
191{
192	unsigned int minor = iminor(file->f_path.dentry->d_inode);
193	struct pp_struct *pp = file->private_data;
194	char * kbuffer;
195	ssize_t bytes_written = 0;
196	ssize_t wrote;
197	int mode;
198	struct parport *pport;
199
200	if (!(pp->flags & PP_CLAIMED)) {
201		/* Don't have the port claimed */
202		pr_debug(CHRDEV "%x: claim the port first\n", 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
271static void pp_irq (void *private)
272{
273	struct pp_struct *pp = 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
284static 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 = kasprintf(GFP_KERNEL, CHRDEV "%x", minor);
292	if (name == NULL)
293		return -ENOMEM;
294
295	port = parport_find_number (minor);
296	if (!port) {
297		printk (KERN_WARNING "%s: no associated port!\n", name);
298		kfree (name);
299		return -ENXIO;
300	}
301
302	fl = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0;
303	pdev = parport_register_device (port, name, NULL,
304					NULL, pp_irq, fl, pp);
305	parport_put_port (port);
306
307	if (!pdev) {
308		printk (KERN_WARNING "%s: failed to register device!\n", name);
309		kfree (name);
310		return -ENXIO;
311	}
312
313	pp->pdev = pdev;
314	pr_debug("%s: registered pardevice\n", name);
315	return 0;
316}
317
318static enum ieee1284_phase init_phase (int mode)
319{
320	switch (mode & ~(IEEE1284_DEVICEID
321			 | IEEE1284_ADDR)) {
322	case IEEE1284_MODE_NIBBLE:
323	case IEEE1284_MODE_BYTE:
324		return IEEE1284_PH_REV_IDLE;
325	}
326	return IEEE1284_PH_FWD_IDLE;
327}
328
329static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
330{
331	unsigned int minor = iminor(file->f_path.dentry->d_inode);
332	struct pp_struct *pp = file->private_data;
333	struct parport * port;
334	void __user *argp = (void __user *)arg;
335
336	/* First handle the cases that don't take arguments. */
337	switch (cmd) {
338	case PPCLAIM:
339	    {
340		struct ieee1284_info *info;
341		int ret;
342
343		if (pp->flags & PP_CLAIMED) {
344			pr_debug(CHRDEV "%x: you've already got it!\n", minor);
345			return -EINVAL;
346		}
347
348		/* Deferred device registration. */
349		if (!pp->pdev) {
350			int err = register_device (minor, pp);
351			if (err) {
352				return err;
353			}
354		}
355
356		ret = parport_claim_or_block (pp->pdev);
357		if (ret < 0)
358			return ret;
359
360		pp->flags |= PP_CLAIMED;
361
362		/* For interrupt-reporting to work, we need to be
363		 * informed of each interrupt. */
364		pp_enable_irq (pp);
365
366		/* We may need to fix up the state machine. */
367		info = &pp->pdev->port->ieee1284;
368		pp->saved_state.mode = info->mode;
369		pp->saved_state.phase = info->phase;
370		info->mode = pp->state.mode;
371		info->phase = pp->state.phase;
372		pp->default_inactivity = parport_set_timeout (pp->pdev, 0);
373		parport_set_timeout (pp->pdev, pp->default_inactivity);
374
375		return 0;
376	    }
377	case PPEXCL:
378		if (pp->pdev) {
379			pr_debug(CHRDEV "%x: too late for PPEXCL; "
380				"already registered\n", minor);
381			if (pp->flags & PP_EXCL)
382				/* But it's not really an error. */
383				return 0;
384			/* There's no chance of making the driver happy. */
385			return -EINVAL;
386		}
387
388		/* Just remember to register the device exclusively
389		 * when we finally do the registration. */
390		pp->flags |= PP_EXCL;
391		return 0;
392	case PPSETMODE:
393	    {
394		int mode;
395		if (copy_from_user (&mode, argp, sizeof (mode)))
396			return -EFAULT;
397		/* FIXME: validate mode */
398		pp->state.mode = mode;
399		pp->state.phase = init_phase (mode);
400
401		if (pp->flags & PP_CLAIMED) {
402			pp->pdev->port->ieee1284.mode = mode;
403			pp->pdev->port->ieee1284.phase = pp->state.phase;
404		}
405
406		return 0;
407	    }
408	case PPGETMODE:
409	    {
410		int mode;
411
412		if (pp->flags & PP_CLAIMED) {
413			mode = pp->pdev->port->ieee1284.mode;
414		} else {
415			mode = pp->state.mode;
416		}
417		if (copy_to_user (argp, &mode, sizeof (mode))) {
418			return -EFAULT;
419		}
420		return 0;
421	    }
422	case PPSETPHASE:
423	    {
424		int phase;
425		if (copy_from_user (&phase, argp, sizeof (phase))) {
426			return -EFAULT;
427		}
428		/* FIXME: validate phase */
429		pp->state.phase = phase;
430
431		if (pp->flags & PP_CLAIMED) {
432			pp->pdev->port->ieee1284.phase = phase;
433		}
434
435		return 0;
436	    }
437	case PPGETPHASE:
438	    {
439		int phase;
440
441		if (pp->flags & PP_CLAIMED) {
442			phase = pp->pdev->port->ieee1284.phase;
443		} else {
444			phase = pp->state.phase;
445		}
446		if (copy_to_user (argp, &phase, sizeof (phase))) {
447			return -EFAULT;
448		}
449		return 0;
450	    }
451	case PPGETMODES:
452	    {
453		unsigned int modes;
454
455		port = parport_find_number (minor);
456		if (!port)
457			return -ENODEV;
458
459		modes = port->modes;
460		parport_put_port(port);
461		if (copy_to_user (argp, &modes, sizeof (modes))) {
462			return -EFAULT;
463		}
464		return 0;
465	    }
466	case PPSETFLAGS:
467	    {
468		int uflags;
469
470		if (copy_from_user (&uflags, argp, sizeof (uflags))) {
471			return -EFAULT;
472		}
473		pp->flags &= ~PP_FLAGMASK;
474		pp->flags |= (uflags & PP_FLAGMASK);
475		return 0;
476	    }
477	case PPGETFLAGS:
478	    {
479		int uflags;
480
481		uflags = pp->flags & PP_FLAGMASK;
482		if (copy_to_user (argp, &uflags, sizeof (uflags))) {
483			return -EFAULT;
484		}
485		return 0;
486	    }
487	}	/* end switch() */
488
489	/* Everything else requires the port to be claimed, so check
490	 * that now. */
491	if ((pp->flags & PP_CLAIMED) == 0) {
492		pr_debug(CHRDEV "%x: claim the port first\n", minor);
493		return -EINVAL;
494	}
495
496	port = pp->pdev->port;
497	switch (cmd) {
498		struct ieee1284_info *info;
499		unsigned char reg;
500		unsigned char mask;
501		int mode;
502		int ret;
503		struct timeval par_timeout;
504		long to_jiffies;
505
506	case PPRSTATUS:
507		reg = parport_read_status (port);
508		if (copy_to_user (argp, &reg, sizeof (reg)))
509			return -EFAULT;
510		return 0;
511	case PPRDATA:
512		reg = parport_read_data (port);
513		if (copy_to_user (argp, &reg, sizeof (reg)))
514			return -EFAULT;
515		return 0;
516	case PPRCONTROL:
517		reg = parport_read_control (port);
518		if (copy_to_user (argp, &reg, sizeof (reg)))
519			return -EFAULT;
520		return 0;
521	case PPYIELD:
522		parport_yield_blocking (pp->pdev);
523		return 0;
524
525	case PPRELEASE:
526		/* Save the state machine's state. */
527		info = &pp->pdev->port->ieee1284;
528		pp->state.mode = info->mode;
529		pp->state.phase = info->phase;
530		info->mode = pp->saved_state.mode;
531		info->phase = pp->saved_state.phase;
532		parport_release (pp->pdev);
533		pp->flags &= ~PP_CLAIMED;
534		return 0;
535
536	case PPWCONTROL:
537		if (copy_from_user (&reg, argp, sizeof (reg)))
538			return -EFAULT;
539		parport_write_control (port, reg);
540		return 0;
541
542	case PPWDATA:
543		if (copy_from_user (&reg, argp, sizeof (reg)))
544			return -EFAULT;
545		parport_write_data (port, reg);
546		return 0;
547
548	case PPFCONTROL:
549		if (copy_from_user (&mask, argp,
550				    sizeof (mask)))
551			return -EFAULT;
552		if (copy_from_user (&reg, 1 + (unsigned char __user *) arg,
553				    sizeof (reg)))
554			return -EFAULT;
555		parport_frob_control (port, mask, reg);
556		return 0;
557
558	case PPDATADIR:
559		if (copy_from_user (&mode, argp, sizeof (mode)))
560			return -EFAULT;
561		if (mode)
562			port->ops->data_reverse (port);
563		else
564			port->ops->data_forward (port);
565		return 0;
566
567	case PPNEGOT:
568		if (copy_from_user (&mode, argp, sizeof (mode)))
569			return -EFAULT;
570		switch ((ret = parport_negotiate (port, mode))) {
571		case 0: break;
572		case -1: /* handshake failed, peripheral not IEEE 1284 */
573			ret = -EIO;
574			break;
575		case 1:  /* handshake succeeded, peripheral rejected mode */
576			ret = -ENXIO;
577			break;
578		}
579		pp_enable_irq (pp);
580		return ret;
581
582	case PPWCTLONIRQ:
583		if (copy_from_user (&reg, argp, sizeof (reg)))
584			return -EFAULT;
585
586		/* Remember what to set the control lines to, for next
587		 * time we get an interrupt. */
588		pp->irqctl = reg;
589		pp->irqresponse = 1;
590		return 0;
591
592	case PPCLRIRQ:
593		ret = atomic_read (&pp->irqc);
594		if (copy_to_user (argp, &ret, sizeof (ret)))
595			return -EFAULT;
596		atomic_sub (ret, &pp->irqc);
597		return 0;
598
599	case PPSETTIME:
600		if (copy_from_user (&par_timeout, argp, sizeof(struct timeval))) {
601			return -EFAULT;
602		}
603		/* Convert to jiffies, place in pp->pdev->timeout */
604		if ((par_timeout.tv_sec < 0) || (par_timeout.tv_usec < 0)) {
605			return -EINVAL;
606		}
607		to_jiffies = ROUND_UP(par_timeout.tv_usec, 1000000/HZ);
608		to_jiffies += par_timeout.tv_sec * (long)HZ;
609		if (to_jiffies <= 0) {
610			return -EINVAL;
611		}
612		pp->pdev->timeout = to_jiffies;
613		return 0;
614
615	case PPGETTIME:
616		to_jiffies = pp->pdev->timeout;
617		memset(&par_timeout, 0, sizeof(par_timeout));
618		par_timeout.tv_sec = to_jiffies / HZ;
619		par_timeout.tv_usec = (to_jiffies % (long)HZ) * (1000000/HZ);
620		if (copy_to_user (argp, &par_timeout, sizeof(struct timeval)))
621			return -EFAULT;
622		return 0;
623
624	default:
625		pr_debug(CHRDEV "%x: What? (cmd=0x%x)\n", minor, cmd);
626		return -EINVAL;
627	}
628
629	/* Keep the compiler happy */
630	return 0;
631}
632
633static long pp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
634{
635	long ret;
636	mutex_lock(&pp_do_mutex);
637	ret = pp_do_ioctl(file, cmd, arg);
638	mutex_unlock(&pp_do_mutex);
639	return ret;
640}
641
642static int pp_open (struct inode * inode, struct file * file)
643{
644	unsigned int minor = iminor(inode);
645	struct pp_struct *pp;
646
647	if (minor >= PARPORT_MAX)
648		return -ENXIO;
649
650	pp = kmalloc (sizeof (struct pp_struct), GFP_KERNEL);
651	if (!pp)
652		return -ENOMEM;
653
654	pp->state.mode = IEEE1284_MODE_COMPAT;
655	pp->state.phase = init_phase (pp->state.mode);
656	pp->flags = 0;
657	pp->irqresponse = 0;
658	atomic_set (&pp->irqc, 0);
659	init_waitqueue_head (&pp->irq_wait);
660
661	/* Defer the actual device registration until the first claim.
662	 * That way, we know whether or not the driver wants to have
663	 * exclusive access to the port (PPEXCL).
664	 */
665	pp->pdev = NULL;
666	file->private_data = pp;
667
668	return 0;
669}
670
671static int pp_release (struct inode * inode, struct file * file)
672{
673	unsigned int minor = iminor(inode);
674	struct pp_struct *pp = file->private_data;
675	int compat_negot;
676
677	compat_negot = 0;
678	if (!(pp->flags & PP_CLAIMED) && pp->pdev &&
679	    (pp->state.mode != IEEE1284_MODE_COMPAT)) {
680	    	struct ieee1284_info *info;
681
682		/* parport released, but not in compatibility mode */
683		parport_claim_or_block (pp->pdev);
684		pp->flags |= PP_CLAIMED;
685		info = &pp->pdev->port->ieee1284;
686		pp->saved_state.mode = info->mode;
687		pp->saved_state.phase = info->phase;
688		info->mode = pp->state.mode;
689		info->phase = pp->state.phase;
690		compat_negot = 1;
691	} else if ((pp->flags & PP_CLAIMED) && pp->pdev &&
692	    (pp->pdev->port->ieee1284.mode != IEEE1284_MODE_COMPAT)) {
693		compat_negot = 2;
694	}
695	if (compat_negot) {
696		parport_negotiate (pp->pdev->port, IEEE1284_MODE_COMPAT);
697		pr_debug(CHRDEV "%x: negotiated back to compatibility "
698			"mode because user-space forgot\n", minor);
699	}
700
701	if (pp->flags & PP_CLAIMED) {
702		struct ieee1284_info *info;
703
704		info = &pp->pdev->port->ieee1284;
705		pp->state.mode = info->mode;
706		pp->state.phase = info->phase;
707		info->mode = pp->saved_state.mode;
708		info->phase = pp->saved_state.phase;
709		parport_release (pp->pdev);
710		if (compat_negot != 1) {
711			pr_debug(CHRDEV "%x: released pardevice "
712				"because user-space forgot\n", minor);
713		}
714	}
715
716	if (pp->pdev) {
717		const char *name = pp->pdev->name;
718		parport_unregister_device (pp->pdev);
719		kfree (name);
720		pp->pdev = NULL;
721		pr_debug(CHRDEV "%x: unregistered pardevice\n", minor);
722	}
723
724	kfree (pp);
725
726	return 0;
727}
728
729/* No kernel lock held - fine */
730static unsigned int pp_poll (struct file * file, poll_table * wait)
731{
732	struct pp_struct *pp = file->private_data;
733	unsigned int mask = 0;
734
735	poll_wait (file, &pp->irq_wait, wait);
736	if (atomic_read (&pp->irqc))
737		mask |= POLLIN | POLLRDNORM;
738
739	return mask;
740}
741
742static struct class *ppdev_class;
743
744static const struct file_operations pp_fops = {
745	.owner		= THIS_MODULE,
746	.llseek		= no_llseek,
747	.read		= pp_read,
748	.write		= pp_write,
749	.poll		= pp_poll,
750	.unlocked_ioctl	= pp_ioctl,
751	.open		= pp_open,
752	.release	= pp_release,
753};
754
755static void pp_attach(struct parport *port)
756{
757	device_create(ppdev_class, port->dev, MKDEV(PP_MAJOR, port->number),
758		      NULL, "parport%d", port->number);
759}
760
761static void pp_detach(struct parport *port)
762{
763	device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
764}
765
766static struct parport_driver pp_driver = {
767	.name		= CHRDEV,
768	.attach		= pp_attach,
769	.detach		= pp_detach,
770};
771
772static int __init ppdev_init (void)
773{
774	int err = 0;
775
776	if (register_chrdev (PP_MAJOR, CHRDEV, &pp_fops)) {
777		printk (KERN_WARNING CHRDEV ": unable to get major %d\n",
778			PP_MAJOR);
779		return -EIO;
780	}
781	ppdev_class = class_create(THIS_MODULE, CHRDEV);
782	if (IS_ERR(ppdev_class)) {
783		err = PTR_ERR(ppdev_class);
784		goto out_chrdev;
785	}
786	if (parport_register_driver(&pp_driver)) {
787		printk (KERN_WARNING CHRDEV ": unable to register with parport\n");
788		goto out_class;
789	}
790
791	printk (KERN_INFO PP_VERSION "\n");
792	goto out;
793
794out_class:
795	class_destroy(ppdev_class);
796out_chrdev:
797	unregister_chrdev(PP_MAJOR, CHRDEV);
798out:
799	return err;
800}
801
802static void __exit ppdev_cleanup (void)
803{
804	/* Clean up all parport stuff */
805	parport_unregister_driver(&pp_driver);
806	class_destroy(ppdev_class);
807	unregister_chrdev (PP_MAJOR, CHRDEV);
808}
809
810module_init(ppdev_init);
811module_exit(ppdev_cleanup);
812
813MODULE_LICENSE("GPL");
814MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR);