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