Root/drivers/char/ppdev.c

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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive