ppdev.c revision 87575437d8173c7da48a4dee25399807c7bec9cb 
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/smp_lock.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 inline void pp_enable_irq (struct pp_struct *pp)
101{
102	struct parport *port = pp->pdev->port;
103	port->ops->enable_irq (port);
104}
105
106static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
107			loff_t * ppos)
108{
109	unsigned int minor = iminor(file->f_path.dentry->d_inode);
110	struct pp_struct *pp = file->private_data;
111	char * kbuffer;
112	ssize_t bytes_read = 0;
113	struct parport *pport;
114	int mode;
115
116	if (!(pp->flags & PP_CLAIMED)) {
117		/* Don't have the port claimed */
118		pr_debug(CHRDEV "%x: claim the port first\n", 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
188static 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		pr_debug(CHRDEV "%x: claim the port first\n", minor);
202		return -EINVAL;
203	}
204
205	kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
206	if (!kbuffer) {
207		return -ENOMEM;
208	}
209	pport = pp->pdev->port;
210	mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
211
212	parport_set_timeout (pp->pdev,
213			     (file->f_flags & O_NONBLOCK) ?
214			     PARPORT_INACTIVITY_O_NONBLOCK :
215			     pp->default_inactivity);
216
217	while (bytes_written < count) {
218		ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
219
220		if (copy_from_user (kbuffer, buf + bytes_written, n)) {
221			bytes_written = -EFAULT;
222			break;
223		}
224
225		if ((pp->flags & PP_FASTWRITE) && (mode == IEEE1284_MODE_EPP)) {
226			/* do a fast EPP write */
227			if (pport->ieee1284.mode & IEEE1284_ADDR) {
228				wrote = pport->ops->epp_write_addr (pport,
229					kbuffer, n, PARPORT_EPP_FAST);
230			} else {
231				wrote = pport->ops->epp_write_data (pport,
232					kbuffer, n, PARPORT_EPP_FAST);
233			}
234		} else {
235			wrote = parport_write (pp->pdev->port, kbuffer, n);
236		}
237
238		if (wrote <= 0) {
239			if (!bytes_written) {
240				bytes_written = wrote;
241			}
242			break;
243		}
244
245		bytes_written += wrote;
246
247		if (file->f_flags & O_NONBLOCK) {
248			if (!bytes_written)
249				bytes_written = -EAGAIN;
250			break;
251		}
252
253		if (signal_pending (current)) {
254			if (!bytes_written) {
255				bytes_written = -EINTR;
256			}
257			break;
258		}
259
260		cond_resched();
261	}
262
263	parport_set_timeout (pp->pdev, pp->default_inactivity);
264
265	kfree (kbuffer);
266	pp_enable_irq (pp);
267	return bytes_written;
268}
269
270static void pp_irq (void *private)
271{
272	struct pp_struct *pp = private;
273
274	if (pp->irqresponse) {
275		parport_write_control (pp->pdev->port, pp->irqctl);
276		pp->irqresponse = 0;
277	}
278
279	atomic_inc (&pp->irqc);
280	wake_up_interruptible (&pp->irq_wait);
281}
282
283static int register_device (int minor, struct pp_struct *pp)
284{
285	struct parport *port;
286	struct pardevice * pdev = NULL;
287	char *name;
288	int fl;
289
290	name = kasprintf(GFP_KERNEL, CHRDEV "%x", minor);
291	if (name == NULL)
292		return -ENOMEM;
293
294	port = parport_find_number (minor);
295	if (!port) {
296		printk (KERN_WARNING "%s: no associated port!\n", name);
297		kfree (name);
298		return -ENXIO;
299	}
300
301	fl = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0;
302	pdev = parport_register_device (port, name, NULL,
303					NULL, pp_irq, fl, pp);
304	parport_put_port (port);
305
306	if (!pdev) {
307		printk (KERN_WARNING "%s: failed to register device!\n", name);
308		kfree (name);
309		return -ENXIO;
310	}
311
312	pp->pdev = pdev;
313	pr_debug("%s: registered pardevice\n", name);
314	return 0;
315}
316
317static enum ieee1284_phase init_phase (int mode)
318{
319	switch (mode & ~(IEEE1284_DEVICEID
320			 | IEEE1284_ADDR)) {
321	case IEEE1284_MODE_NIBBLE:
322	case IEEE1284_MODE_BYTE:
323		return IEEE1284_PH_REV_IDLE;
324	}
325	return IEEE1284_PH_FWD_IDLE;
326}
327
328static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
329{
330	unsigned int minor = iminor(file->f_path.dentry->d_inode);
331	struct pp_struct *pp = file->private_data;
332	struct parport * port;
333	void __user *argp = (void __user *)arg;
334
335	/* First handle the cases that don't take arguments. */
336	switch (cmd) {
337	case PPCLAIM:
338	    {
339		struct ieee1284_info *info;
340		int ret;
341
342		if (pp->flags & PP_CLAIMED) {
343			pr_debug(CHRDEV "%x: you've already got it!\n", minor);
344			return -EINVAL;
345		}
346
347		/* Deferred device registration. */
348		if (!pp->pdev) {
349			int err = register_device (minor, pp);
350			if (err) {
351				return err;
352			}
353		}
354
355		ret = parport_claim_or_block (pp->pdev);
356		if (ret < 0)
357			return ret;
358
359		pp->flags |= PP_CLAIMED;
360
361		/* For interrupt-reporting to work, we need to be
362		 * informed of each interrupt. */
363		pp_enable_irq (pp);
364
365		/* We may need to fix up the state machine. */
366		info = &pp->pdev->port->ieee1284;
367		pp->saved_state.mode = info->mode;
368		pp->saved_state.phase = info->phase;
369		info->mode = pp->state.mode;
370		info->phase = pp->state.phase;
371		pp->default_inactivity = parport_set_timeout (pp->pdev, 0);
372		parport_set_timeout (pp->pdev, pp->default_inactivity);
373
374		return 0;
375	    }
376	case PPEXCL:
377		if (pp->pdev) {
378			pr_debug(CHRDEV "%x: too late for PPEXCL; "
379				"already registered\n", minor);
380			if (pp->flags & PP_EXCL)
381				/* But it's not really an error. */
382				return 0;
383			/* There's no chance of making the driver happy. */
384			return -EINVAL;
385		}
386
387		/* Just remember to register the device exclusively
388		 * when we finally do the registration. */
389		pp->flags |= PP_EXCL;
390		return 0;
391	case PPSETMODE:
392	    {
393		int mode;
394		if (copy_from_user (&mode, argp, sizeof (mode)))
395			return -EFAULT;
396		/* FIXME: validate mode */
397		pp->state.mode = mode;
398		pp->state.phase = init_phase (mode);
399
400		if (pp->flags & PP_CLAIMED) {
401			pp->pdev->port->ieee1284.mode = mode;
402			pp->pdev->port->ieee1284.phase = pp->state.phase;
403		}
404
405		return 0;
406	    }
407	case PPGETMODE:
408	    {
409		int mode;
410
411		if (pp->flags & PP_CLAIMED) {
412			mode = pp->pdev->port->ieee1284.mode;
413		} else {
414			mode = pp->state.mode;
415		}
416		if (copy_to_user (argp, &mode, sizeof (mode))) {
417			return -EFAULT;
418		}
419		return 0;
420	    }
421	case PPSETPHASE:
422	    {
423		int phase;
424		if (copy_from_user (&phase, argp, sizeof (phase))) {
425			return -EFAULT;
426		}
427		/* FIXME: validate phase */
428		pp->state.phase = phase;
429
430		if (pp->flags & PP_CLAIMED) {
431			pp->pdev->port->ieee1284.phase = phase;
432		}
433
434		return 0;
435	    }
436	case PPGETPHASE:
437	    {
438		int phase;
439
440		if (pp->flags & PP_CLAIMED) {
441			phase = pp->pdev->port->ieee1284.phase;
442		} else {
443			phase = pp->state.phase;
444		}
445		if (copy_to_user (argp, &phase, sizeof (phase))) {
446			return -EFAULT;
447		}
448		return 0;
449	    }
450	case PPGETMODES:
451	    {
452		unsigned int modes;
453
454		port = parport_find_number (minor);
455		if (!port)
456			return -ENODEV;
457
458		modes = port->modes;
459		if (copy_to_user (argp, &modes, sizeof (modes))) {
460			return -EFAULT;
461		}
462		return 0;
463	    }
464	case PPSETFLAGS:
465	    {
466		int uflags;
467
468		if (copy_from_user (&uflags, argp, sizeof (uflags))) {
469			return -EFAULT;
470		}
471		pp->flags &= ~PP_FLAGMASK;
472		pp->flags |= (uflags & PP_FLAGMASK);
473		return 0;
474	    }
475	case PPGETFLAGS:
476	    {
477		int uflags;
478
479		uflags = pp->flags & PP_FLAGMASK;
480		if (copy_to_user (argp, &uflags, sizeof (uflags))) {
481			return -EFAULT;
482		}
483		return 0;
484	    }
485	}	/* end switch() */
486
487	/* Everything else requires the port to be claimed, so check
488	 * that now. */
489	if ((pp->flags & PP_CLAIMED) == 0) {
490		pr_debug(CHRDEV "%x: claim the port first\n", minor);
491		return -EINVAL;
492	}
493
494	port = pp->pdev->port;
495	switch (cmd) {
496		struct ieee1284_info *info;
497		unsigned char reg;
498		unsigned char mask;
499		int mode;
500		int ret;
501		struct timeval par_timeout;
502		long to_jiffies;
503
504	case PPRSTATUS:
505		reg = parport_read_status (port);
506		if (copy_to_user (argp, &reg, sizeof (reg)))
507			return -EFAULT;
508		return 0;
509	case PPRDATA:
510		reg = parport_read_data (port);
511		if (copy_to_user (argp, &reg, sizeof (reg)))
512			return -EFAULT;
513		return 0;
514	case PPRCONTROL:
515		reg = parport_read_control (port);
516		if (copy_to_user (argp, &reg, sizeof (reg)))
517			return -EFAULT;
518		return 0;
519	case PPYIELD:
520		parport_yield_blocking (pp->pdev);
521		return 0;
522
523	case PPRELEASE:
524		/* Save the state machine's state. */
525		info = &pp->pdev->port->ieee1284;
526		pp->state.mode = info->mode;
527		pp->state.phase = info->phase;
528		info->mode = pp->saved_state.mode;
529		info->phase = pp->saved_state.phase;
530		parport_release (pp->pdev);
531		pp->flags &= ~PP_CLAIMED;
532		return 0;
533
534	case PPWCONTROL:
535		if (copy_from_user (&reg, argp, sizeof (reg)))
536			return -EFAULT;
537		parport_write_control (port, reg);
538		return 0;
539
540	case PPWDATA:
541		if (copy_from_user (&reg, argp, sizeof (reg)))
542			return -EFAULT;
543		parport_write_data (port, reg);
544		return 0;
545
546	case PPFCONTROL:
547		if (copy_from_user (&mask, argp,
548				    sizeof (mask)))
549			return -EFAULT;
550		if (copy_from_user (&reg, 1 + (unsigned char __user *) arg,
551				    sizeof (reg)))
552			return -EFAULT;
553		parport_frob_control (port, mask, reg);
554		return 0;
555
556	case PPDATADIR:
557		if (copy_from_user (&mode, argp, sizeof (mode)))
558			return -EFAULT;
559		if (mode)
560			port->ops->data_reverse (port);
561		else
562			port->ops->data_forward (port);
563		return 0;
564
565	case PPNEGOT:
566		if (copy_from_user (&mode, argp, sizeof (mode)))
567			return -EFAULT;
568		switch ((ret = parport_negotiate (port, mode))) {
569		case 0: break;
570		case -1: /* handshake failed, peripheral not IEEE 1284 */
571			ret = -EIO;
572			break;
573		case 1:  /* handshake succeeded, peripheral rejected mode */
574			ret = -ENXIO;
575			break;
576		}
577		pp_enable_irq (pp);
578		return ret;
579
580	case PPWCTLONIRQ:
581		if (copy_from_user (&reg, argp, sizeof (reg)))
582			return -EFAULT;
583
584		/* Remember what to set the control lines to, for next
585		 * time we get an interrupt. */
586		pp->irqctl = reg;
587		pp->irqresponse = 1;
588		return 0;
589
590	case PPCLRIRQ:
591		ret = atomic_read (&pp->irqc);
592		if (copy_to_user (argp, &ret, sizeof (ret)))
593			return -EFAULT;
594		atomic_sub (ret, &pp->irqc);
595		return 0;
596
597	case PPSETTIME:
598		if (copy_from_user (&par_timeout, argp, sizeof(struct timeval))) {
599			return -EFAULT;
600		}
601		/* Convert to jiffies, place in pp->pdev->timeout */
602		if ((par_timeout.tv_sec < 0) || (par_timeout.tv_usec < 0)) {
603			return -EINVAL;
604		}
605		to_jiffies = ROUND_UP(par_timeout.tv_usec, 1000000/HZ);
606		to_jiffies += par_timeout.tv_sec * (long)HZ;
607		if (to_jiffies <= 0) {
608			return -EINVAL;
609		}
610		pp->pdev->timeout = to_jiffies;
611		return 0;
612
613	case PPGETTIME:
614		to_jiffies = pp->pdev->timeout;
615		par_timeout.tv_sec = to_jiffies / HZ;
616		par_timeout.tv_usec = (to_jiffies % (long)HZ) * (1000000/HZ);
617		if (copy_to_user (argp, &par_timeout, sizeof(struct timeval)))
618			return -EFAULT;
619		return 0;
620
621	default:
622		pr_debug(CHRDEV "%x: What? (cmd=0x%x)\n", minor, cmd);
623		return -EINVAL;
624	}
625
626	/* Keep the compiler happy */
627	return 0;
628}
629
630static long pp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
631{
632	long ret;
633	lock_kernel();
634	ret = pp_do_ioctl(file, cmd, arg);
635	unlock_kernel();
636	return ret;
637}
638
639static int pp_open (struct inode * inode, struct file * file)
640{
641	unsigned int minor = iminor(inode);
642	struct pp_struct *pp;
643
644	cycle_kernel_lock();
645	if (minor >= PARPORT_MAX)
646		return -ENXIO;
647
648	pp = kmalloc (sizeof (struct pp_struct), GFP_KERNEL);
649	if (!pp)
650		return -ENOMEM;
651
652	pp->state.mode = IEEE1284_MODE_COMPAT;
653	pp->state.phase = init_phase (pp->state.mode);
654	pp->flags = 0;
655	pp->irqresponse = 0;
656	atomic_set (&pp->irqc, 0);
657	init_waitqueue_head (&pp->irq_wait);
658
659	/* Defer the actual device registration until the first claim.
660	 * That way, we know whether or not the driver wants to have
661	 * exclusive access to the port (PPEXCL).
662	 */
663	pp->pdev = NULL;
664	file->private_data = pp;
665
666	return 0;
667}
668
669static int pp_release (struct inode * inode, struct file * file)
670{
671	unsigned int minor = iminor(inode);
672	struct pp_struct *pp = file->private_data;
673	int compat_negot;
674
675	compat_negot = 0;
676	if (!(pp->flags & PP_CLAIMED) && pp->pdev &&
677	    (pp->state.mode != IEEE1284_MODE_COMPAT)) {
678	    	struct ieee1284_info *info;
679
680		/* parport released, but not in compatibility mode */
681		parport_claim_or_block (pp->pdev);
682		pp->flags |= PP_CLAIMED;
683		info = &pp->pdev->port->ieee1284;
684		pp->saved_state.mode = info->mode;
685		pp->saved_state.phase = info->phase;
686		info->mode = pp->state.mode;
687		info->phase = pp->state.phase;
688		compat_negot = 1;
689	} else if ((pp->flags & PP_CLAIMED) && pp->pdev &&
690	    (pp->pdev->port->ieee1284.mode != IEEE1284_MODE_COMPAT)) {
691		compat_negot = 2;
692	}
693	if (compat_negot) {
694		parport_negotiate (pp->pdev->port, IEEE1284_MODE_COMPAT);
695		pr_debug(CHRDEV "%x: negotiated back to compatibility "
696			"mode because user-space forgot\n", minor);
697	}
698
699	if (pp->flags & PP_CLAIMED) {
700		struct ieee1284_info *info;
701
702		info = &pp->pdev->port->ieee1284;
703		pp->state.mode = info->mode;
704		pp->state.phase = info->phase;
705		info->mode = pp->saved_state.mode;
706		info->phase = pp->saved_state.phase;
707		parport_release (pp->pdev);
708		if (compat_negot != 1) {
709			pr_debug(CHRDEV "%x: released pardevice "
710				"because user-space forgot\n", minor);
711		}
712	}
713
714	if (pp->pdev) {
715		const char *name = pp->pdev->name;
716		parport_unregister_device (pp->pdev);
717		kfree (name);
718		pp->pdev = NULL;
719		pr_debug(CHRDEV "%x: unregistered pardevice\n", minor);
720	}
721
722	kfree (pp);
723
724	return 0;
725}
726
727/* No kernel lock held - fine */
728static unsigned int pp_poll (struct file * file, poll_table * wait)
729{
730	struct pp_struct *pp = file->private_data;
731	unsigned int mask = 0;
732
733	poll_wait (file, &pp->irq_wait, wait);
734	if (atomic_read (&pp->irqc))
735		mask |= POLLIN | POLLRDNORM;
736
737	return mask;
738}
739
740static struct class *ppdev_class;
741
742static const struct file_operations pp_fops = {
743	.owner		= THIS_MODULE,
744	.llseek		= no_llseek,
745	.read		= pp_read,
746	.write		= pp_write,
747	.poll		= pp_poll,
748	.unlocked_ioctl	= pp_ioctl,
749	.open		= pp_open,
750	.release	= pp_release,
751};
752
753static void pp_attach(struct parport *port)
754{
755	device_create(ppdev_class, port->dev, MKDEV(PP_MAJOR, port->number),
756		      NULL, "parport%d", port->number);
757}
758
759static void pp_detach(struct parport *port)
760{
761	device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
762}
763
764static struct parport_driver pp_driver = {
765	.name		= CHRDEV,
766	.attach		= pp_attach,
767	.detach		= pp_detach,
768};
769
770static int __init ppdev_init (void)
771{
772	int err = 0;
773
774	if (register_chrdev (PP_MAJOR, CHRDEV, &pp_fops)) {
775		printk (KERN_WARNING CHRDEV ": unable to get major %d\n",
776			PP_MAJOR);
777		return -EIO;
778	}
779	ppdev_class = class_create(THIS_MODULE, CHRDEV);
780	if (IS_ERR(ppdev_class)) {
781		err = PTR_ERR(ppdev_class);
782		goto out_chrdev;
783	}
784	if (parport_register_driver(&pp_driver)) {
785		printk (KERN_WARNING CHRDEV ": unable to register with parport\n");
786		goto out_class;
787	}
788
789	printk (KERN_INFO PP_VERSION "\n");
790	goto out;
791
792out_class:
793	class_destroy(ppdev_class);
794out_chrdev:
795	unregister_chrdev(PP_MAJOR, CHRDEV);
796out:
797	return err;
798}
799
800static void __exit ppdev_cleanup (void)
801{
802	/* Clean up all parport stuff */
803	parport_unregister_driver(&pp_driver);
804	class_destroy(ppdev_class);
805	unregister_chrdev (PP_MAJOR, CHRDEV);
806}
807
808module_init(ppdev_init);
809module_exit(ppdev_cleanup);
810
811MODULE_LICENSE("GPL");
812MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR);
813