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-9 Tim Waugh <tim@cyberelk.demon.co.uk>
   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  *   DATADIR    data_forward / data_reverse
  25  *   WDATA      write_data
  26  *   RDATA      read_data
  27  *   WCONTROL   write_control
  28  *   RCONTROL   read_control
  29  *   FCONTROL   frob_control
  30  *   RSTATUS    read_status
  31  *   NEGOT      parport_negotiate
  32  *   YIELD      parport_yield_blocking
  33  *   WCTLONIRQ  on interrupt, set control lines
  34  *   CLRIRQ     clear (and return) interrupt count
  35  * read/write   read or write in current IEEE 1284 protocol
  36  * select       wait for interrupt (in readfds)
  37  */
  38
  39 #include <linux/module.h>
  40 #include <linux/sched.h>
  41 #include <linux/ioctl.h>
  42 #include <linux/parport.h>
  43 #include <linux/ctype.h>
  44 #include <linux/poll.h>
  45 #include <asm/uaccess.h>
  46 #include "ppdev.h"
  47
  48 #define PP_VERSION "ppdev: user-space parallel port driver"
  49 #define CHRDEV "ppdev"
  50
  51 #ifndef min
  52 #define min(a,b) ((a) < (b) ? (a) : (b))
  53 #endif
  54
  55 struct pp_struct {
  56         struct pardevice * pdev;
  57         wait_queue_head_t irq_wait;
  58         atomic_t irqc;
  59         int mode;
  60         unsigned int flags;
  61         int irqresponse;
  62         unsigned char irqctl;
  63         struct ieee1284_info state;
  64         struct ieee1284_info saved_state;
  65 };
  66
  67 /* pp_struct.flags bitfields */
  68 #define PP_CLAIMED    (1<<0)
  69 #define PP_EXCL       (1<<1)
  70
  71 /* Other constants */
  72 #define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
  73 #define PP_BUFFER_SIZE 256
  74 #define PARDEVICE_MAX 8
  75
  76 static inline void enable_irq (struct pp_struct *pp)
  77 {
  78         struct parport *port = pp->pdev->port;
  79         port->ops->enable_irq (port);
  80 }
  81
  82 static loff_t pp_lseek (struct file * file, long long offset, int origin)
  83 {
  84         return -ESPIPE;
  85 }
  86
  87 /* This looks a bit like parport_read.  The difference is that we don't
  88  * determine the mode to use from the port data, but rather from the
  89  * mode the driver told us to use. */
  90 static ssize_t do_read (struct pp_struct *pp, void *buf, size_t len)
  91 {
  92         size_t (*fn) (struct parport *, void *, size_t, int);
  93         struct parport *port = pp->pdev->port;
  94         int addr = pp->mode & IEEE1284_ADDR;
  95         int mode = pp->mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
  96
  97         switch (mode) {
  98         case IEEE1284_MODE_COMPAT:
  99                 /* This is a write-only mode. */
 100                 return -EIO;
 101
 102         case IEEE1284_MODE_NIBBLE:
 103                 fn = port->ops->nibble_read_data;
 104                 break;
 105
 106         case IEEE1284_MODE_BYTE:
 107                 fn = port->ops->byte_read_data;
 108                 break;
 109
 110         case IEEE1284_MODE_EPP:
 111                 if (addr)
 112                         fn = port->ops->epp_read_addr;
 113                 else
 114                         fn = port->ops->epp_read_data;
 115                 break;
 116
 117         case IEEE1284_MODE_ECP:
 118         case IEEE1284_MODE_ECPRLE:
 119                 fn = port->ops->ecp_read_data;
 120                 break;
 121
 122         case IEEE1284_MODE_ECPSWE:
 123                 fn = parport_ieee1284_ecp_read_data;
 124                 break;
 125
 126         default:
 127                 printk (KERN_DEBUG "%s: unknown mode 0x%02x\n",
 128                         pp->pdev->name, pp->mode);
 129                 return -EINVAL;
 130         }
 131
 132         return (*fn) (port, buf, len, 0);
 133 }
 134
 135 /* This looks a bit like parport_write.  The difference is that we don't
 136  * determine the mode to use from the port data, but rather from the
 137  * mode the driver told us to use. */
 138 static ssize_t do_write (struct pp_struct *pp, const void *buf, size_t len)
 139 {
 140         size_t (*fn) (struct parport *, const void *, size_t, int);
 141         struct parport *port = pp->pdev->port;
 142         int addr = pp->mode & IEEE1284_ADDR;
 143         int mode = pp->mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
 144
 145         switch (mode) {
 146         case IEEE1284_MODE_NIBBLE:
 147         case IEEE1284_MODE_BYTE:
 148                 /* Read-only modes. */
 149                 return -EIO;
 150
 151         case IEEE1284_MODE_COMPAT:
 152                 fn = port->ops->compat_write_data;
 153                 break;
 154
 155         case IEEE1284_MODE_EPP:
 156                 if (addr)
 157                         fn = port->ops->epp_write_addr;
 158                 else
 159                         fn = port->ops->epp_write_data;
 160                 break;
 161
 162         case IEEE1284_MODE_ECP:
 163         case IEEE1284_MODE_ECPRLE:
 164                 if (addr)
 165                         fn = port->ops->ecp_write_addr;
 166                 else
 167                         fn = port->ops->ecp_write_data;
 168                 break;
 169
 170         case IEEE1284_MODE_ECPSWE:
 171                 if (addr)
 172                         fn = parport_ieee1284_ecp_write_addr;
 173                 else
 174                         fn = parport_ieee1284_ecp_write_data;
 175                 break;
 176
 177         default:
 178                 printk (KERN_DEBUG "%s: unknown mode 0x%02x\n",
 179                         pp->pdev->name, pp->mode);
 180                 return -EINVAL;
 181         }
 182
 183         return (*fn) (port, buf, len, 0);
 184 }
 185
 186 static ssize_t pp_read (struct file * file, char * buf, size_t count,
 187                         loff_t * ppos)
 188 {
 189         unsigned int minor = MINOR (file->f_dentry->d_inode->i_rdev);
 190         struct pp_struct *pp = file->private_data;
 191         char * kbuffer;
 192         ssize_t bytes_read = 0;
 193         ssize_t got = 0;
 194
 195         if (!(pp->flags & PP_CLAIMED)) {
 196                 /* Don't have the port claimed */
 197                 printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
 198                         minor);
 199                 return -EINVAL;
 200         }
 201
 202         kbuffer = kmalloc (min (count, PP_BUFFER_SIZE), GFP_KERNEL);
 203         if (!kbuffer)
 204                 return -ENOMEM;
 205
 206         while (bytes_read < count) {
 207                 ssize_t need = min(count - bytes_read, PP_BUFFER_SIZE);
 208
 209                 got = do_read (pp, kbuffer, need);
 210
 211                 if (got <= 0) {
 212                         if (!bytes_read)
 213                                 bytes_read = got;
 214
 215                         break;
 216                 }
 217
 218                 if (copy_to_user (buf + bytes_read, kbuffer, got)) {
 219                         bytes_read = -EFAULT;
 220                         break;
 221                 }
 222
 223                 bytes_read += got;
 224
 225                 if (signal_pending (current)) {
 226                         if (!bytes_read)
 227                                 bytes_read = -EINTR;
 228                         break;
 229                 }
 230
 231                 if (current->need_resched)
 232                         schedule ();
 233         }
 234
 235         kfree (kbuffer);
 236         enable_irq (pp);
 237         return bytes_read;
 238 }
 239
 240 static ssize_t pp_write (struct file * file, const char * buf, size_t count,
 241                          loff_t * ppos)
 242 {
 243         unsigned int minor = MINOR (file->f_dentry->d_inode->i_rdev);
 244         struct pp_struct *pp = file->private_data;
 245         char * kbuffer;
 246         ssize_t bytes_written = 0;
 247         ssize_t wrote;
 248
 249         if (!(pp->flags & PP_CLAIMED)) {
 250                 /* Don't have the port claimed */
 251                 printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
 252                         minor);
 253                 return -EINVAL;
 254         }
 255
 256         kbuffer = kmalloc (min (count, PP_BUFFER_SIZE), GFP_KERNEL);
 257         if (!kbuffer)
 258                 return -ENOMEM;
 259
 260         while (bytes_written < count) {
 261                 ssize_t n = min(count - bytes_written, PP_BUFFER_SIZE);
 262
 263                 if (copy_from_user (kbuffer, buf + bytes_written, n)) {
 264                         bytes_written = -EFAULT;
 265                         break;
 266                 }
 267
 268                 wrote = do_write (pp, kbuffer, n);
 269
 270                 if (wrote < 0) {
 271                         if (!bytes_written)
 272                                 bytes_written = wrote;
 273                         break;
 274                 }
 275
 276                 bytes_written += wrote;
 277
 278                 if (signal_pending (current)) {
 279                         if (!bytes_written)
 280                                 bytes_written = -EINTR;
 281                         break;
 282                 }
 283
 284                 if (current->need_resched)
 285                         schedule ();
 286         }
 287
 288         kfree (kbuffer);
 289         enable_irq (pp);
 290         return bytes_written;
 291 }
 292
 293 static void pp_irq (int irq, void * private, struct pt_regs * unused)
 294 {
 295         struct pp_struct * pp = (struct pp_struct *) private;
 296
 297         if (pp->irqresponse) {
 298                 parport_write_control (pp->pdev->port, pp->irqctl);
 299                 pp->irqresponse = 0;
 300         }
 301
 302         atomic_inc (&pp->irqc);
 303         wake_up_interruptible (&pp->irq_wait);
 304 }
 305
 306 static int register_device (int minor, struct pp_struct *pp)
 307 {
 308         struct parport * port;
 309         struct pardevice * pdev = NULL;
 310         char *name;
 311         int fl;
 312
 313         name = kmalloc (strlen (CHRDEV) + 3, GFP_KERNEL);
 314         if (name == NULL)
 315                 return -ENOMEM;
 316
 317         sprintf (name, CHRDEV "%x", minor);
 318         port = parport_enumerate (); /* FIXME: use attach/detach */
 319
 320         while (port && port->number != minor)
 321                 port = port->next;
 322
 323         if (!port) {
 324                 printk (KERN_WARNING "%s: no associated port!\n", name);
 325                 kfree (name);
 326                 return -ENXIO;
 327         }
 328
 329         fl = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0;
 330         pdev = parport_register_device (port, name, NULL, NULL, pp_irq, fl,
 331                                         pp);
 332
 333         if (!pdev) {
 334                 printk (KERN_WARNING "%s: failed to register device!\n", name);
 335                 kfree (name);
 336                 return -ENXIO;
 337         }
 338
 339         pp->pdev = pdev;
 340         printk (KERN_DEBUG "%s: registered pardevice\n", name);
 341         return 0;
 342 }
 343
 344 static int pp_ioctl(struct inode *inode, struct file *file,
 345                     unsigned int cmd, unsigned long arg)
 346 {
 347         unsigned int minor = MINOR(inode->i_rdev);
 348         struct pp_struct *pp = file->private_data;
 349         struct parport * port;
 350
 351         /* First handle the cases that don't take arguments. */
 352         if (cmd == PPCLAIM) {
 353                 struct ieee1284_info *info;
 354                 int first_claim = 0;
 355
 356                 if (pp->flags & PP_CLAIMED) {
 357                         printk (KERN_DEBUG CHRDEV
 358                                 "%x: you've already got it!\n", minor);
 359                         return -EINVAL;
 360                 }
 361
 362                 /* Deferred device registration. */
 363                 if (!pp->pdev) {
 364                         int err = register_device (minor, pp);
 365                         if (err)
 366                                 return err;
 367
 368                         first_claim = 1;
 369                 }
 370
 371                 parport_claim_or_block (pp->pdev);
 372                 pp->flags |= PP_CLAIMED;
 373
 374                 /* For interrupt-reporting to work, we need to be
 375                  * informed of each interrupt. */
 376                 enable_irq (pp);
 377
 378                 /* We may need to fix up the state machine. */
 379                 info = &pp->pdev->port->ieee1284;
 380                 pp->saved_state.mode = info->mode;
 381                 pp->saved_state.phase = info->phase;
 382                 if (pp->mode != info->mode) {
 383                         int phase = IEEE1284_PH_FWD_IDLE;
 384
 385                         if (first_claim) {
 386                                 info->mode = pp->mode;
 387                                 switch (pp->mode & ~(IEEE1284_DEVICEID
 388                                                      | IEEE1284_ADDR)) {
 389                                 case IEEE1284_MODE_NIBBLE:
 390                                 case IEEE1284_MODE_BYTE:
 391                                         phase = IEEE1284_PH_REV_IDLE;
 392                                 }
 393                                 info->phase = phase;
 394                         } else {
 395                                 /* Just restore the state. */
 396                                 info->mode = pp->state.mode;
 397                                 info->phase = pp->state.phase;
 398                         }
 399                 }
 400
 401                 return 0;
 402         }
 403
 404         if (cmd == PPEXCL) {
 405                 if (pp->pdev) {
 406                         printk (KERN_DEBUG CHRDEV "%x: too late for PPEXCL; "
 407                                 "already registered\n", minor);
 408                         if (pp->flags & PP_EXCL)
 409                                 /* But it's not really an error. */
 410                                 return 0;
 411                         /* There's no chance of making the driver happy. */
 412                         return -EINVAL;
 413                 }
 414
 415                 /* Just remember to register the device exclusively
 416                  * when we finally do the registration. */
 417                 pp->flags |= PP_EXCL;
 418                 return 0;
 419         }
 420
 421         if (cmd == PPSETMODE) {
 422                 int mode;
 423                 if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
 424                         return -EFAULT;
 425                 /* FIXME: validate mode */
 426                 pp->mode = mode;
 427                 return 0;
 428         }
 429
 430         /* Everything else requires the port to be claimed, so check
 431          * that now. */
 432         if ((pp->flags & PP_CLAIMED) == 0) {
 433                 printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
 434                         minor);
 435                 return -EINVAL;
 436         }
 437
 438         port = pp->pdev->port;
 439         switch (cmd) {
 440                 struct ieee1284_info *info;
 441                 unsigned char reg;
 442                 unsigned char mask;
 443                 int mode;
 444                 int ret;
 445
 446         case PPRSTATUS:
 447                 reg = parport_read_status (port);
 448                 return copy_to_user ((unsigned char *) arg, &reg,
 449                                      sizeof (reg));
 450
 451         case PPRDATA:
 452                 reg = parport_read_data (port);
 453                 return copy_to_user ((unsigned char *) arg, &reg,
 454                                      sizeof (reg));
 455
 456         case PPRCONTROL:
 457                 reg = parport_read_control (port);
 458                 return copy_to_user ((unsigned char *) arg, &reg,
 459                                      sizeof (reg));
 460
 461         case PPYIELD:
 462                 parport_yield_blocking (pp->pdev);
 463                 return 0;
 464
 465         case PPRELEASE:
 466                 /* Save the state machine's state. */
 467                 info = &pp->pdev->port->ieee1284;
 468                 pp->state.mode = info->mode;
 469                 pp->state.phase = info->phase;
 470                 info->mode = pp->saved_state.mode;
 471                 info->phase = pp->saved_state.phase;
 472                 parport_release (pp->pdev);
 473                 pp->flags &= ~PP_CLAIMED;
 474                 return 0;
 475
 476         case PPWCONTROL:
 477                 if (copy_from_user (&reg, (unsigned char *) arg, sizeof (reg)))
 478                         return -EFAULT;
 479                 parport_write_control (port, reg);
 480                 return 0;
 481
 482         case PPWDATA:
 483                 if (copy_from_user (&reg, (unsigned char *) arg, sizeof (reg)))
 484                         return -EFAULT;
 485                 parport_write_data (port, reg);
 486                 return 0;
 487
 488         case PPFCONTROL:
 489                 if (copy_from_user (&mask, (unsigned char *) arg,
 490                                     sizeof (mask)))
 491                         return -EFAULT;
 492                 if (copy_from_user (&reg, 1 + (unsigned char *) arg,
 493                                     sizeof (reg)))
 494                         return -EFAULT;
 495                 parport_frob_control (port, mask, reg);
 496                 return 0;
 497
 498         case PPDATADIR:
 499                 if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
 500                         return -EFAULT;
 501                 if (mode)
 502                         port->ops->data_reverse (port);
 503                 else
 504                         port->ops->data_forward (port);
 505                 return 0;
 506
 507         case PPNEGOT:
 508                 if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
 509                         return -EFAULT;
 510                 switch ((ret = parport_negotiate (port, mode))) {
 511                 case 0: break;
 512                 case -1: /* handshake failed, peripheral not IEEE 1284 */
 513                         ret = -EIO;
 514                         break;
 515                 case 1:  /* handshake succeeded, peripheral rejected mode */
 516                         ret = -ENXIO;
 517                         break;
 518                 }
 519                 enable_irq (pp);
 520                 return ret;
 521
 522         case PPWCTLONIRQ:
 523                 if (copy_from_user (&reg, (unsigned char *) arg,
 524                                     sizeof (reg)))
 525                         return -EFAULT;
 526
 527                 /* Remember what to set the control lines to, for next
 528                  * time we get an interrupt. */
 529                 pp->irqctl = reg;
 530                 pp->irqresponse = 1;
 531                 return 0;
 532
 533         case PPCLRIRQ:
 534                 ret = atomic_read (&pp->irqc);
 535                 if (copy_to_user ((int *) arg, &ret, sizeof (ret)))
 536                         return -EFAULT;
 537                 atomic_sub (ret, &pp->irqc);
 538                 return 0;
 539
 540         default:
 541                 printk (KERN_DEBUG CHRDEV "%x: What? (cmd=0x%x)\n", minor,
 542                         cmd);
 543                 return -EINVAL;
 544         }
 545
 546         /* Keep the compiler happy */
 547         return 0;
 548 }
 549
 550 static int pp_open (struct inode * inode, struct file * file)
 551 {
 552         unsigned int minor = MINOR (inode->i_rdev);
 553         struct pp_struct *pp;
 554
 555         if (minor >= PARPORT_MAX)
 556                 return -ENXIO;
 557
 558         pp = kmalloc (GFP_KERNEL, sizeof (struct pp_struct));
 559         if (!pp)
 560                 return -ENOMEM;
 561
 562         pp->mode = IEEE1284_MODE_COMPAT;
 563         pp->flags = 0;
 564         atomic_set (&pp->irqc, 0);
 565         init_waitqueue_head (&pp->irq_wait);
 566
 567         /* Defer the actual device registration until the first claim.
 568          * That way, we know whether or not the driver wants to have
 569          * exclusive access to the port (PPEXCL).
 570          */
 571         pp->pdev = NULL;
 572         file->private_data = pp;
 573
 574         MOD_INC_USE_COUNT;
 575         return 0;
 576 }
 577
 578 static int pp_release (struct inode * inode, struct file * file)
 579 {
 580         unsigned int minor = MINOR (inode->i_rdev);
 581         struct pp_struct *pp = file->private_data;
 582
 583         if (pp->flags & PP_CLAIMED) {
 584                 parport_release (pp->pdev);
 585                 printk (KERN_DEBUG CHRDEV "%x: released pardevice because "
 586                         "user-space forgot\n", minor);
 587         }
 588
 589         if (pp->pdev) {
 590                 kfree (pp->pdev->name);
 591                 parport_unregister_device (pp->pdev);
 592                 pp->pdev = NULL;
 593                 printk (KERN_DEBUG CHRDEV "%x: unregistered pardevice\n",
 594                         minor);
 595         }
 596
 597         kfree (pp);
 598
 599         MOD_DEC_USE_COUNT;
 600         return 0;
 601 }
 602
 603 static unsigned int pp_poll (struct file * file, poll_table * wait)
 604 {
 605         struct pp_struct *pp = file->private_data;
 606         unsigned int mask = 0;
 607
 608         if (atomic_read (&pp->irqc))
 609                 mask |= POLLIN | POLLRDNORM;
 610
 611         poll_wait (file, &pp->irq_wait, wait);
 612         return mask;
 613 }
 614
 615 static struct file_operations pp_fops = {
 616         pp_lseek,
 617         pp_read,
 618         pp_write,
 619         NULL,   /* pp_readdir */
 620         pp_poll,
 621         pp_ioctl,
 622         NULL,   /* pp_mmap */
 623         pp_open,
 624         NULL,   /* pp_flush */
 625         pp_release
 626 };
 627
 628 #ifdef MODULE
 629 #define pp_init init_module
 630 #endif
 631
 632 int pp_init (void)
 633 {
 634         if (register_chrdev (PP_MAJOR, CHRDEV, &pp_fops)) {
 635                 printk (KERN_WARNING CHRDEV ": unable to get major %d\n",
 636                         PP_MAJOR);
 637                 return -EIO;
 638         }
 639
 640         printk (KERN_INFO PP_VERSION "\n");
 641         return 0;
 642 }
 643
 644 #ifdef MODULE
 645 void cleanup_module (void)
 646 {
 647         /* Clean up all parport stuff */
 648         unregister_chrdev (PP_MAJOR, CHRDEV);
 649 }
 650 #endif /* MODULE */