2 * linux/drivers/char/ppdev.c
4 * This is the code behind /dev/parport* -- it allows a user-space
5 * application to use the parport subsystem.
7 * Copyright (C) 1998-2000, 2002 Tim Waugh <tim@cyberelk.net>
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.
14 * A /dev/parportx device node represents an arbitrary device
15 * on port 'x'. The following operations are possible:
17 * open do nothing, set up default IEEE 1284 protocol to be COMPAT
18 * close release port and unregister device (if necessary)
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
29 * WCONTROL write_control
30 * RCONTROL read_control
31 * FCONTROL frob_control
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)
48 * Added SETTIME/GETTIME ioctl, Fred Barnes, 1999.
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
55 * Added GETMODES/GETMODE/GETPHASE ioctls, Fred Barnes <frmb2@ukc.ac.uk>, 03/01/2001.
56 * Added GETFLAGS/SETFLAGS ioctls, Fred Barnes, 04/2001
59 #include <linux/module.h>
60 #include <linux/init.h>
61 #include <linux/sched/signal.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 #include <linux/compat.h>
74 #define PP_VERSION "ppdev: user-space parallel port driver"
75 #define CHRDEV "ppdev"
78 struct pardevice
*pdev
;
79 wait_queue_head_t irq_wait
;
84 struct ieee1284_info state
;
85 struct ieee1284_info saved_state
;
86 long default_inactivity
;
89 /* should we use PARDEVICE_MAX here? */
90 static struct device
*devices
[PARPORT_MAX
];
92 /* pp_struct.flags bitfields */
93 #define PP_CLAIMED (1<<0)
94 #define PP_EXCL (1<<1)
97 #define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
98 #define PP_BUFFER_SIZE 1024
99 #define PARDEVICE_MAX 8
101 /* ROUND_UP macro from fs/select.c */
102 #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
104 static DEFINE_MUTEX(pp_do_mutex
);
106 /* define fixed sized ioctl cmd for y2038 migration */
107 #define PPGETTIME32 _IOR(PP_IOCTL, 0x95, s32[2])
108 #define PPSETTIME32 _IOW(PP_IOCTL, 0x96, s32[2])
109 #define PPGETTIME64 _IOR(PP_IOCTL, 0x95, s64[2])
110 #define PPSETTIME64 _IOW(PP_IOCTL, 0x96, s64[2])
112 static inline void pp_enable_irq(struct pp_struct
*pp
)
114 struct parport
*port
= pp
->pdev
->port
;
116 port
->ops
->enable_irq(port
);
119 static ssize_t
pp_read(struct file
*file
, char __user
*buf
, size_t count
,
122 unsigned int minor
= iminor(file_inode(file
));
123 struct pp_struct
*pp
= file
->private_data
;
125 ssize_t bytes_read
= 0;
126 struct parport
*pport
;
129 if (!(pp
->flags
& PP_CLAIMED
)) {
130 /* Don't have the port claimed */
131 pr_debug(CHRDEV
"%x: claim the port first\n", minor
);
139 kbuffer
= kmalloc(min_t(size_t, count
, PP_BUFFER_SIZE
), GFP_KERNEL
);
142 pport
= pp
->pdev
->port
;
143 mode
= pport
->ieee1284
.mode
& ~(IEEE1284_DEVICEID
| IEEE1284_ADDR
);
145 parport_set_timeout(pp
->pdev
,
146 (file
->f_flags
& O_NONBLOCK
) ?
147 PARPORT_INACTIVITY_O_NONBLOCK
:
148 pp
->default_inactivity
);
150 while (bytes_read
== 0) {
151 ssize_t need
= min_t(unsigned long, count
, PP_BUFFER_SIZE
);
153 if (mode
== IEEE1284_MODE_EPP
) {
154 /* various specials for EPP mode */
156 size_t (*fn
)(struct parport
*, void *, size_t, int);
158 if (pp
->flags
& PP_W91284PIC
)
159 flags
|= PARPORT_W91284PIC
;
160 if (pp
->flags
& PP_FASTREAD
)
161 flags
|= PARPORT_EPP_FAST
;
162 if (pport
->ieee1284
.mode
& IEEE1284_ADDR
)
163 fn
= pport
->ops
->epp_read_addr
;
165 fn
= pport
->ops
->epp_read_data
;
166 bytes_read
= (*fn
)(pport
, kbuffer
, need
, flags
);
168 bytes_read
= parport_read(pport
, kbuffer
, need
);
174 if (file
->f_flags
& O_NONBLOCK
) {
175 bytes_read
= -EAGAIN
;
179 if (signal_pending(current
)) {
180 bytes_read
= -ERESTARTSYS
;
187 parport_set_timeout(pp
->pdev
, pp
->default_inactivity
);
189 if (bytes_read
> 0 && copy_to_user(buf
, kbuffer
, bytes_read
))
190 bytes_read
= -EFAULT
;
197 static ssize_t
pp_write(struct file
*file
, const char __user
*buf
,
198 size_t count
, loff_t
*ppos
)
200 unsigned int minor
= iminor(file_inode(file
));
201 struct pp_struct
*pp
= file
->private_data
;
203 ssize_t bytes_written
= 0;
206 struct parport
*pport
;
208 if (!(pp
->flags
& PP_CLAIMED
)) {
209 /* Don't have the port claimed */
210 pr_debug(CHRDEV
"%x: claim the port first\n", minor
);
214 kbuffer
= kmalloc(min_t(size_t, count
, PP_BUFFER_SIZE
), GFP_KERNEL
);
218 pport
= pp
->pdev
->port
;
219 mode
= pport
->ieee1284
.mode
& ~(IEEE1284_DEVICEID
| IEEE1284_ADDR
);
221 parport_set_timeout(pp
->pdev
,
222 (file
->f_flags
& O_NONBLOCK
) ?
223 PARPORT_INACTIVITY_O_NONBLOCK
:
224 pp
->default_inactivity
);
226 while (bytes_written
< count
) {
227 ssize_t n
= min_t(unsigned long, count
- bytes_written
, PP_BUFFER_SIZE
);
229 if (copy_from_user(kbuffer
, buf
+ bytes_written
, n
)) {
230 bytes_written
= -EFAULT
;
234 if ((pp
->flags
& PP_FASTWRITE
) && (mode
== IEEE1284_MODE_EPP
)) {
235 /* do a fast EPP write */
236 if (pport
->ieee1284
.mode
& IEEE1284_ADDR
) {
237 wrote
= pport
->ops
->epp_write_addr(pport
,
238 kbuffer
, n
, PARPORT_EPP_FAST
);
240 wrote
= pport
->ops
->epp_write_data(pport
,
241 kbuffer
, n
, PARPORT_EPP_FAST
);
244 wrote
= parport_write(pp
->pdev
->port
, kbuffer
, n
);
249 bytes_written
= wrote
;
253 bytes_written
+= wrote
;
255 if (file
->f_flags
& O_NONBLOCK
) {
257 bytes_written
= -EAGAIN
;
261 if (signal_pending(current
))
267 parport_set_timeout(pp
->pdev
, pp
->default_inactivity
);
271 return bytes_written
;
274 static void pp_irq(void *private)
276 struct pp_struct
*pp
= private;
278 if (pp
->irqresponse
) {
279 parport_write_control(pp
->pdev
->port
, pp
->irqctl
);
283 atomic_inc(&pp
->irqc
);
284 wake_up_interruptible(&pp
->irq_wait
);
287 static int register_device(int minor
, struct pp_struct
*pp
)
289 struct parport
*port
;
290 struct pardevice
*pdev
= NULL
;
292 struct pardev_cb ppdev_cb
;
295 name
= kasprintf(GFP_KERNEL
, CHRDEV
"%x", minor
);
299 port
= parport_find_number(minor
);
301 pr_warn("%s: no associated port!\n", name
);
306 memset(&ppdev_cb
, 0, sizeof(ppdev_cb
));
307 ppdev_cb
.irq_func
= pp_irq
;
308 ppdev_cb
.flags
= (pp
->flags
& PP_EXCL
) ? PARPORT_FLAG_EXCL
: 0;
309 ppdev_cb
.private = pp
;
310 pdev
= parport_register_dev_model(port
, name
, &ppdev_cb
, minor
);
311 parport_put_port(port
);
314 pr_warn("%s: failed to register device!\n", name
);
320 dev_dbg(&pdev
->dev
, "registered pardevice\n");
326 static enum ieee1284_phase
init_phase(int mode
)
328 switch (mode
& ~(IEEE1284_DEVICEID
330 case IEEE1284_MODE_NIBBLE
:
331 case IEEE1284_MODE_BYTE
:
332 return IEEE1284_PH_REV_IDLE
;
334 return IEEE1284_PH_FWD_IDLE
;
337 static int pp_set_timeout(struct pardevice
*pdev
, long tv_sec
, int tv_usec
)
341 if ((tv_sec
< 0) || (tv_usec
< 0))
344 to_jiffies
= usecs_to_jiffies(tv_usec
);
345 to_jiffies
+= tv_sec
* HZ
;
349 pdev
->timeout
= to_jiffies
;
353 static int pp_do_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
355 unsigned int minor
= iminor(file_inode(file
));
356 struct pp_struct
*pp
= file
->private_data
;
357 struct parport
*port
;
358 void __user
*argp
= (void __user
*)arg
;
360 /* First handle the cases that don't take arguments. */
364 struct ieee1284_info
*info
;
367 if (pp
->flags
& PP_CLAIMED
) {
368 dev_dbg(&pp
->pdev
->dev
, "you've already got it!\n");
372 /* Deferred device registration. */
374 int err
= register_device(minor
, pp
);
380 ret
= parport_claim_or_block(pp
->pdev
);
384 pp
->flags
|= PP_CLAIMED
;
386 /* For interrupt-reporting to work, we need to be
387 * informed of each interrupt. */
390 /* We may need to fix up the state machine. */
391 info
= &pp
->pdev
->port
->ieee1284
;
392 pp
->saved_state
.mode
= info
->mode
;
393 pp
->saved_state
.phase
= info
->phase
;
394 info
->mode
= pp
->state
.mode
;
395 info
->phase
= pp
->state
.phase
;
396 pp
->default_inactivity
= parport_set_timeout(pp
->pdev
, 0);
397 parport_set_timeout(pp
->pdev
, pp
->default_inactivity
);
403 dev_dbg(&pp
->pdev
->dev
,
404 "too late for PPEXCL; already registered\n");
405 if (pp
->flags
& PP_EXCL
)
406 /* But it's not really an error. */
408 /* There's no chance of making the driver happy. */
412 /* Just remember to register the device exclusively
413 * when we finally do the registration. */
414 pp
->flags
|= PP_EXCL
;
420 if (copy_from_user(&mode
, argp
, sizeof(mode
)))
422 /* FIXME: validate mode */
423 pp
->state
.mode
= mode
;
424 pp
->state
.phase
= init_phase(mode
);
426 if (pp
->flags
& PP_CLAIMED
) {
427 pp
->pdev
->port
->ieee1284
.mode
= mode
;
428 pp
->pdev
->port
->ieee1284
.phase
= pp
->state
.phase
;
437 if (pp
->flags
& PP_CLAIMED
)
438 mode
= pp
->pdev
->port
->ieee1284
.mode
;
440 mode
= pp
->state
.mode
;
442 if (copy_to_user(argp
, &mode
, sizeof(mode
)))
450 if (copy_from_user(&phase
, argp
, sizeof(phase
)))
453 /* FIXME: validate phase */
454 pp
->state
.phase
= phase
;
456 if (pp
->flags
& PP_CLAIMED
)
457 pp
->pdev
->port
->ieee1284
.phase
= phase
;
465 if (pp
->flags
& PP_CLAIMED
)
466 phase
= pp
->pdev
->port
->ieee1284
.phase
;
468 phase
= pp
->state
.phase
;
469 if (copy_to_user(argp
, &phase
, sizeof(phase
)))
477 port
= parport_find_number(minor
);
482 parport_put_port(port
);
483 if (copy_to_user(argp
, &modes
, sizeof(modes
)))
491 if (copy_from_user(&uflags
, argp
, sizeof(uflags
)))
493 pp
->flags
&= ~PP_FLAGMASK
;
494 pp
->flags
|= (uflags
& PP_FLAGMASK
);
501 uflags
= pp
->flags
& PP_FLAGMASK
;
502 if (copy_to_user(argp
, &uflags
, sizeof(uflags
)))
508 /* Everything else requires the port to be claimed, so check
510 if ((pp
->flags
& PP_CLAIMED
) == 0) {
511 pr_debug(CHRDEV
"%x: claim the port first\n", minor
);
515 port
= pp
->pdev
->port
;
517 struct ieee1284_info
*info
;
523 struct timespec64 ts
;
527 reg
= parport_read_status(port
);
528 if (copy_to_user(argp
, ®
, sizeof(reg
)))
532 reg
= parport_read_data(port
);
533 if (copy_to_user(argp
, ®
, sizeof(reg
)))
537 reg
= parport_read_control(port
);
538 if (copy_to_user(argp
, ®
, sizeof(reg
)))
542 parport_yield_blocking(pp
->pdev
);
546 /* Save the state machine's state. */
547 info
= &pp
->pdev
->port
->ieee1284
;
548 pp
->state
.mode
= info
->mode
;
549 pp
->state
.phase
= info
->phase
;
550 info
->mode
= pp
->saved_state
.mode
;
551 info
->phase
= pp
->saved_state
.phase
;
552 parport_release(pp
->pdev
);
553 pp
->flags
&= ~PP_CLAIMED
;
557 if (copy_from_user(®
, argp
, sizeof(reg
)))
559 parport_write_control(port
, reg
);
563 if (copy_from_user(®
, argp
, sizeof(reg
)))
565 parport_write_data(port
, reg
);
569 if (copy_from_user(&mask
, argp
,
572 if (copy_from_user(®
, 1 + (unsigned char __user
*) arg
,
575 parport_frob_control(port
, mask
, reg
);
579 if (copy_from_user(&mode
, argp
, sizeof(mode
)))
582 port
->ops
->data_reverse(port
);
584 port
->ops
->data_forward(port
);
588 if (copy_from_user(&mode
, argp
, sizeof(mode
)))
590 switch ((ret
= parport_negotiate(port
, mode
))) {
592 case -1: /* handshake failed, peripheral not IEEE 1284 */
595 case 1: /* handshake succeeded, peripheral rejected mode */
603 if (copy_from_user(®
, argp
, sizeof(reg
)))
606 /* Remember what to set the control lines to, for next
607 * time we get an interrupt. */
613 ret
= atomic_read(&pp
->irqc
);
614 if (copy_to_user(argp
, &ret
, sizeof(ret
)))
616 atomic_sub(ret
, &pp
->irqc
);
620 if (copy_from_user(time32
, argp
, sizeof(time32
)))
623 return pp_set_timeout(pp
->pdev
, time32
[0], time32
[1]);
626 if (copy_from_user(time64
, argp
, sizeof(time64
)))
629 return pp_set_timeout(pp
->pdev
, time64
[0], time64
[1]);
632 jiffies_to_timespec64(pp
->pdev
->timeout
, &ts
);
633 time32
[0] = ts
.tv_sec
;
634 time32
[1] = ts
.tv_nsec
/ NSEC_PER_USEC
;
635 if ((time32
[0] < 0) || (time32
[1] < 0))
638 if (copy_to_user(argp
, time32
, sizeof(time32
)))
644 jiffies_to_timespec64(pp
->pdev
->timeout
, &ts
);
645 time64
[0] = ts
.tv_sec
;
646 time64
[1] = ts
.tv_nsec
/ NSEC_PER_USEC
;
647 if ((time64
[0] < 0) || (time64
[1] < 0))
650 if (copy_to_user(argp
, time64
, sizeof(time64
)))
656 dev_dbg(&pp
->pdev
->dev
, "What? (cmd=0x%x)\n", cmd
);
660 /* Keep the compiler happy */
664 static long pp_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
668 mutex_lock(&pp_do_mutex
);
669 ret
= pp_do_ioctl(file
, cmd
, arg
);
670 mutex_unlock(&pp_do_mutex
);
675 static long pp_compat_ioctl(struct file
*file
, unsigned int cmd
,
678 return pp_ioctl(file
, cmd
, (unsigned long)compat_ptr(arg
));
682 static int pp_open(struct inode
*inode
, struct file
*file
)
684 unsigned int minor
= iminor(inode
);
685 struct pp_struct
*pp
;
687 if (minor
>= PARPORT_MAX
)
690 pp
= kmalloc(sizeof(struct pp_struct
), GFP_KERNEL
);
694 pp
->state
.mode
= IEEE1284_MODE_COMPAT
;
695 pp
->state
.phase
= init_phase(pp
->state
.mode
);
698 atomic_set(&pp
->irqc
, 0);
699 init_waitqueue_head(&pp
->irq_wait
);
701 /* Defer the actual device registration until the first claim.
702 * That way, we know whether or not the driver wants to have
703 * exclusive access to the port (PPEXCL).
706 file
->private_data
= pp
;
711 static int pp_release(struct inode
*inode
, struct file
*file
)
713 unsigned int minor
= iminor(inode
);
714 struct pp_struct
*pp
= file
->private_data
;
718 if (!(pp
->flags
& PP_CLAIMED
) && pp
->pdev
&&
719 (pp
->state
.mode
!= IEEE1284_MODE_COMPAT
)) {
720 struct ieee1284_info
*info
;
722 /* parport released, but not in compatibility mode */
723 parport_claim_or_block(pp
->pdev
);
724 pp
->flags
|= PP_CLAIMED
;
725 info
= &pp
->pdev
->port
->ieee1284
;
726 pp
->saved_state
.mode
= info
->mode
;
727 pp
->saved_state
.phase
= info
->phase
;
728 info
->mode
= pp
->state
.mode
;
729 info
->phase
= pp
->state
.phase
;
731 } else if ((pp
->flags
& PP_CLAIMED
) && pp
->pdev
&&
732 (pp
->pdev
->port
->ieee1284
.mode
!= IEEE1284_MODE_COMPAT
)) {
736 parport_negotiate(pp
->pdev
->port
, IEEE1284_MODE_COMPAT
);
737 dev_dbg(&pp
->pdev
->dev
,
738 "negotiated back to compatibility mode because user-space forgot\n");
741 if (pp
->flags
& PP_CLAIMED
) {
742 struct ieee1284_info
*info
;
744 info
= &pp
->pdev
->port
->ieee1284
;
745 pp
->state
.mode
= info
->mode
;
746 pp
->state
.phase
= info
->phase
;
747 info
->mode
= pp
->saved_state
.mode
;
748 info
->phase
= pp
->saved_state
.phase
;
749 parport_release(pp
->pdev
);
750 if (compat_negot
!= 1) {
751 pr_debug(CHRDEV
"%x: released pardevice "
752 "because user-space forgot\n", minor
);
757 parport_unregister_device(pp
->pdev
);
759 pr_debug(CHRDEV
"%x: unregistered pardevice\n", minor
);
767 /* No kernel lock held - fine */
768 static unsigned int pp_poll(struct file
*file
, poll_table
*wait
)
770 struct pp_struct
*pp
= file
->private_data
;
771 unsigned int mask
= 0;
773 poll_wait(file
, &pp
->irq_wait
, wait
);
774 if (atomic_read(&pp
->irqc
))
775 mask
|= POLLIN
| POLLRDNORM
;
780 static struct class *ppdev_class
;
782 static const struct file_operations pp_fops
= {
783 .owner
= THIS_MODULE
,
788 .unlocked_ioctl
= pp_ioctl
,
790 .compat_ioctl
= pp_compat_ioctl
,
793 .release
= pp_release
,
796 static void pp_attach(struct parport
*port
)
800 if (devices
[port
->number
])
803 ret
= device_create(ppdev_class
, port
->dev
,
804 MKDEV(PP_MAJOR
, port
->number
), NULL
,
805 "parport%d", port
->number
);
807 pr_err("Failed to create device parport%d\n",
811 devices
[port
->number
] = ret
;
814 static void pp_detach(struct parport
*port
)
816 if (!devices
[port
->number
])
819 device_destroy(ppdev_class
, MKDEV(PP_MAJOR
, port
->number
));
820 devices
[port
->number
] = NULL
;
823 static int pp_probe(struct pardevice
*par_dev
)
825 struct device_driver
*drv
= par_dev
->dev
.driver
;
826 int len
= strlen(drv
->name
);
828 if (strncmp(par_dev
->name
, drv
->name
, len
))
834 static struct parport_driver pp_driver
= {
837 .match_port
= pp_attach
,
842 static int __init
ppdev_init(void)
846 if (register_chrdev(PP_MAJOR
, CHRDEV
, &pp_fops
)) {
847 pr_warn(CHRDEV
": unable to get major %d\n", PP_MAJOR
);
850 ppdev_class
= class_create(THIS_MODULE
, CHRDEV
);
851 if (IS_ERR(ppdev_class
)) {
852 err
= PTR_ERR(ppdev_class
);
855 err
= parport_register_driver(&pp_driver
);
857 pr_warn(CHRDEV
": unable to register with parport\n");
861 pr_info(PP_VERSION
"\n");
865 class_destroy(ppdev_class
);
867 unregister_chrdev(PP_MAJOR
, CHRDEV
);
872 static void __exit
ppdev_cleanup(void)
874 /* Clean up all parport stuff */
875 parport_unregister_driver(&pp_driver
);
876 class_destroy(ppdev_class
);
877 unregister_chrdev(PP_MAJOR
, CHRDEV
);
880 module_init(ppdev_init
);
881 module_exit(ppdev_cleanup
);
883 MODULE_LICENSE("GPL");
884 MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR
);