Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * linux/drivers/char/ppdev.c
0004  *
0005  * This is the code behind /dev/parport* -- it allows a user-space
0006  * application to use the parport subsystem.
0007  *
0008  * Copyright (C) 1998-2000, 2002 Tim Waugh <tim@cyberelk.net>
0009  *
0010  * A /dev/parportx device node represents an arbitrary device
0011  * on port 'x'.  The following operations are possible:
0012  *
0013  * open     do nothing, set up default IEEE 1284 protocol to be COMPAT
0014  * close    release port and unregister device (if necessary)
0015  * ioctl
0016  *   EXCL   register device exclusively (may fail)
0017  *   CLAIM  (register device first time) parport_claim_or_block
0018  *   RELEASE    parport_release
0019  *   SETMODE    set the IEEE 1284 protocol to use for read/write
0020  *   SETPHASE   set the IEEE 1284 phase of a particular mode.  Not to be
0021  *              confused with ioctl(fd, SETPHASER, &stun). ;-)
0022  *   DATADIR    data_forward / data_reverse
0023  *   WDATA  write_data
0024  *   RDATA  read_data
0025  *   WCONTROL   write_control
0026  *   RCONTROL   read_control
0027  *   FCONTROL   frob_control
0028  *   RSTATUS    read_status
0029  *   NEGOT  parport_negotiate
0030  *   YIELD  parport_yield_blocking
0031  *   WCTLONIRQ  on interrupt, set control lines
0032  *   CLRIRQ clear (and return) interrupt count
0033  *   SETTIME    sets device timeout (struct timeval)
0034  *   GETTIME    gets device timeout (struct timeval)
0035  *   GETMODES   gets hardware supported modes (unsigned int)
0036  *   GETMODE    gets the current IEEE1284 mode
0037  *   GETPHASE   gets the current IEEE1284 phase
0038  *   GETFLAGS   gets current (user-visible) flags
0039  *   SETFLAGS   sets current (user-visible) flags
0040  * read/write   read or write in current IEEE 1284 protocol
0041  * select   wait for interrupt (in readfds)
0042  *
0043  * Changes:
0044  * Added SETTIME/GETTIME ioctl, Fred Barnes, 1999.
0045  *
0046  * Arnaldo Carvalho de Melo <acme@conectiva.com.br> 2000/08/25
0047  * - On error, copy_from_user and copy_to_user do not return -EFAULT,
0048  *   They return the positive number of bytes *not* copied due to address
0049  *   space errors.
0050  *
0051  * Added GETMODES/GETMODE/GETPHASE ioctls, Fred Barnes <frmb2@ukc.ac.uk>, 03/01/2001.
0052  * Added GETFLAGS/SETFLAGS ioctls, Fred Barnes, 04/2001
0053  */
0054 
0055 #include <linux/module.h>
0056 #include <linux/init.h>
0057 #include <linux/sched/signal.h>
0058 #include <linux/device.h>
0059 #include <linux/ioctl.h>
0060 #include <linux/parport.h>
0061 #include <linux/ctype.h>
0062 #include <linux/poll.h>
0063 #include <linux/slab.h>
0064 #include <linux/major.h>
0065 #include <linux/ppdev.h>
0066 #include <linux/mutex.h>
0067 #include <linux/uaccess.h>
0068 #include <linux/compat.h>
0069 
0070 #define PP_VERSION "ppdev: user-space parallel port driver"
0071 #define CHRDEV "ppdev"
0072 
0073 struct pp_struct {
0074     struct pardevice *pdev;
0075     wait_queue_head_t irq_wait;
0076     atomic_t irqc;
0077     unsigned int flags;
0078     int irqresponse;
0079     unsigned char irqctl;
0080     struct ieee1284_info state;
0081     struct ieee1284_info saved_state;
0082     long default_inactivity;
0083     int index;
0084 };
0085 
0086 /* should we use PARDEVICE_MAX here? */
0087 static struct device *devices[PARPORT_MAX];
0088 
0089 static DEFINE_IDA(ida_index);
0090 
0091 /* pp_struct.flags bitfields */
0092 #define PP_CLAIMED    (1<<0)
0093 #define PP_EXCL       (1<<1)
0094 
0095 /* Other constants */
0096 #define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
0097 #define PP_BUFFER_SIZE 1024
0098 #define PARDEVICE_MAX 8
0099 
0100 static DEFINE_MUTEX(pp_do_mutex);
0101 
0102 /* define fixed sized ioctl cmd for y2038 migration */
0103 #define PPGETTIME32 _IOR(PP_IOCTL, 0x95, s32[2])
0104 #define PPSETTIME32 _IOW(PP_IOCTL, 0x96, s32[2])
0105 #define PPGETTIME64 _IOR(PP_IOCTL, 0x95, s64[2])
0106 #define PPSETTIME64 _IOW(PP_IOCTL, 0x96, s64[2])
0107 
0108 static inline void pp_enable_irq(struct pp_struct *pp)
0109 {
0110     struct parport *port = pp->pdev->port;
0111 
0112     port->ops->enable_irq(port);
0113 }
0114 
0115 static ssize_t pp_read(struct file *file, char __user *buf, size_t count,
0116                loff_t *ppos)
0117 {
0118     unsigned int minor = iminor(file_inode(file));
0119     struct pp_struct *pp = file->private_data;
0120     char *kbuffer;
0121     ssize_t bytes_read = 0;
0122     struct parport *pport;
0123     int mode;
0124 
0125     if (!(pp->flags & PP_CLAIMED)) {
0126         /* Don't have the port claimed */
0127         pr_debug(CHRDEV "%x: claim the port first\n", minor);
0128         return -EINVAL;
0129     }
0130 
0131     /* Trivial case. */
0132     if (count == 0)
0133         return 0;
0134 
0135     kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
0136     if (!kbuffer)
0137         return -ENOMEM;
0138     pport = pp->pdev->port;
0139     mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
0140 
0141     parport_set_timeout(pp->pdev,
0142                 (file->f_flags & O_NONBLOCK) ?
0143                 PARPORT_INACTIVITY_O_NONBLOCK :
0144                 pp->default_inactivity);
0145 
0146     while (bytes_read == 0) {
0147         ssize_t need = min_t(unsigned long, count, PP_BUFFER_SIZE);
0148 
0149         if (mode == IEEE1284_MODE_EPP) {
0150             /* various specials for EPP mode */
0151             int flags = 0;
0152             size_t (*fn)(struct parport *, void *, size_t, int);
0153 
0154             if (pp->flags & PP_W91284PIC)
0155                 flags |= PARPORT_W91284PIC;
0156             if (pp->flags & PP_FASTREAD)
0157                 flags |= PARPORT_EPP_FAST;
0158             if (pport->ieee1284.mode & IEEE1284_ADDR)
0159                 fn = pport->ops->epp_read_addr;
0160             else
0161                 fn = pport->ops->epp_read_data;
0162             bytes_read = (*fn)(pport, kbuffer, need, flags);
0163         } else {
0164             bytes_read = parport_read(pport, kbuffer, need);
0165         }
0166 
0167         if (bytes_read != 0)
0168             break;
0169 
0170         if (file->f_flags & O_NONBLOCK) {
0171             bytes_read = -EAGAIN;
0172             break;
0173         }
0174 
0175         if (signal_pending(current)) {
0176             bytes_read = -ERESTARTSYS;
0177             break;
0178         }
0179 
0180         cond_resched();
0181     }
0182 
0183     parport_set_timeout(pp->pdev, pp->default_inactivity);
0184 
0185     if (bytes_read > 0 && copy_to_user(buf, kbuffer, bytes_read))
0186         bytes_read = -EFAULT;
0187 
0188     kfree(kbuffer);
0189     pp_enable_irq(pp);
0190     return bytes_read;
0191 }
0192 
0193 static ssize_t pp_write(struct file *file, const char __user *buf,
0194             size_t count, loff_t *ppos)
0195 {
0196     unsigned int minor = iminor(file_inode(file));
0197     struct pp_struct *pp = file->private_data;
0198     char *kbuffer;
0199     ssize_t bytes_written = 0;
0200     ssize_t wrote;
0201     int mode;
0202     struct parport *pport;
0203 
0204     if (!(pp->flags & PP_CLAIMED)) {
0205         /* Don't have the port claimed */
0206         pr_debug(CHRDEV "%x: claim the port first\n", minor);
0207         return -EINVAL;
0208     }
0209 
0210     kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
0211     if (!kbuffer)
0212         return -ENOMEM;
0213 
0214     pport = pp->pdev->port;
0215     mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
0216 
0217     parport_set_timeout(pp->pdev,
0218                 (file->f_flags & O_NONBLOCK) ?
0219                 PARPORT_INACTIVITY_O_NONBLOCK :
0220                 pp->default_inactivity);
0221 
0222     while (bytes_written < count) {
0223         ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
0224 
0225         if (copy_from_user(kbuffer, buf + bytes_written, n)) {
0226             bytes_written = -EFAULT;
0227             break;
0228         }
0229 
0230         if ((pp->flags & PP_FASTWRITE) && (mode == IEEE1284_MODE_EPP)) {
0231             /* do a fast EPP write */
0232             if (pport->ieee1284.mode & IEEE1284_ADDR) {
0233                 wrote = pport->ops->epp_write_addr(pport,
0234                     kbuffer, n, PARPORT_EPP_FAST);
0235             } else {
0236                 wrote = pport->ops->epp_write_data(pport,
0237                     kbuffer, n, PARPORT_EPP_FAST);
0238             }
0239         } else {
0240             wrote = parport_write(pp->pdev->port, kbuffer, n);
0241         }
0242 
0243         if (wrote <= 0) {
0244             if (!bytes_written)
0245                 bytes_written = wrote;
0246             break;
0247         }
0248 
0249         bytes_written += wrote;
0250 
0251         if (file->f_flags & O_NONBLOCK) {
0252             if (!bytes_written)
0253                 bytes_written = -EAGAIN;
0254             break;
0255         }
0256 
0257         if (signal_pending(current))
0258             break;
0259 
0260         cond_resched();
0261     }
0262 
0263     parport_set_timeout(pp->pdev, pp->default_inactivity);
0264 
0265     kfree(kbuffer);
0266     pp_enable_irq(pp);
0267     return bytes_written;
0268 }
0269 
0270 static void pp_irq(void *private)
0271 {
0272     struct pp_struct *pp = private;
0273 
0274     if (pp->irqresponse) {
0275         parport_write_control(pp->pdev->port, pp->irqctl);
0276         pp->irqresponse = 0;
0277     }
0278 
0279     atomic_inc(&pp->irqc);
0280     wake_up_interruptible(&pp->irq_wait);
0281 }
0282 
0283 static int register_device(int minor, struct pp_struct *pp)
0284 {
0285     struct parport *port;
0286     struct pardevice *pdev = NULL;
0287     char *name;
0288     struct pardev_cb ppdev_cb;
0289     int rc = 0, index;
0290 
0291     name = kasprintf(GFP_KERNEL, CHRDEV "%x", minor);
0292     if (name == NULL)
0293         return -ENOMEM;
0294 
0295     port = parport_find_number(minor);
0296     if (!port) {
0297         pr_warn("%s: no associated port!\n", name);
0298         rc = -ENXIO;
0299         goto err;
0300     }
0301 
0302     index = ida_simple_get(&ida_index, 0, 0, GFP_KERNEL);
0303     memset(&ppdev_cb, 0, sizeof(ppdev_cb));
0304     ppdev_cb.irq_func = pp_irq;
0305     ppdev_cb.flags = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0;
0306     ppdev_cb.private = pp;
0307     pdev = parport_register_dev_model(port, name, &ppdev_cb, index);
0308     parport_put_port(port);
0309 
0310     if (!pdev) {
0311         pr_warn("%s: failed to register device!\n", name);
0312         rc = -ENXIO;
0313         ida_simple_remove(&ida_index, index);
0314         goto err;
0315     }
0316 
0317     pp->pdev = pdev;
0318     pp->index = index;
0319     dev_dbg(&pdev->dev, "registered pardevice\n");
0320 err:
0321     kfree(name);
0322     return rc;
0323 }
0324 
0325 static enum ieee1284_phase init_phase(int mode)
0326 {
0327     switch (mode & ~(IEEE1284_DEVICEID
0328              | IEEE1284_ADDR)) {
0329     case IEEE1284_MODE_NIBBLE:
0330     case IEEE1284_MODE_BYTE:
0331         return IEEE1284_PH_REV_IDLE;
0332     }
0333     return IEEE1284_PH_FWD_IDLE;
0334 }
0335 
0336 static int pp_set_timeout(struct pardevice *pdev, long tv_sec, int tv_usec)
0337 {
0338     long to_jiffies;
0339 
0340     if ((tv_sec < 0) || (tv_usec < 0))
0341         return -EINVAL;
0342 
0343     to_jiffies = usecs_to_jiffies(tv_usec);
0344     to_jiffies += tv_sec * HZ;
0345     if (to_jiffies <= 0)
0346         return -EINVAL;
0347 
0348     pdev->timeout = to_jiffies;
0349     return 0;
0350 }
0351 
0352 static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
0353 {
0354     unsigned int minor = iminor(file_inode(file));
0355     struct pp_struct *pp = file->private_data;
0356     struct parport *port;
0357     void __user *argp = (void __user *)arg;
0358     struct ieee1284_info *info;
0359     unsigned char reg;
0360     unsigned char mask;
0361     int mode;
0362     s32 time32[2];
0363     s64 time64[2];
0364     struct timespec64 ts;
0365     int ret;
0366 
0367     /* First handle the cases that don't take arguments. */
0368     switch (cmd) {
0369     case PPCLAIM:
0370         {
0371         if (pp->flags & PP_CLAIMED) {
0372             dev_dbg(&pp->pdev->dev, "you've already got it!\n");
0373             return -EINVAL;
0374         }
0375 
0376         /* Deferred device registration. */
0377         if (!pp->pdev) {
0378             int err = register_device(minor, pp);
0379 
0380             if (err)
0381                 return err;
0382         }
0383 
0384         ret = parport_claim_or_block(pp->pdev);
0385         if (ret < 0)
0386             return ret;
0387 
0388         pp->flags |= PP_CLAIMED;
0389 
0390         /* For interrupt-reporting to work, we need to be
0391          * informed of each interrupt. */
0392         pp_enable_irq(pp);
0393 
0394         /* We may need to fix up the state machine. */
0395         info = &pp->pdev->port->ieee1284;
0396         pp->saved_state.mode = info->mode;
0397         pp->saved_state.phase = info->phase;
0398         info->mode = pp->state.mode;
0399         info->phase = pp->state.phase;
0400         pp->default_inactivity = parport_set_timeout(pp->pdev, 0);
0401         parport_set_timeout(pp->pdev, pp->default_inactivity);
0402 
0403         return 0;
0404         }
0405     case PPEXCL:
0406         if (pp->pdev) {
0407             dev_dbg(&pp->pdev->dev,
0408                 "too late for PPEXCL; already registered\n");
0409             if (pp->flags & PP_EXCL)
0410                 /* But it's not really an error. */
0411                 return 0;
0412             /* There's no chance of making the driver happy. */
0413             return -EINVAL;
0414         }
0415 
0416         /* Just remember to register the device exclusively
0417          * when we finally do the registration. */
0418         pp->flags |= PP_EXCL;
0419         return 0;
0420     case PPSETMODE:
0421         {
0422         int mode;
0423 
0424         if (copy_from_user(&mode, argp, sizeof(mode)))
0425             return -EFAULT;
0426         /* FIXME: validate mode */
0427         pp->state.mode = mode;
0428         pp->state.phase = init_phase(mode);
0429 
0430         if (pp->flags & PP_CLAIMED) {
0431             pp->pdev->port->ieee1284.mode = mode;
0432             pp->pdev->port->ieee1284.phase = pp->state.phase;
0433         }
0434 
0435         return 0;
0436         }
0437     case PPGETMODE:
0438         {
0439         int mode;
0440 
0441         if (pp->flags & PP_CLAIMED)
0442             mode = pp->pdev->port->ieee1284.mode;
0443         else
0444             mode = pp->state.mode;
0445 
0446         if (copy_to_user(argp, &mode, sizeof(mode)))
0447             return -EFAULT;
0448         return 0;
0449         }
0450     case PPSETPHASE:
0451         {
0452         int phase;
0453 
0454         if (copy_from_user(&phase, argp, sizeof(phase)))
0455             return -EFAULT;
0456 
0457         /* FIXME: validate phase */
0458         pp->state.phase = phase;
0459 
0460         if (pp->flags & PP_CLAIMED)
0461             pp->pdev->port->ieee1284.phase = phase;
0462 
0463         return 0;
0464         }
0465     case PPGETPHASE:
0466         {
0467         int phase;
0468 
0469         if (pp->flags & PP_CLAIMED)
0470             phase = pp->pdev->port->ieee1284.phase;
0471         else
0472             phase = pp->state.phase;
0473         if (copy_to_user(argp, &phase, sizeof(phase)))
0474             return -EFAULT;
0475         return 0;
0476         }
0477     case PPGETMODES:
0478         {
0479         unsigned int modes;
0480 
0481         port = parport_find_number(minor);
0482         if (!port)
0483             return -ENODEV;
0484 
0485         modes = port->modes;
0486         parport_put_port(port);
0487         if (copy_to_user(argp, &modes, sizeof(modes)))
0488             return -EFAULT;
0489         return 0;
0490         }
0491     case PPSETFLAGS:
0492         {
0493         int uflags;
0494 
0495         if (copy_from_user(&uflags, argp, sizeof(uflags)))
0496             return -EFAULT;
0497         pp->flags &= ~PP_FLAGMASK;
0498         pp->flags |= (uflags & PP_FLAGMASK);
0499         return 0;
0500         }
0501     case PPGETFLAGS:
0502         {
0503         int uflags;
0504 
0505         uflags = pp->flags & PP_FLAGMASK;
0506         if (copy_to_user(argp, &uflags, sizeof(uflags)))
0507             return -EFAULT;
0508         return 0;
0509         }
0510     }   /* end switch() */
0511 
0512     /* Everything else requires the port to be claimed, so check
0513      * that now. */
0514     if ((pp->flags & PP_CLAIMED) == 0) {
0515         pr_debug(CHRDEV "%x: claim the port first\n", minor);
0516         return -EINVAL;
0517     }
0518 
0519     port = pp->pdev->port;
0520     switch (cmd) {
0521     case PPRSTATUS:
0522         reg = parport_read_status(port);
0523         if (copy_to_user(argp, &reg, sizeof(reg)))
0524             return -EFAULT;
0525         return 0;
0526     case PPRDATA:
0527         reg = parport_read_data(port);
0528         if (copy_to_user(argp, &reg, sizeof(reg)))
0529             return -EFAULT;
0530         return 0;
0531     case PPRCONTROL:
0532         reg = parport_read_control(port);
0533         if (copy_to_user(argp, &reg, sizeof(reg)))
0534             return -EFAULT;
0535         return 0;
0536     case PPYIELD:
0537         parport_yield_blocking(pp->pdev);
0538         return 0;
0539 
0540     case PPRELEASE:
0541         /* Save the state machine's state. */
0542         info = &pp->pdev->port->ieee1284;
0543         pp->state.mode = info->mode;
0544         pp->state.phase = info->phase;
0545         info->mode = pp->saved_state.mode;
0546         info->phase = pp->saved_state.phase;
0547         parport_release(pp->pdev);
0548         pp->flags &= ~PP_CLAIMED;
0549         return 0;
0550 
0551     case PPWCONTROL:
0552         if (copy_from_user(&reg, argp, sizeof(reg)))
0553             return -EFAULT;
0554         parport_write_control(port, reg);
0555         return 0;
0556 
0557     case PPWDATA:
0558         if (copy_from_user(&reg, argp, sizeof(reg)))
0559             return -EFAULT;
0560         parport_write_data(port, reg);
0561         return 0;
0562 
0563     case PPFCONTROL:
0564         if (copy_from_user(&mask, argp,
0565                    sizeof(mask)))
0566             return -EFAULT;
0567         if (copy_from_user(&reg, 1 + (unsigned char __user *) arg,
0568                    sizeof(reg)))
0569             return -EFAULT;
0570         parport_frob_control(port, mask, reg);
0571         return 0;
0572 
0573     case PPDATADIR:
0574         if (copy_from_user(&mode, argp, sizeof(mode)))
0575             return -EFAULT;
0576         if (mode)
0577             port->ops->data_reverse(port);
0578         else
0579             port->ops->data_forward(port);
0580         return 0;
0581 
0582     case PPNEGOT:
0583         if (copy_from_user(&mode, argp, sizeof(mode)))
0584             return -EFAULT;
0585         switch ((ret = parport_negotiate(port, mode))) {
0586         case 0: break;
0587         case -1: /* handshake failed, peripheral not IEEE 1284 */
0588             ret = -EIO;
0589             break;
0590         case 1:  /* handshake succeeded, peripheral rejected mode */
0591             ret = -ENXIO;
0592             break;
0593         }
0594         pp_enable_irq(pp);
0595         return ret;
0596 
0597     case PPWCTLONIRQ:
0598         if (copy_from_user(&reg, argp, sizeof(reg)))
0599             return -EFAULT;
0600 
0601         /* Remember what to set the control lines to, for next
0602          * time we get an interrupt. */
0603         pp->irqctl = reg;
0604         pp->irqresponse = 1;
0605         return 0;
0606 
0607     case PPCLRIRQ:
0608         ret = atomic_read(&pp->irqc);
0609         if (copy_to_user(argp, &ret, sizeof(ret)))
0610             return -EFAULT;
0611         atomic_sub(ret, &pp->irqc);
0612         return 0;
0613 
0614     case PPSETTIME32:
0615         if (copy_from_user(time32, argp, sizeof(time32)))
0616             return -EFAULT;
0617 
0618         if ((time32[0] < 0) || (time32[1] < 0))
0619             return -EINVAL;
0620 
0621         return pp_set_timeout(pp->pdev, time32[0], time32[1]);
0622 
0623     case PPSETTIME64:
0624         if (copy_from_user(time64, argp, sizeof(time64)))
0625             return -EFAULT;
0626 
0627         if ((time64[0] < 0) || (time64[1] < 0))
0628             return -EINVAL;
0629 
0630         if (IS_ENABLED(CONFIG_SPARC64) && !in_compat_syscall())
0631             time64[1] >>= 32;
0632 
0633         return pp_set_timeout(pp->pdev, time64[0], time64[1]);
0634 
0635     case PPGETTIME32:
0636         jiffies_to_timespec64(pp->pdev->timeout, &ts);
0637         time32[0] = ts.tv_sec;
0638         time32[1] = ts.tv_nsec / NSEC_PER_USEC;
0639 
0640         if (copy_to_user(argp, time32, sizeof(time32)))
0641             return -EFAULT;
0642 
0643         return 0;
0644 
0645     case PPGETTIME64:
0646         jiffies_to_timespec64(pp->pdev->timeout, &ts);
0647         time64[0] = ts.tv_sec;
0648         time64[1] = ts.tv_nsec / NSEC_PER_USEC;
0649 
0650         if (IS_ENABLED(CONFIG_SPARC64) && !in_compat_syscall())
0651             time64[1] <<= 32;
0652 
0653         if (copy_to_user(argp, time64, sizeof(time64)))
0654             return -EFAULT;
0655 
0656         return 0;
0657 
0658     default:
0659         dev_dbg(&pp->pdev->dev, "What? (cmd=0x%x)\n", cmd);
0660         return -EINVAL;
0661     }
0662 
0663     /* Keep the compiler happy */
0664     return 0;
0665 }
0666 
0667 static long pp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
0668 {
0669     long ret;
0670 
0671     mutex_lock(&pp_do_mutex);
0672     ret = pp_do_ioctl(file, cmd, arg);
0673     mutex_unlock(&pp_do_mutex);
0674     return ret;
0675 }
0676 
0677 static int pp_open(struct inode *inode, struct file *file)
0678 {
0679     unsigned int minor = iminor(inode);
0680     struct pp_struct *pp;
0681 
0682     if (minor >= PARPORT_MAX)
0683         return -ENXIO;
0684 
0685     pp = kmalloc(sizeof(struct pp_struct), GFP_KERNEL);
0686     if (!pp)
0687         return -ENOMEM;
0688 
0689     pp->state.mode = IEEE1284_MODE_COMPAT;
0690     pp->state.phase = init_phase(pp->state.mode);
0691     pp->flags = 0;
0692     pp->irqresponse = 0;
0693     atomic_set(&pp->irqc, 0);
0694     init_waitqueue_head(&pp->irq_wait);
0695 
0696     /* Defer the actual device registration until the first claim.
0697      * That way, we know whether or not the driver wants to have
0698      * exclusive access to the port (PPEXCL).
0699      */
0700     pp->pdev = NULL;
0701     file->private_data = pp;
0702 
0703     return 0;
0704 }
0705 
0706 static int pp_release(struct inode *inode, struct file *file)
0707 {
0708     unsigned int minor = iminor(inode);
0709     struct pp_struct *pp = file->private_data;
0710     int compat_negot;
0711 
0712     compat_negot = 0;
0713     if (!(pp->flags & PP_CLAIMED) && pp->pdev &&
0714         (pp->state.mode != IEEE1284_MODE_COMPAT)) {
0715         struct ieee1284_info *info;
0716 
0717         /* parport released, but not in compatibility mode */
0718         parport_claim_or_block(pp->pdev);
0719         pp->flags |= PP_CLAIMED;
0720         info = &pp->pdev->port->ieee1284;
0721         pp->saved_state.mode = info->mode;
0722         pp->saved_state.phase = info->phase;
0723         info->mode = pp->state.mode;
0724         info->phase = pp->state.phase;
0725         compat_negot = 1;
0726     } else if ((pp->flags & PP_CLAIMED) && pp->pdev &&
0727         (pp->pdev->port->ieee1284.mode != IEEE1284_MODE_COMPAT)) {
0728         compat_negot = 2;
0729     }
0730     if (compat_negot) {
0731         parport_negotiate(pp->pdev->port, IEEE1284_MODE_COMPAT);
0732         dev_dbg(&pp->pdev->dev,
0733             "negotiated back to compatibility mode because user-space forgot\n");
0734     }
0735 
0736     if ((pp->flags & PP_CLAIMED) && pp->pdev) {
0737         struct ieee1284_info *info;
0738 
0739         info = &pp->pdev->port->ieee1284;
0740         pp->state.mode = info->mode;
0741         pp->state.phase = info->phase;
0742         info->mode = pp->saved_state.mode;
0743         info->phase = pp->saved_state.phase;
0744         parport_release(pp->pdev);
0745         if (compat_negot != 1) {
0746             pr_debug(CHRDEV "%x: released pardevice "
0747                 "because user-space forgot\n", minor);
0748         }
0749     }
0750 
0751     if (pp->pdev) {
0752         parport_unregister_device(pp->pdev);
0753         ida_simple_remove(&ida_index, pp->index);
0754         pp->pdev = NULL;
0755         pr_debug(CHRDEV "%x: unregistered pardevice\n", minor);
0756     }
0757 
0758     kfree(pp);
0759 
0760     return 0;
0761 }
0762 
0763 /* No kernel lock held - fine */
0764 static __poll_t pp_poll(struct file *file, poll_table *wait)
0765 {
0766     struct pp_struct *pp = file->private_data;
0767     __poll_t mask = 0;
0768 
0769     poll_wait(file, &pp->irq_wait, wait);
0770     if (atomic_read(&pp->irqc))
0771         mask |= EPOLLIN | EPOLLRDNORM;
0772 
0773     return mask;
0774 }
0775 
0776 static struct class *ppdev_class;
0777 
0778 static const struct file_operations pp_fops = {
0779     .owner      = THIS_MODULE,
0780     .llseek     = no_llseek,
0781     .read       = pp_read,
0782     .write      = pp_write,
0783     .poll       = pp_poll,
0784     .unlocked_ioctl = pp_ioctl,
0785     .compat_ioctl   = compat_ptr_ioctl,
0786     .open       = pp_open,
0787     .release    = pp_release,
0788 };
0789 
0790 static void pp_attach(struct parport *port)
0791 {
0792     struct device *ret;
0793 
0794     if (devices[port->number])
0795         return;
0796 
0797     ret = device_create(ppdev_class, port->dev,
0798                 MKDEV(PP_MAJOR, port->number), NULL,
0799                 "parport%d", port->number);
0800     if (IS_ERR(ret)) {
0801         pr_err("Failed to create device parport%d\n",
0802                port->number);
0803         return;
0804     }
0805     devices[port->number] = ret;
0806 }
0807 
0808 static void pp_detach(struct parport *port)
0809 {
0810     if (!devices[port->number])
0811         return;
0812 
0813     device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
0814     devices[port->number] = NULL;
0815 }
0816 
0817 static int pp_probe(struct pardevice *par_dev)
0818 {
0819     struct device_driver *drv = par_dev->dev.driver;
0820     int len = strlen(drv->name);
0821 
0822     if (strncmp(par_dev->name, drv->name, len))
0823         return -ENODEV;
0824 
0825     return 0;
0826 }
0827 
0828 static struct parport_driver pp_driver = {
0829     .name       = CHRDEV,
0830     .probe      = pp_probe,
0831     .match_port = pp_attach,
0832     .detach     = pp_detach,
0833     .devmodel   = true,
0834 };
0835 
0836 static int __init ppdev_init(void)
0837 {
0838     int err = 0;
0839 
0840     if (register_chrdev(PP_MAJOR, CHRDEV, &pp_fops)) {
0841         pr_warn(CHRDEV ": unable to get major %d\n", PP_MAJOR);
0842         return -EIO;
0843     }
0844     ppdev_class = class_create(THIS_MODULE, CHRDEV);
0845     if (IS_ERR(ppdev_class)) {
0846         err = PTR_ERR(ppdev_class);
0847         goto out_chrdev;
0848     }
0849     err = parport_register_driver(&pp_driver);
0850     if (err < 0) {
0851         pr_warn(CHRDEV ": unable to register with parport\n");
0852         goto out_class;
0853     }
0854 
0855     pr_info(PP_VERSION "\n");
0856     goto out;
0857 
0858 out_class:
0859     class_destroy(ppdev_class);
0860 out_chrdev:
0861     unregister_chrdev(PP_MAJOR, CHRDEV);
0862 out:
0863     return err;
0864 }
0865 
0866 static void __exit ppdev_cleanup(void)
0867 {
0868     /* Clean up all parport stuff */
0869     parport_unregister_driver(&pp_driver);
0870     class_destroy(ppdev_class);
0871     unregister_chrdev(PP_MAJOR, CHRDEV);
0872 }
0873 
0874 module_init(ppdev_init);
0875 module_exit(ppdev_cleanup);
0876 
0877 MODULE_LICENSE("GPL");
0878 MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!