drivers/staging/media/lirc/lirc_parallel.c

   1 /*
   2  * lirc_parallel.c
   3  *
   4  * lirc_parallel - device driver for infra-red signal receiving and
   5  *                 transmitting unit built by the author
   6  *
   7  * Copyright (C) 1998 Christoph Bartelmus <lirc@bartelmus.de>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24
  25 /*** Includes ***/
  26
  27 #include <linux/module.h>
  28 #include <linux/sched.h>
  29 #include <linux/errno.h>
  30 #include <linux/signal.h>
  31 #include <linux/fs.h>
  32 #include <linux/kernel.h>
  33 #include <linux/ioport.h>
  34 #include <linux/time.h>
  35 #include <linux/mm.h>
  36 #include <linux/delay.h>
  37
  38 #include <linux/io.h>
  39 #include <linux/irq.h>
  40 #include <linux/uaccess.h>
  41 #include <asm/div64.h>
  42
  43 #include <linux/poll.h>
  44 #include <linux/parport.h>
  45 #include <linux/platform_device.h>
  46
  47 #include <media/lirc.h>
  48 #include <media/lirc_dev.h>
  49
  50 #include "lirc_parallel.h"
  51
  52 #define LIRC_DRIVER_NAME "lirc_parallel"
  53
  54 #ifndef LIRC_IRQ
  55 #define LIRC_IRQ 7
  56 #endif
  57 #ifndef LIRC_PORT
  58 #define LIRC_PORT 0x378
  59 #endif
  60 #ifndef LIRC_TIMER
  61 #define LIRC_TIMER 65536
  62 #endif
  63
  64 /*** Global Variables ***/
  65
  66 static bool debug;
  67 static bool check_pselecd;
  68
  69 unsigned int irq = LIRC_IRQ;
  70 unsigned int io = LIRC_PORT;
  71 #ifdef LIRC_TIMER
  72 unsigned int timer;
  73 unsigned int default_timer = LIRC_TIMER;
  74 #endif
  75
  76 #define RBUF_SIZE (256) /* this must be a power of 2 larger than 1 */
  77
  78 static int rbuf[RBUF_SIZE];
  79
  80 DECLARE_WAIT_QUEUE_HEAD(lirc_wait);
  81
  82 unsigned int rptr;
  83 unsigned int wptr;
  84 unsigned int lost_irqs;
  85 int is_open;
  86
  87 struct parport *pport;
  88 struct pardevice *ppdevice;
  89 int is_claimed;
  90
  91 unsigned int tx_mask = 1;
  92
  93 /*** Internal Functions ***/
  94
  95 static unsigned int in(int offset)
  96 {
  97         switch (offset) {
  98         case LIRC_LP_BASE:
  99                 return parport_read_data(pport);
 100         case LIRC_LP_STATUS:
 101                 return parport_read_status(pport);
 102         case LIRC_LP_CONTROL:
 103                 return parport_read_control(pport);
 104         }
 105         return 0; /* make compiler happy */
 106 }
 107
 108 static void out(int offset, int value)
 109 {
 110         switch (offset) {
 111         case LIRC_LP_BASE:
 112                 parport_write_data(pport, value);
 113                 break;
 114         case LIRC_LP_CONTROL:
 115                 parport_write_control(pport, value);
 116                 break;
 117         case LIRC_LP_STATUS:
 118                 printk(KERN_INFO "%s: attempt to write to status register\n",
 119                        LIRC_DRIVER_NAME);
 120                 break;
 121         }
 122 }
 123
 124 static unsigned int lirc_get_timer(void)
 125 {
 126         return in(LIRC_PORT_TIMER) & LIRC_PORT_TIMER_BIT;
 127 }
 128
 129 static unsigned int lirc_get_signal(void)
 130 {
 131         return in(LIRC_PORT_SIGNAL) & LIRC_PORT_SIGNAL_BIT;
 132 }
 133
 134 static void lirc_on(void)
 135 {
 136         out(LIRC_PORT_DATA, tx_mask);
 137 }
 138
 139 static void lirc_off(void)
 140 {
 141         out(LIRC_PORT_DATA, 0);
 142 }
 143
 144 static unsigned int init_lirc_timer(void)
 145 {
 146         struct timeval tv, now;
 147         unsigned int level, newlevel, timeelapsed, newtimer;
 148         int count = 0;
 149
 150         do_gettimeofday(&tv);
 151         tv.tv_sec++;                     /* wait max. 1 sec. */
 152         level = lirc_get_timer();
 153         do {
 154                 newlevel = lirc_get_timer();
 155                 if (level == 0 && newlevel != 0)
 156                         count++;
 157                 level = newlevel;
 158                 do_gettimeofday(&now);
 159         } while (count < 1000 && (now.tv_sec < tv.tv_sec
 160                              || (now.tv_sec == tv.tv_sec
 161                                  && now.tv_usec < tv.tv_usec)));
 162
 163         timeelapsed = ((now.tv_sec + 1 - tv.tv_sec)*1000000
 164                      + (now.tv_usec - tv.tv_usec));
 165         if (count >= 1000 && timeelapsed > 0) {
 166                 if (default_timer == 0) {
 167                         /* autodetect timer */
 168                         newtimer = (1000000*count)/timeelapsed;
 169                         printk(KERN_INFO "%s: %u Hz timer detected\n",
 170                                LIRC_DRIVER_NAME, newtimer);
 171                         return newtimer;
 172                 }  else {
 173                         newtimer = (1000000*count)/timeelapsed;
 174                         if (abs(newtimer - default_timer) > default_timer/10) {
 175                                 /* bad timer */
 176                                 printk(KERN_NOTICE "%s: bad timer: %u Hz\n",
 177                                        LIRC_DRIVER_NAME, newtimer);
 178                                 printk(KERN_NOTICE "%s: using default timer: "
 179                                        "%u Hz\n",
 180                                        LIRC_DRIVER_NAME, default_timer);
 181                                 return default_timer;
 182                         } else {
 183                                 printk(KERN_INFO "%s: %u Hz timer detected\n",
 184                                        LIRC_DRIVER_NAME, newtimer);
 185                                 return newtimer; /* use detected value */
 186                         }
 187                 }
 188         } else {
 189                 printk(KERN_NOTICE "%s: no timer detected\n", LIRC_DRIVER_NAME);
 190                 return 0;
 191         }
 192 }
 193
 194 static int lirc_claim(void)
 195 {
 196         if (parport_claim(ppdevice) != 0) {
 197                 printk(KERN_WARNING "%s: could not claim port\n",
 198                        LIRC_DRIVER_NAME);
 199                 printk(KERN_WARNING "%s: waiting for port becoming available"
 200                        "\n", LIRC_DRIVER_NAME);
 201                 if (parport_claim_or_block(ppdevice) < 0) {
 202                         printk(KERN_NOTICE "%s: could not claim port, giving"
 203                                " up\n", LIRC_DRIVER_NAME);
 204                         return 0;
 205                 }
 206         }
 207         out(LIRC_LP_CONTROL, LP_PSELECP|LP_PINITP);
 208         is_claimed = 1;
 209         return 1;
 210 }
 211
 212 /*** interrupt handler ***/
 213
 214 static void rbuf_write(int signal)
 215 {
 216         unsigned int nwptr;
 217
 218         nwptr = (wptr + 1) & (RBUF_SIZE - 1);
 219         if (nwptr == rptr) {
 220                 /* no new signals will be accepted */
 221                 lost_irqs++;
 222                 printk(KERN_NOTICE "%s: buffer overrun\n", LIRC_DRIVER_NAME);
 223                 return;
 224         }
 225         rbuf[wptr] = signal;
 226         wptr = nwptr;
 227 }
 228
 229 static void irq_handler(void *blah)
 230 {
 231         struct timeval tv;
 232         static struct timeval lasttv;
 233         static int init;
 234         long signal;
 235         int data;
 236         unsigned int level, newlevel;
 237         unsigned int timeout;
 238
 239         if (!is_open)
 240                 return;
 241
 242         if (!is_claimed)
 243                 return;
 244
 245 #if 0
 246         /* disable interrupt */
 247           disable_irq(irq);
 248           out(LIRC_PORT_IRQ, in(LIRC_PORT_IRQ) & (~LP_PINTEN));
 249 #endif
 250         if (check_pselecd && (in(1) & LP_PSELECD))
 251                 return;
 252
 253 #ifdef LIRC_TIMER
 254         if (init) {
 255                 do_gettimeofday(&tv);
 256
 257                 signal = tv.tv_sec - lasttv.tv_sec;
 258                 if (signal > 15)
 259                         /* really long time */
 260                         data = PULSE_MASK;
 261                 else
 262                         data = (int) (signal*1000000 +
 263                                          tv.tv_usec - lasttv.tv_usec +
 264                                          LIRC_SFH506_DELAY);
 265
 266                 rbuf_write(data); /* space */
 267         } else {
 268                 if (timer == 0) {
 269                         /*
 270                          * wake up; we'll lose this signal, but it will be
 271                          * garbage if the device is turned on anyway
 272                          */
 273                         timer = init_lirc_timer();
 274                         /* enable_irq(irq); */
 275                         return;
 276                 }
 277                 init = 1;
 278         }
 279
 280         timeout = timer/10;     /* timeout after 1/10 sec. */
 281         signal = 1;
 282         level = lirc_get_timer();
 283         do {
 284                 newlevel = lirc_get_timer();
 285                 if (level == 0 && newlevel != 0)
 286                         signal++;
 287                 level = newlevel;
 288
 289                 /* giving up */
 290                 if (signal > timeout
 291                     || (check_pselecd && (in(1) & LP_PSELECD))) {
 292                         signal = 0;
 293                         printk(KERN_NOTICE "%s: timeout\n", LIRC_DRIVER_NAME);
 294                         break;
 295                 }
 296         } while (lirc_get_signal());
 297
 298         if (signal != 0) {
 299                 /* adjust value to usecs */
 300                 __u64 helper;
 301
 302                 helper = ((__u64) signal)*1000000;
 303                 do_div(helper, timer);
 304                 signal = (long) helper;
 305
 306                 if (signal > LIRC_SFH506_DELAY)
 307                         data = signal - LIRC_SFH506_DELAY;
 308                 else
 309                         data = 1;
 310                 rbuf_write(PULSE_BIT|data); /* pulse */
 311         }
 312         do_gettimeofday(&lasttv);
 313 #else
 314         /* add your code here */
 315 #endif
 316
 317         wake_up_interruptible(&lirc_wait);
 318
 319         /* enable interrupt */
 320         /*
 321           enable_irq(irq);
 322           out(LIRC_PORT_IRQ, in(LIRC_PORT_IRQ)|LP_PINTEN);
 323         */
 324 }
 325
 326 /*** file operations ***/
 327
 328 static loff_t lirc_lseek(struct file *filep, loff_t offset, int orig)
 329 {
 330         return -ESPIPE;
 331 }
 332
 333 static ssize_t lirc_read(struct file *filep, char *buf, size_t n, loff_t *ppos)
 334 {
 335         int result = 0;
 336         int count = 0;
 337         DECLARE_WAITQUEUE(wait, current);
 338
 339         if (n % sizeof(int))
 340                 return -EINVAL;
 341
 342         add_wait_queue(&lirc_wait, &wait);
 343         set_current_state(TASK_INTERRUPTIBLE);
 344         while (count < n) {
 345                 if (rptr != wptr) {
 346                         if (copy_to_user(buf+count, (char *) &rbuf[rptr],
 347                                          sizeof(int))) {
 348                                 result = -EFAULT;
 349                                 break;
 350                         }
 351                         rptr = (rptr + 1) & (RBUF_SIZE - 1);
 352                         count += sizeof(int);
 353                 } else {
 354                         if (filep->f_flags & O_NONBLOCK) {
 355                                 result = -EAGAIN;
 356                                 break;
 357                         }
 358                         if (signal_pending(current)) {
 359                                 result = -ERESTARTSYS;
 360                                 break;
 361                         }
 362                         schedule();
 363                         set_current_state(TASK_INTERRUPTIBLE);
 364                 }
 365         }
 366         remove_wait_queue(&lirc_wait, &wait);
 367         set_current_state(TASK_RUNNING);
 368         return count ? count : result;
 369 }
 370
 371 static ssize_t lirc_write(struct file *filep, const char *buf, size_t n,
 372                           loff_t *ppos)
 373 {
 374         int count;
 375         unsigned int i;
 376         unsigned int level, newlevel;
 377         unsigned long flags;
 378         int counttimer;
 379         int *wbuf;
 380         ssize_t ret;
 381
 382         if (!is_claimed)
 383                 return -EBUSY;
 384
 385         count = n / sizeof(int);
 386
 387         if (n % sizeof(int) || count % 2 == 0)
 388                 return -EINVAL;
 389
 390         wbuf = memdup_user(buf, n);
 391         if (IS_ERR(wbuf))
 392                 return PTR_ERR(wbuf);
 393
 394 #ifdef LIRC_TIMER
 395         if (timer == 0) {
 396                 /* try again if device is ready */
 397                 timer = init_lirc_timer();
 398                 if (timer == 0) {
 399                         ret = -EIO;
 400                         goto out;
 401                 }
 402         }
 403
 404         /* adjust values from usecs */
 405         for (i = 0; i < count; i++) {
 406                 __u64 helper;
 407
 408                 helper = ((__u64) wbuf[i])*timer;
 409                 do_div(helper, 1000000);
 410                 wbuf[i] = (int) helper;
 411         }
 412
 413         local_irq_save(flags);
 414         i = 0;
 415         while (i < count) {
 416                 level = lirc_get_timer();
 417                 counttimer = 0;
 418                 lirc_on();
 419                 do {
 420                         newlevel = lirc_get_timer();
 421                         if (level == 0 && newlevel != 0)
 422                                 counttimer++;
 423                         level = newlevel;
 424                         if (check_pselecd && (in(1) & LP_PSELECD)) {
 425                                 lirc_off();
 426                                 local_irq_restore(flags);
 427                                 ret = -EIO;
 428                                 goto out;
 429                         }
 430                 } while (counttimer < wbuf[i]);
 431                 i++;
 432
 433                 lirc_off();
 434                 if (i == count)
 435                         break;
 436                 counttimer = 0;
 437                 do {
 438                         newlevel = lirc_get_timer();
 439                         if (level == 0 && newlevel != 0)
 440                                 counttimer++;
 441                         level = newlevel;
 442                         if (check_pselecd && (in(1) & LP_PSELECD)) {
 443                                 local_irq_restore(flags);
 444                                 ret = -EIO;
 445                                 goto out;
 446                         }
 447                 } while (counttimer < wbuf[i]);
 448                 i++;
 449         }
 450         local_irq_restore(flags);
 451 #else
 452         /* place code that handles write without external timer here */
 453 #endif
 454         ret = n;
 455 out:
 456         kfree(wbuf);
 457
 458         return ret;
 459 }
 460
 461 static unsigned int lirc_poll(struct file *file, poll_table *wait)
 462 {
 463         poll_wait(file, &lirc_wait, wait);
 464         if (rptr != wptr)
 465                 return POLLIN | POLLRDNORM;
 466         return 0;
 467 }
 468
 469 static long lirc_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
 470 {
 471         int result;
 472         __u32 features = LIRC_CAN_SET_TRANSMITTER_MASK |
 473                          LIRC_CAN_SEND_PULSE | LIRC_CAN_REC_MODE2;
 474         __u32 mode;
 475         __u32 value;
 476
 477         switch (cmd) {
 478         case LIRC_GET_FEATURES:
 479                 result = put_user(features, (__u32 *) arg);
 480                 if (result)
 481                         return result;
 482                 break;
 483         case LIRC_GET_SEND_MODE:
 484                 result = put_user(LIRC_MODE_PULSE, (__u32 *) arg);
 485                 if (result)
 486                         return result;
 487                 break;
 488         case LIRC_GET_REC_MODE:
 489                 result = put_user(LIRC_MODE_MODE2, (__u32 *) arg);
 490                 if (result)
 491                         return result;
 492                 break;
 493         case LIRC_SET_SEND_MODE:
 494                 result = get_user(mode, (__u32 *) arg);
 495                 if (result)
 496                         return result;
 497                 if (mode != LIRC_MODE_PULSE)
 498                         return -EINVAL;
 499                 break;
 500         case LIRC_SET_REC_MODE:
 501                 result = get_user(mode, (__u32 *) arg);
 502                 if (result)
 503                         return result;
 504                 if (mode != LIRC_MODE_MODE2)
 505                         return -ENOSYS;
 506                 break;
 507         case LIRC_SET_TRANSMITTER_MASK:
 508                 result = get_user(value, (__u32 *) arg);
 509                 if (result)
 510                         return result;
 511                 if ((value & LIRC_PARALLEL_TRANSMITTER_MASK) != value)
 512                         return LIRC_PARALLEL_MAX_TRANSMITTERS;
 513                 tx_mask = value;
 514                 break;
 515         default:
 516                 return -ENOIOCTLCMD;
 517         }
 518         return 0;
 519 }
 520
 521 static int lirc_open(struct inode *node, struct file *filep)
 522 {
 523         if (is_open || !lirc_claim())
 524                 return -EBUSY;
 525
 526         parport_enable_irq(pport);
 527
 528         /* init read ptr */
 529         rptr = 0;
 530         wptr = 0;
 531         lost_irqs = 0;
 532
 533         is_open = 1;
 534         return 0;
 535 }
 536
 537 static int lirc_close(struct inode *node, struct file *filep)
 538 {
 539         if (is_claimed) {
 540                 is_claimed = 0;
 541                 parport_release(ppdevice);
 542         }
 543         is_open = 0;
 544         return 0;
 545 }
 546
 547 static const struct file_operations lirc_fops = {
 548         .owner          = THIS_MODULE,
 549         .llseek         = lirc_lseek,
 550         .read           = lirc_read,
 551         .write          = lirc_write,
 552         .poll           = lirc_poll,
 553         .unlocked_ioctl = lirc_ioctl,
 554 #ifdef CONFIG_COMPAT
 555         .compat_ioctl   = lirc_ioctl,
 556 #endif
 557         .open           = lirc_open,
 558         .release        = lirc_close
 559 };
 560
 561 static int set_use_inc(void *data)
 562 {
 563         return 0;
 564 }
 565
 566 static void set_use_dec(void *data)
 567 {
 568 }
 569
 570 static struct lirc_driver driver = {
 571         .name           = LIRC_DRIVER_NAME,
 572         .minor          = -1,
 573         .code_length    = 1,
 574         .sample_rate    = 0,
 575         .data           = NULL,
 576         .add_to_buf     = NULL,
 577         .set_use_inc    = set_use_inc,
 578         .set_use_dec    = set_use_dec,
 579         .fops           = &lirc_fops,
 580         .dev            = NULL,
 581         .owner          = THIS_MODULE,
 582 };
 583
 584 static struct platform_device *lirc_parallel_dev;
 585
 586 static int lirc_parallel_probe(struct platform_device *dev)
 587 {
 588         return 0;
 589 }
 590
 591 static int lirc_parallel_remove(struct platform_device *dev)
 592 {
 593         return 0;
 594 }
 595
 596 static int lirc_parallel_suspend(struct platform_device *dev,
 597                                         pm_message_t state)
 598 {
 599         return 0;
 600 }
 601
 602 static int lirc_parallel_resume(struct platform_device *dev)
 603 {
 604         return 0;
 605 }
 606
 607 static struct platform_driver lirc_parallel_driver = {
 608         .probe  = lirc_parallel_probe,
 609         .remove = lirc_parallel_remove,
 610         .suspend        = lirc_parallel_suspend,
 611         .resume = lirc_parallel_resume,
 612         .driver = {
 613                 .name   = LIRC_DRIVER_NAME,
 614                 .owner  = THIS_MODULE,
 615         },
 616 };
 617
 618 static int pf(void *handle)
 619 {
 620         parport_disable_irq(pport);
 621         is_claimed = 0;
 622         return 0;
 623 }
 624
 625 static void kf(void *handle)
 626 {
 627         if (!is_open)
 628                 return;
 629         if (!lirc_claim())
 630                 return;
 631         parport_enable_irq(pport);
 632         lirc_off();
 633         /* this is a bit annoying when you actually print...*/
 634         /*
 635         printk(KERN_INFO "%s: reclaimed port\n", LIRC_DRIVER_NAME);
 636         */
 637 }
 638
 639 /*** module initialization and cleanup ***/
 640
 641 static int __init lirc_parallel_init(void)
 642 {
 643         int result;
 644
 645         result = platform_driver_register(&lirc_parallel_driver);
 646         if (result) {
 647                 printk(KERN_NOTICE "platform_driver_register"
 648                                         " returned %d\n", result);
 649                 return result;
 650         }
 651
 652         lirc_parallel_dev = platform_device_alloc(LIRC_DRIVER_NAME, 0);
 653         if (!lirc_parallel_dev) {
 654                 result = -ENOMEM;
 655                 goto exit_driver_unregister;
 656         }
 657
 658         result = platform_device_add(lirc_parallel_dev);
 659         if (result)
 660                 goto exit_device_put;
 661
 662         pport = parport_find_base(io);
 663         if (pport == NULL) {
 664                 printk(KERN_NOTICE "%s: no port at %x found\n",
 665                        LIRC_DRIVER_NAME, io);
 666                 result = -ENXIO;
 667                 goto exit_device_put;
 668         }
 669         ppdevice = parport_register_device(pport, LIRC_DRIVER_NAME,
 670                                            pf, kf, irq_handler, 0, NULL);
 671         parport_put_port(pport);
 672         if (ppdevice == NULL) {
 673                 printk(KERN_NOTICE "%s: parport_register_device() failed\n",
 674                        LIRC_DRIVER_NAME);
 675                 result = -ENXIO;
 676                 goto exit_device_put;
 677         }
 678         if (parport_claim(ppdevice) != 0)
 679                 goto skip_init;
 680         is_claimed = 1;
 681         out(LIRC_LP_CONTROL, LP_PSELECP|LP_PINITP);
 682
 683 #ifdef LIRC_TIMER
 684         if (debug)
 685                 out(LIRC_PORT_DATA, tx_mask);
 686
 687         timer = init_lirc_timer();
 688
 689 #if 0   /* continue even if device is offline */
 690         if (timer == 0) {
 691                 is_claimed = 0;
 692                 parport_release(pport);
 693                 parport_unregister_device(ppdevice);
 694                 result = -EIO;
 695                 goto exit_device_put;
 696         }
 697
 698 #endif
 699         if (debug)
 700                 out(LIRC_PORT_DATA, 0);
 701 #endif
 702
 703         is_claimed = 0;
 704         parport_release(ppdevice);
 705  skip_init:
 706         driver.dev = &lirc_parallel_dev->dev;
 707         driver.minor = lirc_register_driver(&driver);
 708         if (driver.minor < 0) {
 709                 printk(KERN_NOTICE "%s: register_chrdev() failed\n",
 710                        LIRC_DRIVER_NAME);
 711                 parport_unregister_device(ppdevice);
 712                 result = -EIO;
 713                 goto exit_device_put;
 714         }
 715         printk(KERN_INFO "%s: installed using port 0x%04x irq %d\n",
 716                LIRC_DRIVER_NAME, io, irq);
 717         return 0;
 718
 719 exit_device_put:
 720         platform_device_put(lirc_parallel_dev);
 721 exit_driver_unregister:
 722         platform_driver_unregister(&lirc_parallel_driver);
 723         return result;
 724 }
 725
 726 static void __exit lirc_parallel_exit(void)
 727 {
 728         parport_unregister_device(ppdevice);
 729         lirc_unregister_driver(driver.minor);
 730
 731         platform_device_unregister(lirc_parallel_dev);
 732         platform_driver_unregister(&lirc_parallel_driver);
 733 }
 734
 735 module_init(lirc_parallel_init);
 736 module_exit(lirc_parallel_exit);
 737
 738 MODULE_DESCRIPTION("Infrared receiver driver for parallel ports.");
 739 MODULE_AUTHOR("Christoph Bartelmus");
 740 MODULE_LICENSE("GPL");
 741
 742 module_param(io, int, S_IRUGO);
 743 MODULE_PARM_DESC(io, "I/O address base (0x3bc, 0x378 or 0x278)");
 744
 745 module_param(irq, int, S_IRUGO);
 746 MODULE_PARM_DESC(irq, "Interrupt (7 or 5)");
 747
 748 module_param(tx_mask, int, S_IRUGO);
 749 MODULE_PARM_DESC(tx_maxk, "Transmitter mask (default: 0x01)");
 750
 751 module_param(debug, bool, S_IRUGO | S_IWUSR);
 752 MODULE_PARM_DESC(debug, "Enable debugging messages");
 753
 754 module_param(check_pselecd, bool, S_IRUGO | S_IWUSR);
 755 MODULE_PARM_DESC(check_pselecd, "Check for printer (default: 0)");