linux/drivers/char/ppdev.c
<<
>>
Prefs
   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
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.