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
;
90 /* should we use PARDEVICE_MAX here? */
91 static struct device
*devices
[PARPORT_MAX
];
93 static DEFINE_IDA(ida_index
);
95 /* pp_struct.flags bitfields */
96 #define PP_CLAIMED (1<<0)
97 #define PP_EXCL (1<<1)
100 #define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
101 #define PP_BUFFER_SIZE 1024
102 #define PARDEVICE_MAX 8
104 /* ROUND_UP macro from fs/select.c */
105 #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
107 static DEFINE_MUTEX(pp_do_mutex
);
109 /* define fixed sized ioctl cmd for y2038 migration */
110 #define PPGETTIME32 _IOR(PP_IOCTL, 0x95, s32[2])
111 #define PPSETTIME32 _IOW(PP_IOCTL, 0x96, s32[2])
112 #define PPGETTIME64 _IOR(PP_IOCTL, 0x95, s64[2])
113 #define PPSETTIME64 _IOW(PP_IOCTL, 0x96, s64[2])
115 static inline void pp_enable_irq(struct pp_struct
*pp
)
117 struct parport
*port
= pp
->pdev
->port
;
119 port
->ops
->enable_irq(port
);
122 static ssize_t
pp_read(struct file
*file
, char __user
*buf
, size_t count
,
125 unsigned int minor
= iminor(file_inode(file
));
126 struct pp_struct
*pp
= file
->private_data
;
128 ssize_t bytes_read
= 0;
129 struct parport
*pport
;
132 if (!(pp
->flags
& PP_CLAIMED
)) {
133 /* Don't have the port claimed */
134 pr_debug(CHRDEV
"%x: claim the port first\n", minor
);
142 kbuffer
= kmalloc(min_t(size_t, count
, PP_BUFFER_SIZE
), GFP_KERNEL
);
145 pport
= pp
->pdev
->port
;
146 mode
= pport
->ieee1284
.mode
& ~(IEEE1284_DEVICEID
| IEEE1284_ADDR
);
148 parport_set_timeout(pp
->pdev
,
149 (file
->f_flags
& O_NONBLOCK
) ?
150 PARPORT_INACTIVITY_O_NONBLOCK
:
151 pp
->default_inactivity
);
153 while (bytes_read
== 0) {
154 ssize_t need
= min_t(unsigned long, count
, PP_BUFFER_SIZE
);
156 if (mode
== IEEE1284_MODE_EPP
) {
157 /* various specials for EPP mode */
159 size_t (*fn
)(struct parport
*, void *, size_t, int);
161 if (pp
->flags
& PP_W91284PIC
)
162 flags
|= PARPORT_W91284PIC
;
163 if (pp
->flags
& PP_FASTREAD
)
164 flags
|= PARPORT_EPP_FAST
;
165 if (pport
->ieee1284
.mode
& IEEE1284_ADDR
)
166 fn
= pport
->ops
->epp_read_addr
;
168 fn
= pport
->ops
->epp_read_data
;
169 bytes_read
= (*fn
)(pport
, kbuffer
, need
, flags
);
171 bytes_read
= parport_read(pport
, kbuffer
, need
);
177 if (file
->f_flags
& O_NONBLOCK
) {
178 bytes_read
= -EAGAIN
;
182 if (signal_pending(current
)) {
183 bytes_read
= -ERESTARTSYS
;
190 parport_set_timeout(pp
->pdev
, pp
->default_inactivity
);
192 if (bytes_read
> 0 && copy_to_user(buf
, kbuffer
, bytes_read
))
193 bytes_read
= -EFAULT
;
200 static ssize_t
pp_write(struct file
*file
, const char __user
*buf
,
201 size_t count
, loff_t
*ppos
)
203 unsigned int minor
= iminor(file_inode(file
));
204 struct pp_struct
*pp
= file
->private_data
;
206 ssize_t bytes_written
= 0;
209 struct parport
*pport
;
211 if (!(pp
->flags
& PP_CLAIMED
)) {
212 /* Don't have the port claimed */
213 pr_debug(CHRDEV
"%x: claim the port first\n", minor
);
217 kbuffer
= kmalloc(min_t(size_t, count
, PP_BUFFER_SIZE
), GFP_KERNEL
);
221 pport
= pp
->pdev
->port
;
222 mode
= pport
->ieee1284
.mode
& ~(IEEE1284_DEVICEID
| IEEE1284_ADDR
);
224 parport_set_timeout(pp
->pdev
,
225 (file
->f_flags
& O_NONBLOCK
) ?
226 PARPORT_INACTIVITY_O_NONBLOCK
:
227 pp
->default_inactivity
);
229 while (bytes_written
< count
) {
230 ssize_t n
= min_t(unsigned long, count
- bytes_written
, PP_BUFFER_SIZE
);
232 if (copy_from_user(kbuffer
, buf
+ bytes_written
, n
)) {
233 bytes_written
= -EFAULT
;
237 if ((pp
->flags
& PP_FASTWRITE
) && (mode
== IEEE1284_MODE_EPP
)) {
238 /* do a fast EPP write */
239 if (pport
->ieee1284
.mode
& IEEE1284_ADDR
) {
240 wrote
= pport
->ops
->epp_write_addr(pport
,
241 kbuffer
, n
, PARPORT_EPP_FAST
);
243 wrote
= pport
->ops
->epp_write_data(pport
,
244 kbuffer
, n
, PARPORT_EPP_FAST
);
247 wrote
= parport_write(pp
->pdev
->port
, kbuffer
, n
);
252 bytes_written
= wrote
;
256 bytes_written
+= wrote
;
258 if (file
->f_flags
& O_NONBLOCK
) {
260 bytes_written
= -EAGAIN
;
264 if (signal_pending(current
))
270 parport_set_timeout(pp
->pdev
, pp
->default_inactivity
);
274 return bytes_written
;
277 static void pp_irq(void *private)
279 struct pp_struct
*pp
= private;
281 if (pp
->irqresponse
) {
282 parport_write_control(pp
->pdev
->port
, pp
->irqctl
);
286 atomic_inc(&pp
->irqc
);
287 wake_up_interruptible(&pp
->irq_wait
);
290 static int register_device(int minor
, struct pp_struct
*pp
)
292 struct parport
*port
;
293 struct pardevice
*pdev
= NULL
;
295 struct pardev_cb ppdev_cb
;
298 name
= kasprintf(GFP_KERNEL
, CHRDEV
"%x", minor
);
302 port
= parport_find_number(minor
);
304 pr_warn("%s: no associated port!\n", name
);
309 index
= ida_simple_get(&ida_index
, 0, 0, GFP_KERNEL
);
310 memset(&ppdev_cb
, 0, sizeof(ppdev_cb
));
311 ppdev_cb
.irq_func
= pp_irq
;
312 ppdev_cb
.flags
= (pp
->flags
& PP_EXCL
) ? PARPORT_FLAG_EXCL
: 0;
313 ppdev_cb
.private = pp
;
314 pdev
= parport_register_dev_model(port
, name
, &ppdev_cb
, index
);
315 parport_put_port(port
);
318 pr_warn("%s: failed to register device!\n", name
);
320 ida_simple_remove(&ida_index
, index
);
326 dev_dbg(&pdev
->dev
, "registered pardevice\n");
332 static enum ieee1284_phase
init_phase(int mode
)
334 switch (mode
& ~(IEEE1284_DEVICEID
336 case IEEE1284_MODE_NIBBLE
:
337 case IEEE1284_MODE_BYTE
:
338 return IEEE1284_PH_REV_IDLE
;
340 return IEEE1284_PH_FWD_IDLE
;
343 static int pp_set_timeout(struct pardevice
*pdev
, long tv_sec
, int tv_usec
)
347 if ((tv_sec
< 0) || (tv_usec
< 0))
350 to_jiffies
= usecs_to_jiffies(tv_usec
);
351 to_jiffies
+= tv_sec
* HZ
;
355 pdev
->timeout
= to_jiffies
;
359 static int pp_do_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
361 unsigned int minor
= iminor(file_inode(file
));
362 struct pp_struct
*pp
= file
->private_data
;
363 struct parport
*port
;
364 void __user
*argp
= (void __user
*)arg
;
366 /* First handle the cases that don't take arguments. */
370 struct ieee1284_info
*info
;
373 if (pp
->flags
& PP_CLAIMED
) {
374 dev_dbg(&pp
->pdev
->dev
, "you've already got it!\n");
378 /* Deferred device registration. */
380 int err
= register_device(minor
, pp
);
386 ret
= parport_claim_or_block(pp
->pdev
);
390 pp
->flags
|= PP_CLAIMED
;
392 /* For interrupt-reporting to work, we need to be
393 * informed of each interrupt. */
396 /* We may need to fix up the state machine. */
397 info
= &pp
->pdev
->port
->ieee1284
;
398 pp
->saved_state
.mode
= info
->mode
;
399 pp
->saved_state
.phase
= info
->phase
;
400 info
->mode
= pp
->state
.mode
;
401 info
->phase
= pp
->state
.phase
;
402 pp
->default_inactivity
= parport_set_timeout(pp
->pdev
, 0);
403 parport_set_timeout(pp
->pdev
, pp
->default_inactivity
);
409 dev_dbg(&pp
->pdev
->dev
,
410 "too late for PPEXCL; already registered\n");
411 if (pp
->flags
& PP_EXCL
)
412 /* But it's not really an error. */
414 /* There's no chance of making the driver happy. */
418 /* Just remember to register the device exclusively
419 * when we finally do the registration. */
420 pp
->flags
|= PP_EXCL
;
426 if (copy_from_user(&mode
, argp
, sizeof(mode
)))
428 /* FIXME: validate mode */
429 pp
->state
.mode
= mode
;
430 pp
->state
.phase
= init_phase(mode
);
432 if (pp
->flags
& PP_CLAIMED
) {
433 pp
->pdev
->port
->ieee1284
.mode
= mode
;
434 pp
->pdev
->port
->ieee1284
.phase
= pp
->state
.phase
;
443 if (pp
->flags
& PP_CLAIMED
)
444 mode
= pp
->pdev
->port
->ieee1284
.mode
;
446 mode
= pp
->state
.mode
;
448 if (copy_to_user(argp
, &mode
, sizeof(mode
)))
456 if (copy_from_user(&phase
, argp
, sizeof(phase
)))
459 /* FIXME: validate phase */
460 pp
->state
.phase
= phase
;
462 if (pp
->flags
& PP_CLAIMED
)
463 pp
->pdev
->port
->ieee1284
.phase
= phase
;
471 if (pp
->flags
& PP_CLAIMED
)
472 phase
= pp
->pdev
->port
->ieee1284
.phase
;
474 phase
= pp
->state
.phase
;
475 if (copy_to_user(argp
, &phase
, sizeof(phase
)))
483 port
= parport_find_number(minor
);
488 parport_put_port(port
);
489 if (copy_to_user(argp
, &modes
, sizeof(modes
)))
497 if (copy_from_user(&uflags
, argp
, sizeof(uflags
)))
499 pp
->flags
&= ~PP_FLAGMASK
;
500 pp
->flags
|= (uflags
& PP_FLAGMASK
);
507 uflags
= pp
->flags
& PP_FLAGMASK
;
508 if (copy_to_user(argp
, &uflags
, sizeof(uflags
)))
514 /* Everything else requires the port to be claimed, so check
516 if ((pp
->flags
& PP_CLAIMED
) == 0) {
517 pr_debug(CHRDEV
"%x: claim the port first\n", minor
);
521 port
= pp
->pdev
->port
;
523 struct ieee1284_info
*info
;
529 struct timespec64 ts
;
533 reg
= parport_read_status(port
);
534 if (copy_to_user(argp
, ®
, sizeof(reg
)))
538 reg
= parport_read_data(port
);
539 if (copy_to_user(argp
, ®
, sizeof(reg
)))
543 reg
= parport_read_control(port
);
544 if (copy_to_user(argp
, ®
, sizeof(reg
)))
548 parport_yield_blocking(pp
->pdev
);
552 /* Save the state machine's state. */
553 info
= &pp
->pdev
->port
->ieee1284
;
554 pp
->state
.mode
= info
->mode
;
555 pp
->state
.phase
= info
->phase
;
556 info
->mode
= pp
->saved_state
.mode
;
557 info
->phase
= pp
->saved_state
.phase
;
558 parport_release(pp
->pdev
);
559 pp
->flags
&= ~PP_CLAIMED
;
563 if (copy_from_user(®
, argp
, sizeof(reg
)))
565 parport_write_control(port
, reg
);
569 if (copy_from_user(®
, argp
, sizeof(reg
)))
571 parport_write_data(port
, reg
);
575 if (copy_from_user(&mask
, argp
,
578 if (copy_from_user(®
, 1 + (unsigned char __user
*) arg
,
581 parport_frob_control(port
, mask
, reg
);
585 if (copy_from_user(&mode
, argp
, sizeof(mode
)))
588 port
->ops
->data_reverse(port
);
590 port
->ops
->data_forward(port
);
594 if (copy_from_user(&mode
, argp
, sizeof(mode
)))
596 switch ((ret
= parport_negotiate(port
, mode
))) {
598 case -1: /* handshake failed, peripheral not IEEE 1284 */
601 case 1: /* handshake succeeded, peripheral rejected mode */
609 if (copy_from_user(®
, argp
, sizeof(reg
)))
612 /* Remember what to set the control lines to, for next
613 * time we get an interrupt. */
619 ret
= atomic_read(&pp
->irqc
);
620 if (copy_to_user(argp
, &ret
, sizeof(ret
)))
622 atomic_sub(ret
, &pp
->irqc
);
626 if (copy_from_user(time32
, argp
, sizeof(time32
)))
629 return pp_set_timeout(pp
->pdev
, time32
[0], time32
[1]);
632 if (copy_from_user(time64
, argp
, sizeof(time64
)))
635 return pp_set_timeout(pp
->pdev
, time64
[0], time64
[1]);
638 jiffies_to_timespec64(pp
->pdev
->timeout
, &ts
);
639 time32
[0] = ts
.tv_sec
;
640 time32
[1] = ts
.tv_nsec
/ NSEC_PER_USEC
;
641 if ((time32
[0] < 0) || (time32
[1] < 0))
644 if (copy_to_user(argp
, time32
, sizeof(time32
)))
650 jiffies_to_timespec64(pp
->pdev
->timeout
, &ts
);
651 time64
[0] = ts
.tv_sec
;
652 time64
[1] = ts
.tv_nsec
/ NSEC_PER_USEC
;
653 if ((time64
[0] < 0) || (time64
[1] < 0))
656 if (copy_to_user(argp
, time64
, sizeof(time64
)))
662 dev_dbg(&pp
->pdev
->dev
, "What? (cmd=0x%x)\n", cmd
);
666 /* Keep the compiler happy */
670 static long pp_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
674 mutex_lock(&pp_do_mutex
);
675 ret
= pp_do_ioctl(file
, cmd
, arg
);
676 mutex_unlock(&pp_do_mutex
);
681 static long pp_compat_ioctl(struct file
*file
, unsigned int cmd
,
684 return pp_ioctl(file
, cmd
, (unsigned long)compat_ptr(arg
));
688 static int pp_open(struct inode
*inode
, struct file
*file
)
690 unsigned int minor
= iminor(inode
);
691 struct pp_struct
*pp
;
693 if (minor
>= PARPORT_MAX
)
696 pp
= kmalloc(sizeof(struct pp_struct
), GFP_KERNEL
);
700 pp
->state
.mode
= IEEE1284_MODE_COMPAT
;
701 pp
->state
.phase
= init_phase(pp
->state
.mode
);
704 atomic_set(&pp
->irqc
, 0);
705 init_waitqueue_head(&pp
->irq_wait
);
707 /* Defer the actual device registration until the first claim.
708 * That way, we know whether or not the driver wants to have
709 * exclusive access to the port (PPEXCL).
712 file
->private_data
= pp
;
717 static int pp_release(struct inode
*inode
, struct file
*file
)
719 unsigned int minor
= iminor(inode
);
720 struct pp_struct
*pp
= file
->private_data
;
724 if (!(pp
->flags
& PP_CLAIMED
) && pp
->pdev
&&
725 (pp
->state
.mode
!= IEEE1284_MODE_COMPAT
)) {
726 struct ieee1284_info
*info
;
728 /* parport released, but not in compatibility mode */
729 parport_claim_or_block(pp
->pdev
);
730 pp
->flags
|= PP_CLAIMED
;
731 info
= &pp
->pdev
->port
->ieee1284
;
732 pp
->saved_state
.mode
= info
->mode
;
733 pp
->saved_state
.phase
= info
->phase
;
734 info
->mode
= pp
->state
.mode
;
735 info
->phase
= pp
->state
.phase
;
737 } else if ((pp
->flags
& PP_CLAIMED
) && pp
->pdev
&&
738 (pp
->pdev
->port
->ieee1284
.mode
!= IEEE1284_MODE_COMPAT
)) {
742 parport_negotiate(pp
->pdev
->port
, IEEE1284_MODE_COMPAT
);
743 dev_dbg(&pp
->pdev
->dev
,
744 "negotiated back to compatibility mode because user-space forgot\n");
747 if (pp
->flags
& PP_CLAIMED
) {
748 struct ieee1284_info
*info
;
750 info
= &pp
->pdev
->port
->ieee1284
;
751 pp
->state
.mode
= info
->mode
;
752 pp
->state
.phase
= info
->phase
;
753 info
->mode
= pp
->saved_state
.mode
;
754 info
->phase
= pp
->saved_state
.phase
;
755 parport_release(pp
->pdev
);
756 if (compat_negot
!= 1) {
757 pr_debug(CHRDEV
"%x: released pardevice "
758 "because user-space forgot\n", minor
);
763 parport_unregister_device(pp
->pdev
);
764 ida_simple_remove(&ida_index
, pp
->index
);
766 pr_debug(CHRDEV
"%x: unregistered pardevice\n", minor
);
774 /* No kernel lock held - fine */
775 static unsigned int pp_poll(struct file
*file
, poll_table
*wait
)
777 struct pp_struct
*pp
= file
->private_data
;
778 unsigned int mask
= 0;
780 poll_wait(file
, &pp
->irq_wait
, wait
);
781 if (atomic_read(&pp
->irqc
))
782 mask
|= POLLIN
| POLLRDNORM
;
787 static struct class *ppdev_class
;
789 static const struct file_operations pp_fops
= {
790 .owner
= THIS_MODULE
,
795 .unlocked_ioctl
= pp_ioctl
,
797 .compat_ioctl
= pp_compat_ioctl
,
800 .release
= pp_release
,
803 static void pp_attach(struct parport
*port
)
807 if (devices
[port
->number
])
810 ret
= device_create(ppdev_class
, port
->dev
,
811 MKDEV(PP_MAJOR
, port
->number
), NULL
,
812 "parport%d", port
->number
);
814 pr_err("Failed to create device parport%d\n",
818 devices
[port
->number
] = ret
;
821 static void pp_detach(struct parport
*port
)
823 if (!devices
[port
->number
])
826 device_destroy(ppdev_class
, MKDEV(PP_MAJOR
, port
->number
));
827 devices
[port
->number
] = NULL
;
830 static int pp_probe(struct pardevice
*par_dev
)
832 struct device_driver
*drv
= par_dev
->dev
.driver
;
833 int len
= strlen(drv
->name
);
835 if (strncmp(par_dev
->name
, drv
->name
, len
))
841 static struct parport_driver pp_driver
= {
844 .match_port
= pp_attach
,
849 static int __init
ppdev_init(void)
853 if (register_chrdev(PP_MAJOR
, CHRDEV
, &pp_fops
)) {
854 pr_warn(CHRDEV
": unable to get major %d\n", PP_MAJOR
);
857 ppdev_class
= class_create(THIS_MODULE
, CHRDEV
);
858 if (IS_ERR(ppdev_class
)) {
859 err
= PTR_ERR(ppdev_class
);
862 err
= parport_register_driver(&pp_driver
);
864 pr_warn(CHRDEV
": unable to register with parport\n");
868 pr_info(PP_VERSION
"\n");
872 class_destroy(ppdev_class
);
874 unregister_chrdev(PP_MAJOR
, CHRDEV
);
879 static void __exit
ppdev_cleanup(void)
881 /* Clean up all parport stuff */
882 parport_unregister_driver(&pp_driver
);
883 class_destroy(ppdev_class
);
884 unregister_chrdev(PP_MAJOR
, CHRDEV
);
887 module_init(ppdev_init
);
888 module_exit(ppdev_cleanup
);
890 MODULE_LICENSE("GPL");
891 MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR
);