source: src/linux/universal/linux-4.9/drivers/char/ppdev.c @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 10 days ago

kernel update

File size: 20.6 KB
Line 
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#include <linux/compat.h>
73
74#define PP_VERSION "ppdev: user-space parallel port driver"
75#define CHRDEV "ppdev"
76
77struct pp_struct {
78        struct pardevice *pdev;
79        wait_queue_head_t irq_wait;
80        atomic_t irqc;
81        unsigned int flags;
82        int irqresponse;
83        unsigned char irqctl;
84        struct ieee1284_info state;
85        struct ieee1284_info saved_state;
86        long default_inactivity;
87        int index;
88};
89
90/* should we use PARDEVICE_MAX here? */
91static struct device *devices[PARPORT_MAX];
92
93static DEFINE_IDA(ida_index);
94
95/* pp_struct.flags bitfields */
96#define PP_CLAIMED    (1<<0)
97#define PP_EXCL       (1<<1)
98
99/* Other constants */
100#define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
101#define PP_BUFFER_SIZE 1024
102#define PARDEVICE_MAX 8
103
104/* ROUND_UP macro from fs/select.c */
105#define ROUND_UP(x,y) (((x)+(y)-1)/(y))
106
107static DEFINE_MUTEX(pp_do_mutex);
108
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])
114
115static inline void pp_enable_irq(struct pp_struct *pp)
116{
117        struct parport *port = pp->pdev->port;
118
119        port->ops->enable_irq(port);
120}
121
122static ssize_t pp_read(struct file *file, char __user *buf, size_t count,
123                       loff_t *ppos)
124{
125        unsigned int minor = iminor(file_inode(file));
126        struct pp_struct *pp = file->private_data;
127        char *kbuffer;
128        ssize_t bytes_read = 0;
129        struct parport *pport;
130        int mode;
131
132        if (!(pp->flags & PP_CLAIMED)) {
133                /* Don't have the port claimed */
134                pr_debug(CHRDEV "%x: claim the port first\n", minor);
135                return -EINVAL;
136        }
137
138        /* Trivial case. */
139        if (count == 0)
140                return 0;
141
142        kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
143        if (!kbuffer)
144                return -ENOMEM;
145        pport = pp->pdev->port;
146        mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
147
148        parport_set_timeout(pp->pdev,
149                            (file->f_flags & O_NONBLOCK) ?
150                            PARPORT_INACTIVITY_O_NONBLOCK :
151                            pp->default_inactivity);
152
153        while (bytes_read == 0) {
154                ssize_t need = min_t(unsigned long, count, PP_BUFFER_SIZE);
155
156                if (mode == IEEE1284_MODE_EPP) {
157                        /* various specials for EPP mode */
158                        int flags = 0;
159                        size_t (*fn)(struct parport *, void *, size_t, int);
160
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;
167                        else
168                                fn = pport->ops->epp_read_data;
169                        bytes_read = (*fn)(pport, kbuffer, need, flags);
170                } else {
171                        bytes_read = parport_read(pport, kbuffer, need);
172                }
173
174                if (bytes_read != 0)
175                        break;
176
177                if (file->f_flags & O_NONBLOCK) {
178                        bytes_read = -EAGAIN;
179                        break;
180                }
181
182                if (signal_pending(current)) {
183                        bytes_read = -ERESTARTSYS;
184                        break;
185                }
186
187                cond_resched();
188        }
189
190        parport_set_timeout(pp->pdev, pp->default_inactivity);
191
192        if (bytes_read > 0 && copy_to_user(buf, kbuffer, bytes_read))
193                bytes_read = -EFAULT;
194
195        kfree(kbuffer);
196        pp_enable_irq(pp);
197        return bytes_read;
198}
199
200static ssize_t pp_write(struct file *file, const char __user *buf,
201                        size_t count, loff_t *ppos)
202{
203        unsigned int minor = iminor(file_inode(file));
204        struct pp_struct *pp = file->private_data;
205        char *kbuffer;
206        ssize_t bytes_written = 0;
207        ssize_t wrote;
208        int mode;
209        struct parport *pport;
210
211        if (!(pp->flags & PP_CLAIMED)) {
212                /* Don't have the port claimed */
213                pr_debug(CHRDEV "%x: claim the port first\n", minor);
214                return -EINVAL;
215        }
216
217        kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
218        if (!kbuffer)
219                return -ENOMEM;
220
221        pport = pp->pdev->port;
222        mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
223
224        parport_set_timeout(pp->pdev,
225                            (file->f_flags & O_NONBLOCK) ?
226                            PARPORT_INACTIVITY_O_NONBLOCK :
227                            pp->default_inactivity);
228
229        while (bytes_written < count) {
230                ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
231
232                if (copy_from_user(kbuffer, buf + bytes_written, n)) {
233                        bytes_written = -EFAULT;
234                        break;
235                }
236
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);
242                        } else {
243                                wrote = pport->ops->epp_write_data(pport,
244                                        kbuffer, n, PARPORT_EPP_FAST);
245                        }
246                } else {
247                        wrote = parport_write(pp->pdev->port, kbuffer, n);
248                }
249
250                if (wrote <= 0) {
251                        if (!bytes_written)
252                                bytes_written = wrote;
253                        break;
254                }
255
256                bytes_written += wrote;
257
258                if (file->f_flags & O_NONBLOCK) {
259                        if (!bytes_written)
260                                bytes_written = -EAGAIN;
261                        break;
262                }
263
264                if (signal_pending(current))
265                        break;
266
267                cond_resched();
268        }
269
270        parport_set_timeout(pp->pdev, pp->default_inactivity);
271
272        kfree(kbuffer);
273        pp_enable_irq(pp);
274        return bytes_written;
275}
276
277static void pp_irq(void *private)
278{
279        struct pp_struct *pp = private;
280
281        if (pp->irqresponse) {
282                parport_write_control(pp->pdev->port, pp->irqctl);
283                pp->irqresponse = 0;
284        }
285
286        atomic_inc(&pp->irqc);
287        wake_up_interruptible(&pp->irq_wait);
288}
289
290static int register_device(int minor, struct pp_struct *pp)
291{
292        struct parport *port;
293        struct pardevice *pdev = NULL;
294        char *name;
295        struct pardev_cb ppdev_cb;
296        int index;
297
298        name = kasprintf(GFP_KERNEL, CHRDEV "%x", minor);
299        if (name == NULL)
300                return -ENOMEM;
301
302        port = parport_find_number(minor);
303        if (!port) {
304                printk(KERN_WARNING "%s: no associated port!\n", name);
305                kfree(name);
306                return -ENXIO;
307        }
308
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);
316
317        if (!pdev) {
318                printk(KERN_WARNING "%s: failed to register device!\n", name);
319                ida_simple_remove(&ida_index, index);
320                kfree(name);
321                return -ENXIO;
322        }
323
324        pp->pdev = pdev;
325        pp->index = index;
326        dev_dbg(&pdev->dev, "registered pardevice\n");
327        return 0;
328}
329
330static enum ieee1284_phase init_phase(int mode)
331{
332        switch (mode & ~(IEEE1284_DEVICEID
333                         | IEEE1284_ADDR)) {
334        case IEEE1284_MODE_NIBBLE:
335        case IEEE1284_MODE_BYTE:
336                return IEEE1284_PH_REV_IDLE;
337        }
338        return IEEE1284_PH_FWD_IDLE;
339}
340
341static int pp_set_timeout(struct pardevice *pdev, long tv_sec, int tv_usec)
342{
343        long to_jiffies;
344
345        if ((tv_sec < 0) || (tv_usec < 0))
346                return -EINVAL;
347
348        to_jiffies = usecs_to_jiffies(tv_usec);
349        to_jiffies += tv_sec * HZ;
350        if (to_jiffies <= 0)
351                return -EINVAL;
352
353        pdev->timeout = to_jiffies;
354        return 0;
355}
356
357static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
358{
359        unsigned int minor = iminor(file_inode(file));
360        struct pp_struct *pp = file->private_data;
361        struct parport *port;
362        void __user *argp = (void __user *)arg;
363
364        /* First handle the cases that don't take arguments. */
365        switch (cmd) {
366        case PPCLAIM:
367            {
368                struct ieee1284_info *info;
369                int ret;
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                struct ieee1284_info *info;
522                unsigned char reg;
523                unsigned char mask;
524                int mode;
525                s32 time32[2];
526                s64 time64[2];
527                struct timespec64 ts;
528                int ret;
529
530        case PPRSTATUS:
531                reg = parport_read_status(port);
532                if (copy_to_user(argp, &reg, sizeof(reg)))
533                        return -EFAULT;
534                return 0;
535        case PPRDATA:
536                reg = parport_read_data(port);
537                if (copy_to_user(argp, &reg, sizeof(reg)))
538                        return -EFAULT;
539                return 0;
540        case PPRCONTROL:
541                reg = parport_read_control(port);
542                if (copy_to_user(argp, &reg, sizeof(reg)))
543                        return -EFAULT;
544                return 0;
545        case PPYIELD:
546                parport_yield_blocking(pp->pdev);
547                return 0;
548
549        case PPRELEASE:
550                /* Save the state machine's state. */
551                info = &pp->pdev->port->ieee1284;
552                pp->state.mode = info->mode;
553                pp->state.phase = info->phase;
554                info->mode = pp->saved_state.mode;
555                info->phase = pp->saved_state.phase;
556                parport_release(pp->pdev);
557                pp->flags &= ~PP_CLAIMED;
558                return 0;
559
560        case PPWCONTROL:
561                if (copy_from_user(&reg, argp, sizeof(reg)))
562                        return -EFAULT;
563                parport_write_control(port, reg);
564                return 0;
565
566        case PPWDATA:
567                if (copy_from_user(&reg, argp, sizeof(reg)))
568                        return -EFAULT;
569                parport_write_data(port, reg);
570                return 0;
571
572        case PPFCONTROL:
573                if (copy_from_user(&mask, argp,
574                                   sizeof(mask)))
575                        return -EFAULT;
576                if (copy_from_user(&reg, 1 + (unsigned char __user *) arg,
577                                   sizeof(reg)))
578                        return -EFAULT;
579                parport_frob_control(port, mask, reg);
580                return 0;
581
582        case PPDATADIR:
583                if (copy_from_user(&mode, argp, sizeof(mode)))
584                        return -EFAULT;
585                if (mode)
586                        port->ops->data_reverse(port);
587                else
588                        port->ops->data_forward(port);
589                return 0;
590
591        case PPNEGOT:
592                if (copy_from_user(&mode, argp, sizeof(mode)))
593                        return -EFAULT;
594                switch ((ret = parport_negotiate(port, mode))) {
595                case 0: break;
596                case -1: /* handshake failed, peripheral not IEEE 1284 */
597                        ret = -EIO;
598                        break;
599                case 1:  /* handshake succeeded, peripheral rejected mode */
600                        ret = -ENXIO;
601                        break;
602                }
603                pp_enable_irq(pp);
604                return ret;
605
606        case PPWCTLONIRQ:
607                if (copy_from_user(&reg, argp, sizeof(reg)))
608                        return -EFAULT;
609
610                /* Remember what to set the control lines to, for next
611                 * time we get an interrupt. */
612                pp->irqctl = reg;
613                pp->irqresponse = 1;
614                return 0;
615
616        case PPCLRIRQ:
617                ret = atomic_read(&pp->irqc);
618                if (copy_to_user(argp, &ret, sizeof(ret)))
619                        return -EFAULT;
620                atomic_sub(ret, &pp->irqc);
621                return 0;
622
623        case PPSETTIME32:
624                if (copy_from_user(time32, argp, sizeof(time32)))
625                        return -EFAULT;
626
627                return pp_set_timeout(pp->pdev, time32[0], time32[1]);
628
629        case PPSETTIME64:
630                if (copy_from_user(time64, argp, sizeof(time64)))
631                        return -EFAULT;
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                if ((time32[0] < 0) || (time32[1] < 0))
640                        return -EINVAL;
641
642                if (copy_to_user(argp, time32, sizeof(time32)))
643                        return -EFAULT;
644
645                return 0;
646
647        case PPGETTIME64:
648                jiffies_to_timespec64(pp->pdev->timeout, &ts);
649                time64[0] = ts.tv_sec;
650                time64[1] = ts.tv_nsec / NSEC_PER_USEC;
651                if ((time64[0] < 0) || (time64[1] < 0))
652                        return -EINVAL;
653
654                if (copy_to_user(argp, time64, sizeof(time64)))
655                        return -EFAULT;
656
657                return 0;
658
659        default:
660                dev_dbg(&pp->pdev->dev, "What? (cmd=0x%x)\n", cmd);
661                return -EINVAL;
662        }
663
664        /* Keep the compiler happy */
665        return 0;
666}
667
668static long pp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
669{
670        long ret;
671
672        mutex_lock(&pp_do_mutex);
673        ret = pp_do_ioctl(file, cmd, arg);
674        mutex_unlock(&pp_do_mutex);
675        return ret;
676}
677
678#ifdef CONFIG_COMPAT
679static long pp_compat_ioctl(struct file *file, unsigned int cmd,
680                            unsigned long arg)
681{
682        return pp_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
683}
684#endif
685
686static int pp_open(struct inode *inode, struct file *file)
687{
688        unsigned int minor = iminor(inode);
689        struct pp_struct *pp;
690
691        if (minor >= PARPORT_MAX)
692                return -ENXIO;
693
694        pp = kmalloc(sizeof(struct pp_struct), GFP_KERNEL);
695        if (!pp)
696                return -ENOMEM;
697
698        pp->state.mode = IEEE1284_MODE_COMPAT;
699        pp->state.phase = init_phase(pp->state.mode);
700        pp->flags = 0;
701        pp->irqresponse = 0;
702        atomic_set(&pp->irqc, 0);
703        init_waitqueue_head(&pp->irq_wait);
704
705        /* Defer the actual device registration until the first claim.
706         * That way, we know whether or not the driver wants to have
707         * exclusive access to the port (PPEXCL).
708         */
709        pp->pdev = NULL;
710        file->private_data = pp;
711
712        return 0;
713}
714
715static int pp_release(struct inode *inode, struct file *file)
716{
717        unsigned int minor = iminor(inode);
718        struct pp_struct *pp = file->private_data;
719        int compat_negot;
720
721        compat_negot = 0;
722        if (!(pp->flags & PP_CLAIMED) && pp->pdev &&
723            (pp->state.mode != IEEE1284_MODE_COMPAT)) {
724                struct ieee1284_info *info;
725
726                /* parport released, but not in compatibility mode */
727                parport_claim_or_block(pp->pdev);
728                pp->flags |= PP_CLAIMED;
729                info = &pp->pdev->port->ieee1284;
730                pp->saved_state.mode = info->mode;
731                pp->saved_state.phase = info->phase;
732                info->mode = pp->state.mode;
733                info->phase = pp->state.phase;
734                compat_negot = 1;
735        } else if ((pp->flags & PP_CLAIMED) && pp->pdev &&
736            (pp->pdev->port->ieee1284.mode != IEEE1284_MODE_COMPAT)) {
737                compat_negot = 2;
738        }
739        if (compat_negot) {
740                parport_negotiate(pp->pdev->port, IEEE1284_MODE_COMPAT);
741                dev_dbg(&pp->pdev->dev,
742                        "negotiated back to compatibility mode because user-space forgot\n");
743        }
744
745        if (pp->flags & PP_CLAIMED) {
746                struct ieee1284_info *info;
747
748                info = &pp->pdev->port->ieee1284;
749                pp->state.mode = info->mode;
750                pp->state.phase = info->phase;
751                info->mode = pp->saved_state.mode;
752                info->phase = pp->saved_state.phase;
753                parport_release(pp->pdev);
754                if (compat_negot != 1) {
755                        pr_debug(CHRDEV "%x: released pardevice "
756                                "because user-space forgot\n", minor);
757                }
758        }
759
760        if (pp->pdev) {
761                parport_unregister_device(pp->pdev);
762                ida_simple_remove(&ida_index, pp->index);
763                pp->pdev = NULL;
764                pr_debug(CHRDEV "%x: unregistered pardevice\n", minor);
765        }
766
767        kfree(pp);
768
769        return 0;
770}
771
772/* No kernel lock held - fine */
773static unsigned int pp_poll(struct file *file, poll_table *wait)
774{
775        struct pp_struct *pp = file->private_data;
776        unsigned int mask = 0;
777
778        poll_wait(file, &pp->irq_wait, wait);
779        if (atomic_read(&pp->irqc))
780                mask |= POLLIN | POLLRDNORM;
781
782        return mask;
783}
784
785static struct class *ppdev_class;
786
787static const struct file_operations pp_fops = {
788        .owner          = THIS_MODULE,
789        .llseek         = no_llseek,
790        .read           = pp_read,
791        .write          = pp_write,
792        .poll           = pp_poll,
793        .unlocked_ioctl = pp_ioctl,
794#ifdef CONFIG_COMPAT
795        .compat_ioctl   = pp_compat_ioctl,
796#endif
797        .open           = pp_open,
798        .release        = pp_release,
799};
800
801static void pp_attach(struct parport *port)
802{
803        struct device *ret;
804
805        if (devices[port->number])
806                return;
807
808        ret = device_create(ppdev_class, port->dev,
809                            MKDEV(PP_MAJOR, port->number), NULL,
810                            "parport%d", port->number);
811        if (IS_ERR(ret)) {
812                pr_err("Failed to create device parport%d\n",
813                       port->number);
814                return;
815        }
816        devices[port->number] = ret;
817}
818
819static void pp_detach(struct parport *port)
820{
821        if (!devices[port->number])
822                return;
823
824        device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
825        devices[port->number] = NULL;
826}
827
828static int pp_probe(struct pardevice *par_dev)
829{
830        struct device_driver *drv = par_dev->dev.driver;
831        int len = strlen(drv->name);
832
833        if (strncmp(par_dev->name, drv->name, len))
834                return -ENODEV;
835
836        return 0;
837}
838
839static struct parport_driver pp_driver = {
840        .name           = CHRDEV,
841        .probe          = pp_probe,
842        .match_port     = pp_attach,
843        .detach         = pp_detach,
844        .devmodel       = true,
845};
846
847static int __init ppdev_init(void)
848{
849        int err = 0;
850
851        if (register_chrdev(PP_MAJOR, CHRDEV, &pp_fops)) {
852                printk(KERN_WARNING CHRDEV ": unable to get major %d\n",
853                       PP_MAJOR);
854                return -EIO;
855        }
856        ppdev_class = class_create(THIS_MODULE, CHRDEV);
857        if (IS_ERR(ppdev_class)) {
858                err = PTR_ERR(ppdev_class);
859                goto out_chrdev;
860        }
861        err = parport_register_driver(&pp_driver);
862        if (err < 0) {
863                printk(KERN_WARNING CHRDEV ": unable to register with parport\n");
864                goto out_class;
865        }
866
867        printk(KERN_INFO PP_VERSION "\n");
868        goto out;
869
870out_class:
871        class_destroy(ppdev_class);
872out_chrdev:
873        unregister_chrdev(PP_MAJOR, CHRDEV);
874out:
875        return err;
876}
877
878static void __exit ppdev_cleanup(void)
879{
880        /* Clean up all parport stuff */
881        parport_unregister_driver(&pp_driver);
882        class_destroy(ppdev_class);
883        unregister_chrdev(PP_MAJOR, CHRDEV);
884}
885
886module_init(ppdev_init);
887module_exit(ppdev_cleanup);
888
889MODULE_LICENSE("GPL");
890MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR);
Note: See TracBrowser for help on using the repository browser.