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