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