SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/char/dtlk.c

   1 /*                                              -*- linux-c -*-
   2  * dtlk.c - DoubleTalk PC driver for Linux
   3  *
   4  * Original author: Chris Pallotta <chris@allmedia.com>
   5  * Current maintainer: Jim Van Zandt <jrv@vanzandt.mv.com>
   6  *
   7  * 2000-03-18 Jim Van Zandt: Fix polling.
   8  *  Eliminate dtlk_timer_active flag and separate dtlk_stop_timer
   9  *  function.  Don't restart timer in dtlk_timer_tick.  Restart timer
  10  *  in dtlk_poll after every poll.  dtlk_poll returns mask (duh).
  11  *  Eliminate unused function dtlk_write_byte.  Misc. code cleanups.
  12  */
  13
  14 /* This driver is for the DoubleTalk PC, a speech synthesizer
  15    manufactured by RC Systems (http://www.rcsys.com/).  It was written
  16    based on documentation in their User's Manual file and Developer's
  17    Tools disk.
  18
  19    The DoubleTalk PC contains four voice synthesizers: text-to-speech
  20    (TTS), linear predictive coding (LPC), PCM/ADPCM, and CVSD.  It
  21    also has a tone generator.  Output data for LPC are written to the
  22    LPC port, and output data for the other modes are written to the
  23    TTS port.
  24
  25    Two kinds of data can be read from the DoubleTalk: status
  26    information (in response to the "\001?" interrogation command) is
  27    read from the TTS port, and index markers (which mark the progress
  28    of the speech) are read from the LPC port.  Not all models of the
  29    DoubleTalk PC implement index markers.  Both the TTS and LPC ports
  30    can also display status flags.
  31
  32    The DoubleTalk PC generates no interrupts.
  33
  34    These characteristics are mapped into the Unix stream I/O model as
  35    follows:
  36
  37    "write" sends bytes to the TTS port.  It is the responsibility of
  38    the user program to switch modes among TTS, PCM/ADPCM, and CVSD.
  39    This driver was written for use with the text-to-speech
  40    synthesizer.  If LPC output is needed some day, other minor device
  41    numbers can be used to select among output modes.
  42
  43    "read" gets index markers from the LPC port.  If the device does
  44    not implement index markers, the read will fail with error EINVAL.
  45
  46    Status information is available using the DTLK_INTERROGATE ioctl.
  47
  48  */
  49
  50 #include <linux/module.h>
  51
  52 #define KERNEL
  53 #include <linux/types.h>
  54 #include <linux/fs.h>
  55 #include <linux/mm.h>
  56 #include <linux/errno.h>        /* for -EBUSY */
  57 #include <linux/ioport.h>       /* for request_region */
  58 #include <linux/delay.h>        /* for loops_per_jiffy */
  59 #include <asm/io.h>             /* for inb_p, outb_p, inb, outb, etc. */
  60 #include <asm/uaccess.h>        /* for get_user, etc. */
  61 #include <linux/wait.h>         /* for wait_queue */
  62 #include <linux/init.h>         /* for __init, module_{init,exit} */
  63 #include <linux/poll.h>         /* for POLLIN, etc. */
  64 #include <linux/dtlk.h>         /* local header file for DoubleTalk values */
  65
  66 #ifdef TRACING
  67 #define TRACE_TEXT(str) printk(str);
  68 #define TRACE_RET printk(")")
  69 #else                           /* !TRACING */
  70 #define TRACE_TEXT(str) ((void) 0)
  71 #define TRACE_RET ((void) 0)
  72 #endif                          /* TRACING */
  73
  74 static void dtlk_timer_tick(unsigned long data);
  75
  76 static int dtlk_major;
  77 static int dtlk_port_lpc;
  78 static int dtlk_port_tts;
  79 static int dtlk_busy;
  80 static int dtlk_has_indexing;
  81 static unsigned int dtlk_portlist[] =
  82 {0x25e, 0x29e, 0x2de, 0x31e, 0x35e, 0x39e, 0};
  83 static wait_queue_head_t dtlk_process_list;
  84 static DEFINE_TIMER(dtlk_timer, dtlk_timer_tick, 0, 0);
  85
  86 /* prototypes for file_operations struct */
  87 static ssize_t dtlk_read(struct file *, char __user *,
  88                          size_t nbytes, loff_t * ppos);
  89 static ssize_t dtlk_write(struct file *, const char __user *,
  90                           size_t nbytes, loff_t * ppos);
  91 static unsigned int dtlk_poll(struct file *, poll_table *);
  92 static int dtlk_open(struct inode *, struct file *);
  93 static int dtlk_release(struct inode *, struct file *);
  94 static int dtlk_ioctl(struct inode *inode, struct file *file,
  95                       unsigned int cmd, unsigned long arg);
  96
  97 static const struct file_operations dtlk_fops =
  98 {
  99         .owner          = THIS_MODULE,
 100         .read           = dtlk_read,
 101         .write          = dtlk_write,
 102         .poll           = dtlk_poll,
 103         .ioctl          = dtlk_ioctl,
 104         .open           = dtlk_open,
 105         .release        = dtlk_release,
 106 };
 107
 108 /* local prototypes */
 109 static int dtlk_dev_probe(void);
 110 static struct dtlk_settings *dtlk_interrogate(void);
 111 static int dtlk_readable(void);
 112 static char dtlk_read_lpc(void);
 113 static char dtlk_read_tts(void);
 114 static int dtlk_writeable(void);
 115 static char dtlk_write_bytes(const char *buf, int n);
 116 static char dtlk_write_tts(char);
 117 /*
 118    static void dtlk_handle_error(char, char, unsigned int);
 119  */
 120
 121 static ssize_t dtlk_read(struct file *file, char __user *buf,
 122                          size_t count, loff_t * ppos)
 123 {
 124         unsigned int minor = iminor(file->f_path.dentry->d_inode);
 125         char ch;
 126         int i = 0, retries;
 127
 128         TRACE_TEXT("(dtlk_read");
 129         /*  printk("DoubleTalk PC - dtlk_read()\n"); */
 130
 131         if (minor != DTLK_MINOR || !dtlk_has_indexing)
 132                 return -EINVAL;
 133
 134         for (retries = 0; retries < loops_per_jiffy; retries++) {
 135                 while (i < count && dtlk_readable()) {
 136                         ch = dtlk_read_lpc();
 137                         /*        printk("dtlk_read() reads 0x%02x\n", ch); */
 138                         if (put_user(ch, buf++))
 139                                 return -EFAULT;
 140                         i++;
 141                 }
 142                 if (i)
 143                         return i;
 144                 if (file->f_flags & O_NONBLOCK)
 145                         break;
 146                 msleep_interruptible(100);
 147         }
 148         if (retries == loops_per_jiffy)
 149                 printk(KERN_ERR "dtlk_read times out\n");
 150         TRACE_RET;
 151         return -EAGAIN;
 152 }
 153
 154 static ssize_t dtlk_write(struct file *file, const char __user *buf,
 155                           size_t count, loff_t * ppos)
 156 {
 157         int i = 0, retries = 0, ch;
 158
 159         TRACE_TEXT("(dtlk_write");
 160 #ifdef TRACING
 161         printk(" \"");
 162         {
 163                 int i, ch;
 164                 for (i = 0; i < count; i++) {
 165                         if (get_user(ch, buf + i))
 166                                 return -EFAULT;
 167                         if (' ' <= ch && ch <= '~')
 168                                 printk("%c", ch);
 169                         else
 170                                 printk("\\%03o", ch);
 171                 }
 172                 printk("\"");
 173         }
 174 #endif
 175
 176         if (iminor(file->f_path.dentry->d_inode) != DTLK_MINOR)
 177                 return -EINVAL;
 178
 179         while (1) {
 180                 while (i < count && !get_user(ch, buf) &&
 181                        (ch == DTLK_CLEAR || dtlk_writeable())) {
 182                         dtlk_write_tts(ch);
 183                         buf++;
 184                         i++;
 185                         if (i % 5 == 0)
 186                                 /* We yield our time until scheduled
 187                                    again.  This reduces the transfer
 188                                    rate to 500 bytes/sec, but that's
 189                                    still enough to keep up with the
 190                                    speech synthesizer. */
 191                                 msleep_interruptible(1);
 192                         else {
 193                                 /* the RDY bit goes zero 2-3 usec
 194                                    after writing, and goes 1 again
 195                                    180-190 usec later.  Here, we wait
 196                                    up to 250 usec for the RDY bit to
 197                                    go nonzero. */
 198                                 for (retries = 0;
 199                                      retries < loops_per_jiffy / (4000/HZ);
 200                                      retries++)
 201                                         if (inb_p(dtlk_port_tts) &
 202                                             TTS_WRITABLE)
 203                                                 break;
 204                         }
 205                         retries = 0;
 206                 }
 207                 if (i == count)
 208                         return i;
 209                 if (file->f_flags & O_NONBLOCK)
 210                         break;
 211
 212                 msleep_interruptible(1);
 213
 214                 if (++retries > 10 * HZ) { /* wait no more than 10 sec
 215                                               from last write */
 216                         printk("dtlk: write timeout.  "
 217                                "inb_p(dtlk_port_tts) = 0x%02x\n",
 218                                inb_p(dtlk_port_tts));
 219                         TRACE_RET;
 220                         return -EBUSY;
 221                 }
 222         }
 223         TRACE_RET;
 224         return -EAGAIN;
 225 }
 226
 227 static unsigned int dtlk_poll(struct file *file, poll_table * wait)
 228 {
 229         int mask = 0;
 230         unsigned long expires;
 231
 232         TRACE_TEXT(" dtlk_poll");
 233         /*
 234            static long int j;
 235            printk(".");
 236            printk("<%ld>", jiffies-j);
 237            j=jiffies;
 238          */
 239         poll_wait(file, &dtlk_process_list, wait);
 240
 241         if (dtlk_has_indexing && dtlk_readable()) {
 242                 del_timer(&dtlk_timer);
 243                 mask = POLLIN | POLLRDNORM;
 244         }
 245         if (dtlk_writeable()) {
 246                 del_timer(&dtlk_timer);
 247                 mask |= POLLOUT | POLLWRNORM;
 248         }
 249         /* there are no exception conditions */
 250
 251         /* There won't be any interrupts, so we set a timer instead. */
 252         expires = jiffies + 3*HZ / 100;
 253         mod_timer(&dtlk_timer, expires);
 254
 255         return mask;
 256 }
 257
 258 static void dtlk_timer_tick(unsigned long data)
 259 {
 260         TRACE_TEXT(" dtlk_timer_tick");
 261         wake_up_interruptible(&dtlk_process_list);
 262 }
 263
 264 static int dtlk_ioctl(struct inode *inode,
 265                       struct file *file,
 266                       unsigned int cmd,
 267                       unsigned long arg)
 268 {
 269         char __user *argp = (char __user *)arg;
 270         struct dtlk_settings *sp;
 271         char portval;
 272         TRACE_TEXT(" dtlk_ioctl");
 273
 274         switch (cmd) {
 275
 276         case DTLK_INTERROGATE:
 277                 sp = dtlk_interrogate();
 278                 if (copy_to_user(argp, sp, sizeof(struct dtlk_settings)))
 279                         return -EINVAL;
 280                 return 0;
 281
 282         case DTLK_STATUS:
 283                 portval = inb_p(dtlk_port_tts);
 284                 return put_user(portval, argp);
 285
 286         default:
 287                 return -EINVAL;
 288         }
 289 }
 290
 291 /* No BKL needed here; "dtlk_busy" is the only global resource,
 292    and it is not ever set by anybody (test is broken) */
 293 static int dtlk_open(struct inode *inode, struct file *file)
 294 {
 295         TRACE_TEXT("(dtlk_open");
 296
 297         nonseekable_open(inode, file);
 298         switch (iminor(inode)) {
 299         case DTLK_MINOR:
 300                 if (dtlk_busy)
 301                         return -EBUSY;
 302                 return nonseekable_open(inode, file);
 303
 304         default:
 305                 return -ENXIO;
 306         }
 307 }
 308
 309 static int dtlk_release(struct inode *inode, struct file *file)
 310 {
 311         TRACE_TEXT("(dtlk_release");
 312
 313         switch (iminor(inode)) {
 314         case DTLK_MINOR:
 315                 break;
 316
 317         default:
 318                 break;
 319         }
 320         TRACE_RET;
 321
 322         del_timer_sync(&dtlk_timer);
 323
 324         return 0;
 325 }
 326
 327 static int __init dtlk_init(void)
 328 {
 329         int err;
 330
 331         dtlk_port_lpc = 0;
 332         dtlk_port_tts = 0;
 333         dtlk_busy = 0;
 334         dtlk_major = register_chrdev(0, "dtlk", &dtlk_fops);
 335         if (dtlk_major < 0) {
 336                 printk(KERN_ERR "DoubleTalk PC - cannot register device\n");
 337                 return dtlk_major;
 338         }
 339         err = dtlk_dev_probe();
 340         if (err) {
 341                 unregister_chrdev(dtlk_major, "dtlk");
 342                 return err;
 343         }
 344         printk(", MAJOR %d\n", dtlk_major);
 345
 346         init_waitqueue_head(&dtlk_process_list);
 347
 348         return 0;
 349 }
 350
 351 static void __exit dtlk_cleanup (void)
 352 {
 353         dtlk_write_bytes("goodbye", 8);
 354         msleep_interruptible(500);              /* nap 0.50 sec but
 355                                                    could be awakened
 356                                                    earlier by
 357                                                    signals... */
 358
 359         dtlk_write_tts(DTLK_CLEAR);
 360         unregister_chrdev(dtlk_major, "dtlk");
 361         release_region(dtlk_port_lpc, DTLK_IO_EXTENT);
 362 }
 363
 364 module_init(dtlk_init);
 365 module_exit(dtlk_cleanup);
 366
 367 /* ------------------------------------------------------------------------ */
 368
 369 static int dtlk_readable(void)
 370 {
 371 #ifdef TRACING
 372         printk(" dtlk_readable=%u@%u", inb_p(dtlk_port_lpc) != 0x7f, jiffies);
 373 #endif
 374         return inb_p(dtlk_port_lpc) != 0x7f;
 375 }
 376
 377 static int dtlk_writeable(void)
 378 {
 379         /* TRACE_TEXT(" dtlk_writeable"); */
 380 #ifdef TRACINGMORE
 381         printk(" dtlk_writeable=%u", (inb_p(dtlk_port_tts) & TTS_WRITABLE)!=0);
 382 #endif
 383         return inb_p(dtlk_port_tts) & TTS_WRITABLE;
 384 }
 385
 386 static int __init dtlk_dev_probe(void)
 387 {
 388         unsigned int testval = 0;
 389         int i = 0;
 390         struct dtlk_settings *sp;
 391
 392         if (dtlk_port_lpc | dtlk_port_tts)
 393                 return -EBUSY;
 394
 395         for (i = 0; dtlk_portlist[i]; i++) {
 396 #if 0
 397                 printk("DoubleTalk PC - Port %03x = %04x\n",
 398                        dtlk_portlist[i], (testval = inw_p(dtlk_portlist[i])));
 399 #endif
 400
 401                 if (!request_region(dtlk_portlist[i], DTLK_IO_EXTENT,
 402                                "dtlk"))
 403                         continue;
 404                 testval = inw_p(dtlk_portlist[i]);
 405                 if ((testval &= 0xfbff) == 0x107f) {
 406                         dtlk_port_lpc = dtlk_portlist[i];
 407                         dtlk_port_tts = dtlk_port_lpc + 1;
 408
 409                         sp = dtlk_interrogate();
 410                         printk("DoubleTalk PC at %03x-%03x, "
 411                                "ROM version %s, serial number %u",
 412                                dtlk_portlist[i], dtlk_portlist[i] +
 413                                DTLK_IO_EXTENT - 1,
 414                                sp->rom_version, sp->serial_number);
 415
 416                         /* put LPC port into known state, so
 417                            dtlk_readable() gives valid result */
 418                         outb_p(0xff, dtlk_port_lpc);
 419
 420                         /* INIT string and index marker */
 421                         dtlk_write_bytes("\036\1@\0\0012I\r", 8);
 422                         /* posting an index takes 18 msec.  Here, we
 423                            wait up to 100 msec to see whether it
 424                            appears. */
 425                         msleep_interruptible(100);
 426                         dtlk_has_indexing = dtlk_readable();
 427 #ifdef TRACING
 428                         printk(", indexing %d\n", dtlk_has_indexing);
 429 #endif
 430 #ifdef INSCOPE
 431                         {
 432 /* This macro records ten samples read from the LPC port, for later display */
 433 #define LOOK                                    \
 434 for (i = 0; i < 10; i++)                        \
 435   {                                             \
 436     buffer[b++] = inb_p(dtlk_port_lpc);         \
 437     __delay(loops_per_jiffy/(1000000/HZ));             \
 438   }
 439                                 char buffer[1000];
 440                                 int b = 0, i, j;
 441
 442                                 LOOK
 443                                 outb_p(0xff, dtlk_port_lpc);
 444                                 buffer[b++] = 0;
 445                                 LOOK
 446                                 dtlk_write_bytes("\0012I\r", 4);
 447                                 buffer[b++] = 0;
 448                                 __delay(50 * loops_per_jiffy / (1000/HZ));
 449                                 outb_p(0xff, dtlk_port_lpc);
 450                                 buffer[b++] = 0;
 451                                 LOOK
 452
 453                                 printk("\n");
 454                                 for (j = 0; j < b; j++)
 455                                         printk(" %02x", buffer[j]);
 456                                 printk("\n");
 457                         }
 458 #endif                          /* INSCOPE */
 459
 460 #ifdef OUTSCOPE
 461                         {
 462 /* This macro records ten samples read from the TTS port, for later display */
 463 #define LOOK                                    \
 464 for (i = 0; i < 10; i++)                        \
 465   {                                             \
 466     buffer[b++] = inb_p(dtlk_port_tts);         \
 467     __delay(loops_per_jiffy/(1000000/HZ));  /* 1 us */ \
 468   }
 469                                 char buffer[1000];
 470                                 int b = 0, i, j;
 471
 472                                 mdelay(10);     /* 10 ms */
 473                                 LOOK
 474                                 outb_p(0x03, dtlk_port_tts);
 475                                 buffer[b++] = 0;
 476                                 LOOK
 477                                 LOOK
 478
 479                                 printk("\n");
 480                                 for (j = 0; j < b; j++)
 481                                         printk(" %02x", buffer[j]);
 482                                 printk("\n");
 483                         }
 484 #endif                          /* OUTSCOPE */
 485
 486                         dtlk_write_bytes("Double Talk found", 18);
 487
 488                         return 0;
 489                 }
 490                 release_region(dtlk_portlist[i], DTLK_IO_EXTENT);
 491         }
 492
 493         printk(KERN_INFO "DoubleTalk PC - not found\n");
 494         return -ENODEV;
 495 }
 496
 497 /*
 498    static void dtlk_handle_error(char op, char rc, unsigned int minor)
 499    {
 500    printk(KERN_INFO"\nDoubleTalk PC - MINOR: %d, OPCODE: %d, ERROR: %d\n",
 501    minor, op, rc);
 502    return;
 503    }
 504  */
 505
 506 /* interrogate the DoubleTalk PC and return its settings */
 507 static struct dtlk_settings *dtlk_interrogate(void)
 508 {
 509         unsigned char *t;
 510         static char buf[sizeof(struct dtlk_settings) + 1];
 511         int total, i;
 512         static struct dtlk_settings status;
 513         TRACE_TEXT("(dtlk_interrogate");
 514         dtlk_write_bytes("\030\001?", 3);
 515         for (total = 0, i = 0; i < 50; i++) {
 516                 buf[total] = dtlk_read_tts();
 517                 if (total > 2 && buf[total] == 0x7f)
 518                         break;
 519                 if (total < sizeof(struct dtlk_settings))
 520                         total++;
 521         }
 522         /*
 523            if (i==50) printk("interrogate() read overrun\n");
 524            for (i=0; i<sizeof(buf); i++)
 525            printk(" %02x", buf[i]);
 526            printk("\n");
 527          */
 528         t = buf;
 529         status.serial_number = t[0] + t[1] * 256; /* serial number is
 530                                                      little endian */
 531         t += 2;
 532
 533         i = 0;
 534         while (*t != '\r') {
 535                 status.rom_version[i] = *t;
 536                 if (i < sizeof(status.rom_version) - 1)
 537                         i++;
 538                 t++;
 539         }
 540         status.rom_version[i] = 0;
 541         t++;
 542
 543         status.mode = *t++;
 544         status.punc_level = *t++;
 545         status.formant_freq = *t++;
 546         status.pitch = *t++;
 547         status.speed = *t++;
 548         status.volume = *t++;
 549         status.tone = *t++;
 550         status.expression = *t++;
 551         status.ext_dict_loaded = *t++;
 552         status.ext_dict_status = *t++;
 553         status.free_ram = *t++;
 554         status.articulation = *t++;
 555         status.reverb = *t++;
 556         status.eob = *t++;
 557         status.has_indexing = dtlk_has_indexing;
 558         TRACE_RET;
 559         return &status;
 560 }
 561
 562 static char dtlk_read_tts(void)
 563 {
 564         int portval, retries = 0;
 565         char ch;
 566         TRACE_TEXT("(dtlk_read_tts");
 567
 568         /* verify DT is ready, read char, wait for ACK */
 569         do {
 570                 portval = inb_p(dtlk_port_tts);
 571         } while ((portval & TTS_READABLE) == 0 &&
 572                  retries++ < DTLK_MAX_RETRIES);
 573         if (retries == DTLK_MAX_RETRIES)
 574                 printk(KERN_ERR "dtlk_read_tts() timeout\n");
 575
 576         ch = inb_p(dtlk_port_tts);      /* input from TTS port */
 577         ch &= 0x7f;
 578         outb_p(ch, dtlk_port_tts);
 579
 580         retries = 0;
 581         do {
 582                 portval = inb_p(dtlk_port_tts);
 583         } while ((portval & TTS_READABLE) != 0 &&
 584                  retries++ < DTLK_MAX_RETRIES);
 585         if (retries == DTLK_MAX_RETRIES)
 586                 printk(KERN_ERR "dtlk_read_tts() timeout\n");
 587
 588         TRACE_RET;
 589         return ch;
 590 }
 591
 592 static char dtlk_read_lpc(void)
 593 {
 594         int retries = 0;
 595         char ch;
 596         TRACE_TEXT("(dtlk_read_lpc");
 597
 598         /* no need to test -- this is only called when the port is readable */
 599
 600         ch = inb_p(dtlk_port_lpc);      /* input from LPC port */
 601
 602         outb_p(0xff, dtlk_port_lpc);
 603
 604         /* acknowledging a read takes 3-4
 605            usec.  Here, we wait up to 20 usec
 606            for the acknowledgement */
 607         retries = (loops_per_jiffy * 20) / (1000000/HZ);
 608         while (inb_p(dtlk_port_lpc) != 0x7f && --retries > 0);
 609         if (retries == 0)
 610                 printk(KERN_ERR "dtlk_read_lpc() timeout\n");
 611
 612         TRACE_RET;
 613         return ch;
 614 }
 615
 616 /* write n bytes to tts port */
 617 static char dtlk_write_bytes(const char *buf, int n)
 618 {
 619         char val = 0;
 620         /*  printk("dtlk_write_bytes(\"%-*s\", %d)\n", n, buf, n); */
 621         TRACE_TEXT("(dtlk_write_bytes");
 622         while (n-- > 0)
 623                 val = dtlk_write_tts(*buf++);
 624         TRACE_RET;
 625         return val;
 626 }
 627
 628 static char dtlk_write_tts(char ch)
 629 {
 630         int retries = 0;
 631 #ifdef TRACINGMORE
 632         printk("  dtlk_write_tts(");
 633         if (' ' <= ch && ch <= '~')
 634                 printk("'%c'", ch);
 635         else
 636                 printk("0x%02x", ch);
 637 #endif
 638         if (ch != DTLK_CLEAR)   /* no flow control for CLEAR command */
 639                 while ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0 &&
 640                        retries++ < DTLK_MAX_RETRIES)    /* DT ready? */
 641                         ;
 642         if (retries == DTLK_MAX_RETRIES)
 643                 printk(KERN_ERR "dtlk_write_tts() timeout\n");
 644
 645         outb_p(ch, dtlk_port_tts);      /* output to TTS port */
 646         /* the RDY bit goes zero 2-3 usec after writing, and goes
 647            1 again 180-190 usec later.  Here, we wait up to 10
 648            usec for the RDY bit to go zero. */
 649         for (retries = 0; retries < loops_per_jiffy / (100000/HZ); retries++)
 650                 if ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0)
 651                         break;
 652
 653 #ifdef TRACINGMORE
 654         printk(")\n");
 655 #endif
 656         return 0;
 657 }
 658
 659 MODULE_LICENSE("GPL");