git.oblomov.eu Git - linux-2.6/blob - sound/oss/forte.c

   1 /*
   2  * forte.c - ForteMedia FM801 OSS Driver
   3  *
   4  * Written by Martin K. Petersen <mkp@mkp.net>
   5  * Copyright (C) 2002 Hewlett-Packard Company
   6  * Portions Copyright (C) 2003 Martin K. Petersen
   7  *
   8  * Latest version: http://mkp.net/forte/
   9  *
  10  * Based upon the ALSA FM801 driver by Jaroslav Kysela and OSS drivers
  11  * by Thomas Sailer, Alan Cox, Zach Brown, and Jeff Garzik.  Thanks
  12  * guys!
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License version
  16  * 2 as published by the Free Software Foundation.
  17  *
  18  * This program is distributed in the hope that it will be useful, but
  19  * WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  26  * USA
  27  *
  28  */
  29
  30 #include <linux/module.h>
  31 #include <linux/kernel.h>
  32
  33 #include <linux/init.h>
  34 #include <linux/spinlock.h>
  35 #include <linux/pci.h>
  36
  37 #include <linux/delay.h>
  38 #include <linux/poll.h>
  39
  40 #include <linux/sound.h>
  41 #include <linux/ac97_codec.h>
  42 #include <linux/interrupt.h>
  43
  44 #include <linux/proc_fs.h>
  45 #include <linux/mutex.h>
  46
  47 #include <asm/uaccess.h>
  48 #include <asm/io.h>
  49
  50 #define DRIVER_NAME     "forte"
  51 #define DRIVER_VERSION  "$Id: forte.c,v 1.63 2003/03/01 05:32:42 mkp Exp $"
  52 #define PFX             DRIVER_NAME ": "
  53
  54 #undef M_DEBUG
  55
  56 #ifdef M_DEBUG
  57 #define DPRINTK(args...) printk(KERN_WARNING args)
  58 #else
  59 #define DPRINTK(args...)
  60 #endif
  61
  62 /* Card capabilities */
  63 #define FORTE_CAPS              (DSP_CAP_MMAP | DSP_CAP_TRIGGER)
  64
  65 /* Supported audio formats */
  66 #define FORTE_FMTS              (AFMT_U8 | AFMT_S16_LE)
  67
  68 /* Buffers */
  69 #define FORTE_MIN_FRAG_SIZE     256
  70 #define FORTE_MAX_FRAG_SIZE     PAGE_SIZE
  71 #define FORTE_DEF_FRAG_SIZE     256
  72 #define FORTE_MIN_FRAGMENTS     2
  73 #define FORTE_MAX_FRAGMENTS     256
  74 #define FORTE_DEF_FRAGMENTS     2
  75 #define FORTE_MIN_BUF_MSECS     500
  76 #define FORTE_MAX_BUF_MSECS     1000
  77
  78 /* PCI BARs */
  79 #define FORTE_PCM_VOL           0x00    /* PCM Output Volume */
  80 #define FORTE_FM_VOL            0x02    /* FM Output Volume */
  81 #define FORTE_I2S_VOL           0x04    /* I2S Volume */
  82 #define FORTE_REC_SRC           0x06    /* Record Source */
  83 #define FORTE_PLY_CTRL          0x08    /* Playback Control */
  84 #define FORTE_PLY_COUNT         0x0a    /* Playback Count */
  85 #define FORTE_PLY_BUF1          0x0c    /* Playback Buffer I */
  86 #define FORTE_PLY_BUF2          0x10    /* Playback Buffer II */
  87 #define FORTE_CAP_CTRL          0x14    /* Capture Control */
  88 #define FORTE_CAP_COUNT         0x16    /* Capture Count */
  89 #define FORTE_CAP_BUF1          0x18    /* Capture Buffer I */
  90 #define FORTE_CAP_BUF2          0x1c    /* Capture Buffer II */
  91 #define FORTE_CODEC_CTRL        0x22    /* Codec Control */
  92 #define FORTE_I2S_MODE          0x24    /* I2S Mode Control */
  93 #define FORTE_VOLUME            0x26    /* Volume Up/Down/Mute Status */
  94 #define FORTE_I2C_CTRL          0x29    /* I2C Control */
  95 #define FORTE_AC97_CMD          0x2a    /* AC'97 Command */
  96 #define FORTE_AC97_DATA         0x2c    /* AC'97 Data */
  97 #define FORTE_MPU401_DATA       0x30    /* MPU401 Data */
  98 #define FORTE_MPU401_CMD        0x31    /* MPU401 Command */
  99 #define FORTE_GPIO_CTRL         0x52    /* General Purpose I/O Control */
 100 #define FORTE_GEN_CTRL          0x54    /* General Control */
 101 #define FORTE_IRQ_MASK          0x56    /* Interrupt Mask */
 102 #define FORTE_IRQ_STATUS        0x5a    /* Interrupt Status */
 103 #define FORTE_OPL3_BANK0        0x68    /* OPL3 Status Read / Bank 0 Write */
 104 #define FORTE_OPL3_DATA0        0x69    /* OPL3 Data 0 Write */
 105 #define FORTE_OPL3_BANK1        0x6a    /* OPL3 Bank 1 Write */
 106 #define FORTE_OPL3_DATA1        0x6b    /* OPL3 Bank 1 Write */
 107 #define FORTE_POWERDOWN         0x70    /* Blocks Power Down Control */
 108
 109 #define FORTE_CAP_OFFSET        FORTE_CAP_CTRL - FORTE_PLY_CTRL
 110
 111 #define FORTE_AC97_ADDR_SHIFT   10
 112
 113 /* Playback and record control register bits */
 114 #define FORTE_BUF1_LAST         (1<<1)
 115 #define FORTE_BUF2_LAST         (1<<2)
 116 #define FORTE_START             (1<<5)
 117 #define FORTE_PAUSE             (1<<6)
 118 #define FORTE_IMMED_STOP        (1<<7)
 119 #define FORTE_RATE_SHIFT        8
 120 #define FORTE_RATE_MASK         (15 << FORTE_RATE_SHIFT)
 121 #define FORTE_CHANNELS_4        (1<<12) /* Playback only */
 122 #define FORTE_CHANNELS_6        (2<<12) /* Playback only */
 123 #define FORTE_CHANNELS_6MS      (3<<12) /* Playback only */
 124 #define FORTE_CHANNELS_MASK     (3<<12)
 125 #define FORTE_16BIT             (1<<14)
 126 #define FORTE_STEREO            (1<<15)
 127
 128 /* IRQ status bits */
 129 #define FORTE_IRQ_PLAYBACK      (1<<8)
 130 #define FORTE_IRQ_CAPTURE       (1<<9)
 131 #define FORTE_IRQ_VOLUME        (1<<14)
 132 #define FORTE_IRQ_MPU           (1<<15)
 133
 134 /* CODEC control */
 135 #define FORTE_CC_CODEC_RESET    (1<<5)
 136 #define FORTE_CC_AC97_RESET     (1<<6)
 137
 138 /* AC97 cmd */
 139 #define FORTE_AC97_WRITE        (0<<7)
 140 #define FORTE_AC97_READ         (1<<7)
 141 #define FORTE_AC97_DP_INVALID   (0<<8)
 142 #define FORTE_AC97_DP_VALID     (1<<8)
 143 #define FORTE_AC97_PORT_RDY     (0<<9)
 144 #define FORTE_AC97_PORT_BSY     (1<<9)
 145
 146
 147 struct forte_channel {
 148         const char              *name;
 149
 150         unsigned short          ctrl;           /* Ctrl BAR contents */
 151         unsigned long           iobase;         /* Ctrl BAR address */
 152
 153         wait_queue_head_t       wait;
 154
 155         void                    *buf;           /* Buffer */
 156         dma_addr_t              buf_handle;     /* Buffer handle */
 157
 158         unsigned int            record;
 159         unsigned int            format;
 160         unsigned int            rate;
 161         unsigned int            stereo;
 162
 163         unsigned int            frag_sz;        /* Current fragment size */
 164         unsigned int            frag_num;       /* Current # of fragments */
 165         unsigned int            frag_msecs;     /* Milliseconds per frag */
 166         unsigned int            buf_sz;         /* Current buffer size */
 167
 168         unsigned int            hwptr;          /* Tail */
 169         unsigned int            swptr;          /* Head */
 170         unsigned int            filled_frags;   /* Fragments currently full */
 171         unsigned int            next_buf;       /* Index of next buffer */
 172
 173         unsigned int            active;         /* Channel currently in use */
 174         unsigned int            mapped;         /* mmap */
 175
 176         unsigned int            buf_pages;      /* Real size of buffer */
 177         unsigned int            nr_irqs;        /* Number of interrupts */
 178         unsigned int            bytes;          /* Total bytes */
 179         unsigned int            residue;        /* Partial fragment */
 180 };
 181
 182
 183 struct forte_chip {
 184         struct pci_dev          *pci_dev;
 185         unsigned long           iobase;
 186         int                     irq;
 187
 188         struct mutex            open_mutex;     /* Device access */
 189         spinlock_t              lock;           /* State */
 190
 191         spinlock_t              ac97_lock;
 192         struct ac97_codec       *ac97;
 193
 194         int                     multichannel;
 195         int                     dsp;            /* OSS handle */
 196         int                     trigger;        /* mmap I/O trigger */
 197
 198         struct forte_channel    play;
 199         struct forte_channel    rec;
 200 };
 201
 202
 203 static int channels[] = { 2, 4, 6, };
 204 static int rates[]    = { 5500, 8000, 9600, 11025, 16000, 19200,
 205                           22050, 32000, 38400, 44100, 48000, };
 206
 207 static struct forte_chip *forte;
 208 static int found;
 209
 210
 211 /* AC97 Codec -------------------------------------------------------------- */
 212
 213
 214 /**
 215  * forte_ac97_wait:
 216  * @chip:       fm801 instance whose AC97 codec to wait on
 217  *
 218  * FIXME:
 219  *              Stop busy-waiting
 220  */
 221
 222 static inline int
 223 forte_ac97_wait (struct forte_chip *chip)
 224 {
 225         int i = 10000;
 226
 227         while ( (inw (chip->iobase + FORTE_AC97_CMD) & FORTE_AC97_PORT_BSY)
 228                 && i-- )
 229                 cpu_relax();
 230
 231         return i == 0;
 232 }
 233
 234
 235 /**
 236  * forte_ac97_read:
 237  * @codec:      AC97 codec to read from
 238  * @reg:        register to read
 239  */
 240
 241 static u16
 242 forte_ac97_read (struct ac97_codec *codec, u8 reg)
 243 {
 244         u16 ret = 0;
 245         struct forte_chip *chip = codec->private_data;
 246
 247         spin_lock (&chip->ac97_lock);
 248
 249         /* Knock, knock */
 250         if (forte_ac97_wait (chip)) {
 251                 printk (KERN_ERR PFX "ac97_read: Serial bus busy\n");
 252                 goto out;
 253         }
 254
 255         /* Send read command */
 256         outw (reg | (1<<7), chip->iobase + FORTE_AC97_CMD);
 257
 258         if (forte_ac97_wait (chip)) {
 259                 printk (KERN_ERR PFX "ac97_read: Bus busy reading reg 0x%x\n",
 260                         reg);
 261                 goto out;
 262         }
 263
 264         /* Sanity checking */
 265         if (inw (chip->iobase + FORTE_AC97_CMD) & FORTE_AC97_DP_INVALID) {
 266                 printk (KERN_ERR PFX "ac97_read: Invalid data port");
 267                 goto out;
 268         }
 269
 270         /* Fetch result */
 271         ret = inw (chip->iobase + FORTE_AC97_DATA);
 272
 273  out:
 274         spin_unlock (&chip->ac97_lock);
 275         return ret;
 276 }
 277
 278
 279 /**
 280  * forte_ac97_write:
 281  * @codec:      AC97 codec to send command to
 282  * @reg:        register to write
 283  * @val:        value to write
 284  */
 285
 286 static void
 287 forte_ac97_write (struct ac97_codec *codec, u8 reg, u16 val)
 288 {
 289         struct forte_chip *chip = codec->private_data;
 290
 291         spin_lock (&chip->ac97_lock);
 292
 293         /* Knock, knock */
 294         if (forte_ac97_wait (chip)) {
 295                 printk (KERN_ERR PFX "ac97_write: Serial bus busy\n");
 296                 goto out;
 297         }
 298
 299         outw (val, chip->iobase + FORTE_AC97_DATA);
 300         outb (reg | FORTE_AC97_WRITE, chip->iobase + FORTE_AC97_CMD);
 301
 302         /* Wait for completion */
 303         if (forte_ac97_wait (chip)) {
 304                 printk (KERN_ERR PFX "ac97_write: Bus busy after write\n");
 305                 goto out;
 306         }
 307
 308  out:
 309         spin_unlock (&chip->ac97_lock);
 310 }
 311
 312
 313 /* Mixer ------------------------------------------------------------------- */
 314
 315
 316 /**
 317  * forte_mixer_open:
 318  * @inode:
 319  * @file:
 320  */
 321
 322 static int
 323 forte_mixer_open (struct inode *inode, struct file *file)
 324 {
 325         struct forte_chip *chip = forte;
 326         file->private_data = chip->ac97;
 327         return 0;
 328 }
 329
 330
 331 /**
 332  * forte_mixer_release:
 333  * @inode:
 334  * @file:
 335  */
 336
 337 static int
 338 forte_mixer_release (struct inode *inode, struct file *file)
 339 {
 340         /* We will welease Wodewick */
 341         return 0;
 342 }
 343
 344
 345 /**
 346  * forte_mixer_ioctl:
 347  * @inode:
 348  * @file:
 349  */
 350
 351 static int
 352 forte_mixer_ioctl (struct inode *inode, struct file *file,
 353                    unsigned int cmd, unsigned long arg)
 354 {
 355         struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
 356
 357         return codec->mixer_ioctl (codec, cmd, arg);
 358 }
 359
 360
 361 static struct file_operations forte_mixer_fops = {
 362         .owner                  = THIS_MODULE,
 363         .llseek                 = no_llseek,
 364         .ioctl                  = forte_mixer_ioctl,
 365         .open                   = forte_mixer_open,
 366         .release                = forte_mixer_release,
 367 };
 368
 369
 370 /* Channel ----------------------------------------------------------------- */
 371
 372 /**
 373  * forte_channel_reset:
 374  * @channel:    Channel to reset
 375  *
 376  * Locking:     Must be called with lock held.
 377  */
 378
 379 static void
 380 forte_channel_reset (struct forte_channel *channel)
 381 {
 382         if (!channel || !channel->iobase)
 383                 return;
 384
 385         DPRINTK ("%s: channel = %s\n", __FUNCTION__, channel->name);
 386
 387         channel->ctrl &= ~FORTE_START;
 388         outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
 389
 390         /* We always play at least two fragments, hence these defaults */
 391         channel->hwptr = channel->frag_sz;
 392         channel->next_buf = 1;
 393         channel->swptr = 0;
 394         channel->filled_frags = 0;
 395         channel->active = 0;
 396         channel->bytes = 0;
 397         channel->nr_irqs = 0;
 398         channel->mapped = 0;
 399         channel->residue = 0;
 400 }
 401
 402
 403 /**
 404  * forte_channel_start:
 405  * @channel:    Channel to start (record/playback)
 406  *
 407  * Locking:     Must be called with lock held.
 408  */
 409
 410 static void inline
 411 forte_channel_start (struct forte_channel *channel)
 412 {
 413         if (!channel || !channel->iobase || channel->active)
 414                 return;
 415
 416         channel->ctrl &= ~(FORTE_PAUSE | FORTE_BUF1_LAST | FORTE_BUF2_LAST
 417                            | FORTE_IMMED_STOP);
 418         channel->ctrl |= FORTE_START;
 419         channel->active = 1;
 420         outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
 421 }
 422
 423
 424 /**
 425  * forte_channel_stop:
 426  * @channel:    Channel to stop
 427  *
 428  * Locking:     Must be called with lock held.
 429  */
 430
 431 static void inline
 432 forte_channel_stop (struct forte_channel *channel)
 433 {
 434         if (!channel || !channel->iobase)
 435                 return;
 436
 437         channel->ctrl &= ~(FORTE_START | FORTE_PAUSE);
 438         channel->ctrl |= FORTE_IMMED_STOP;
 439
 440         channel->active = 0;
 441         outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
 442 }
 443
 444
 445 /**
 446  * forte_channel_pause:
 447  * @channel:    Channel to pause
 448  *
 449  * Locking:     Must be called with lock held.
 450  */
 451
 452 static void inline
 453 forte_channel_pause (struct forte_channel *channel)
 454 {
 455         if (!channel || !channel->iobase)
 456                 return;
 457
 458         channel->ctrl |= FORTE_PAUSE;
 459
 460         channel->active = 0;
 461         outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
 462 }
 463
 464
 465 /**
 466  * forte_channel_rate:
 467  * @channel:    Channel whose rate to set.  Playback and record are
 468  *              independent.
 469  * @rate:       Channel rate in Hz
 470  *
 471  * Locking:     Must be called with lock held.
 472  */
 473
 474 static int
 475 forte_channel_rate (struct forte_channel *channel, unsigned int rate)
 476 {
 477         int new_rate;
 478
 479         if (!channel || !channel->iobase)
 480                 return -EINVAL;
 481
 482         /* The FM801 only supports a handful of fixed frequencies.
 483          * We find the value closest to what userland requested.
 484          */
 485         if      (rate <= 6250)  { rate = 5500;  new_rate =  0; }
 486         else if (rate <= 8800)  { rate = 8000;  new_rate =  1; }
 487         else if (rate <= 10312) { rate = 9600;  new_rate =  2; }
 488         else if (rate <= 13512) { rate = 11025; new_rate =  3; }
 489         else if (rate <= 17600) { rate = 16000; new_rate =  4; }
 490         else if (rate <= 20625) { rate = 19200; new_rate =  5; }
 491         else if (rate <= 27025) { rate = 22050; new_rate =  6; }
 492         else if (rate <= 35200) { rate = 32000; new_rate =  7; }
 493         else if (rate <= 41250) { rate = 38400; new_rate =  8; }
 494         else if (rate <= 46050) { rate = 44100; new_rate =  9; }
 495         else                    { rate = 48000; new_rate = 10; }
 496
 497         channel->ctrl &= ~FORTE_RATE_MASK;
 498         channel->ctrl |= new_rate << FORTE_RATE_SHIFT;
 499         channel->rate = rate;
 500
 501         DPRINTK ("%s: %s rate = %d\n", __FUNCTION__, channel->name, rate);
 502
 503         return rate;
 504 }
 505
 506
 507 /**
 508  * forte_channel_format:
 509  * @channel:    Channel whose audio format to set
 510  * @format:     OSS format ID
 511  *
 512  * Locking:     Must be called with lock held.
 513  */
 514
 515 static int
 516 forte_channel_format (struct forte_channel *channel, int format)
 517 {
 518         if (!channel || !channel->iobase)
 519                 return -EINVAL;
 520
 521         switch (format) {
 522
 523         case AFMT_QUERY:
 524                 break;
 525
 526         case AFMT_U8:
 527                 channel->ctrl &= ~FORTE_16BIT;
 528                 channel->format = AFMT_U8;
 529                 break;
 530
 531         case AFMT_S16_LE:
 532         default:
 533                 channel->ctrl |= FORTE_16BIT;
 534                 channel->format = AFMT_S16_LE;
 535                 break;
 536         }
 537
 538         DPRINTK ("%s: %s want %d format, got %d\n", __FUNCTION__, channel->name,
 539                  format, channel->format);
 540
 541         return channel->format;
 542 }
 543
 544
 545 /**
 546  * forte_channel_stereo:
 547  * @channel:    Channel to toggle
 548  * @stereo:     0 for Mono, 1 for Stereo
 549  *
 550  * Locking:     Must be called with lock held.
 551  */
 552
 553 static int
 554 forte_channel_stereo (struct forte_channel *channel, unsigned int stereo)
 555 {
 556         int ret;
 557
 558         if (!channel || !channel->iobase)
 559                 return -EINVAL;
 560
 561         DPRINTK ("%s: %s stereo = %d\n", __FUNCTION__, channel->name, stereo);
 562
 563         switch (stereo) {
 564
 565         case 0:
 566                 channel->ctrl &= ~(FORTE_STEREO | FORTE_CHANNELS_MASK);
 567                 channel-> stereo = stereo;
 568                 ret = stereo;
 569                 break;
 570
 571         case 1:
 572                 channel->ctrl &= ~FORTE_CHANNELS_MASK;
 573                 channel->ctrl |= FORTE_STEREO;
 574                 channel-> stereo = stereo;
 575                 ret = stereo;
 576                 break;
 577
 578         default:
 579                 DPRINTK ("Unsupported channel format");
 580                 ret = -EINVAL;
 581                 break;
 582         }
 583
 584         return ret;
 585 }
 586
 587
 588 /**
 589  * forte_channel_buffer:
 590  * @channel:    Channel whose buffer to set up
 591  *
 592  * Locking:     Must be called with lock held.
 593  */
 594
 595 static void
 596 forte_channel_buffer (struct forte_channel *channel, int sz, int num)
 597 {
 598         unsigned int msecs, shift;
 599
 600         /* Go away, I'm busy */
 601         if (channel->filled_frags || channel->bytes)
 602                 return;
 603
 604         /* Fragment size must be a power of 2 */
 605         shift = 0; sz++;
 606         while (sz >>= 1)
 607                 shift++;
 608         channel->frag_sz = 1 << shift;
 609
 610         /* Round fragment size to something reasonable */
 611         if (channel->frag_sz < FORTE_MIN_FRAG_SIZE)
 612                 channel->frag_sz = FORTE_MIN_FRAG_SIZE;
 613
 614         if (channel->frag_sz > FORTE_MAX_FRAG_SIZE)
 615                 channel->frag_sz = FORTE_MAX_FRAG_SIZE;
 616
 617         /* Find fragment length in milliseconds */
 618         msecs = channel->frag_sz /
 619                 (channel->format == AFMT_S16_LE ? 2 : 1) /
 620                 (channel->stereo ? 2 : 1) /
 621                 (channel->rate / 1000);
 622
 623         channel->frag_msecs = msecs;
 624
 625         /* Pick a suitable number of fragments */
 626         if (msecs * num < FORTE_MIN_BUF_MSECS)
 627              num = FORTE_MIN_BUF_MSECS / msecs;
 628
 629         if (msecs * num > FORTE_MAX_BUF_MSECS)
 630              num = FORTE_MAX_BUF_MSECS / msecs;
 631
 632         /* Fragment number must be a power of 2 */
 633         shift = 0;
 634         while (num >>= 1)
 635                 shift++;
 636         channel->frag_num = 1 << (shift + 1);
 637
 638         /* Round fragment number to something reasonable */
 639         if (channel->frag_num < FORTE_MIN_FRAGMENTS)
 640                 channel->frag_num = FORTE_MIN_FRAGMENTS;
 641
 642         if (channel->frag_num > FORTE_MAX_FRAGMENTS)
 643                 channel->frag_num = FORTE_MAX_FRAGMENTS;
 644
 645         channel->buf_sz = channel->frag_sz * channel->frag_num;
 646
 647         DPRINTK ("%s: %s frag_sz = %d, frag_num = %d, buf_sz = %d\n",
 648                  __FUNCTION__, channel->name, channel->frag_sz,
 649                  channel->frag_num, channel->buf_sz);
 650 }
 651
 652
 653 /**
 654  * forte_channel_prep:
 655  * @channel:    Channel whose buffer to prepare
 656  *
 657  * Locking:     Lock held.
 658  */
 659
 660 static void
 661 forte_channel_prep (struct forte_channel *channel)
 662 {
 663         struct page *page;
 664         int i;
 665
 666         if (channel->buf)
 667                 return;
 668
 669         forte_channel_buffer (channel, channel->frag_sz, channel->frag_num);
 670         channel->buf_pages = channel->buf_sz >> PAGE_SHIFT;
 671
 672         if (channel->buf_sz % PAGE_SIZE)
 673                 channel->buf_pages++;
 674
 675         DPRINTK ("%s: %s frag_sz = %d, frag_num = %d, buf_sz = %d, pg = %d\n",
 676                  __FUNCTION__, channel->name, channel->frag_sz,
 677                  channel->frag_num, channel->buf_sz, channel->buf_pages);
 678
 679         /* DMA buffer */
 680         channel->buf = pci_alloc_consistent (forte->pci_dev,
 681                                              channel->buf_pages * PAGE_SIZE,
 682                                              &channel->buf_handle);
 683
 684         if (!channel->buf || !channel->buf_handle)
 685                 BUG();
 686
 687         page = virt_to_page (channel->buf);
 688
 689         /* FIXME: can this go away ? */
 690         for (i = 0 ; i < channel->buf_pages ; i++)
 691                 SetPageReserved(page++);
 692
 693         /* Prep buffer registers */
 694         outw (channel->frag_sz - 1, channel->iobase + FORTE_PLY_COUNT);
 695         outl (channel->buf_handle, channel->iobase + FORTE_PLY_BUF1);
 696         outl (channel->buf_handle + channel->frag_sz,
 697               channel->iobase + FORTE_PLY_BUF2);
 698
 699         /* Reset hwptr */
 700         channel->hwptr = channel->frag_sz;
 701         channel->next_buf = 1;
 702
 703         DPRINTK ("%s: %s buffer @ %p (%p)\n", __FUNCTION__, channel->name,
 704                  channel->buf, channel->buf_handle);
 705 }
 706
 707
 708 /**
 709  * forte_channel_drain:
 710  * @chip:
 711  * @channel:
 712  *
 713  * Locking:     Don't hold the lock.
 714  */
 715
 716 static inline int
 717 forte_channel_drain (struct forte_channel *channel)
 718 {
 719         DECLARE_WAITQUEUE (wait, current);
 720         unsigned long flags;
 721
 722         DPRINTK ("%s\n", __FUNCTION__);
 723
 724         if (channel->mapped) {
 725                 spin_lock_irqsave (&forte->lock, flags);
 726                 forte_channel_stop (channel);
 727                 spin_unlock_irqrestore (&forte->lock, flags);
 728                 return 0;
 729         }
 730
 731         spin_lock_irqsave (&forte->lock, flags);
 732         add_wait_queue (&channel->wait, &wait);
 733
 734         for (;;) {
 735                 if (channel->active == 0 || channel->filled_frags == 1)
 736                         break;
 737
 738                 spin_unlock_irqrestore (&forte->lock, flags);
 739
 740                 __set_current_state (TASK_INTERRUPTIBLE);
 741                 schedule();
 742
 743                 spin_lock_irqsave (&forte->lock, flags);
 744         }
 745
 746         forte_channel_stop (channel);
 747         forte_channel_reset (channel);
 748         set_current_state (TASK_RUNNING);
 749         remove_wait_queue (&channel->wait, &wait);
 750         spin_unlock_irqrestore (&forte->lock, flags);
 751
 752         return 0;
 753 }
 754
 755
 756 /**
 757  * forte_channel_init:
 758  * @chip:       Forte chip instance the channel hangs off
 759  * @channel:    Channel to initialize
 760  *
 761  * Description:
 762  *              Initializes a channel, sets defaults, and allocates
 763  *              buffers.
 764  *
 765  * Locking:     No lock held.
 766  */
 767
 768 static int
 769 forte_channel_init (struct forte_chip *chip, struct forte_channel *channel)
 770 {
 771         DPRINTK ("%s: chip iobase @ %p\n", __FUNCTION__, (void *)chip->iobase);
 772
 773         spin_lock_irq (&chip->lock);
 774         memset (channel, 0x0, sizeof (*channel));
 775
 776         if (channel == &chip->play) {
 777                 channel->name = "PCM_OUT";
 778                 channel->iobase = chip->iobase;
 779                 DPRINTK ("%s: PCM-OUT iobase @ %p\n", __FUNCTION__,
 780                          (void *) channel->iobase);
 781         }
 782         else if (channel == &chip->rec) {
 783                 channel->name = "PCM_IN";
 784                 channel->iobase = chip->iobase + FORTE_CAP_OFFSET;
 785                 channel->record = 1;
 786                 DPRINTK ("%s: PCM-IN iobase @ %p\n", __FUNCTION__,
 787                          (void *) channel->iobase);
 788         }
 789         else
 790                 BUG();
 791
 792         init_waitqueue_head (&channel->wait);
 793
 794         /* Defaults: 48kHz, 16-bit, stereo */
 795         channel->ctrl = inw (channel->iobase + FORTE_PLY_CTRL);
 796         forte_channel_reset (channel);
 797         forte_channel_stereo (channel, 1);
 798         forte_channel_format (channel, AFMT_S16_LE);
 799         forte_channel_rate (channel, 48000);
 800         channel->frag_sz = FORTE_DEF_FRAG_SIZE;
 801         channel->frag_num = FORTE_DEF_FRAGMENTS;
 802
 803         chip->trigger = 0;
 804         spin_unlock_irq (&chip->lock);
 805
 806         return 0;
 807 }
 808
 809
 810 /**
 811  * forte_channel_free:
 812  * @chip:       Chip this channel hangs off
 813  * @channel:    Channel to nuke
 814  *
 815  * Description:
 816  *              Resets channel and frees buffers.
 817  *
 818  * Locking:     Hold your horses.
 819  */
 820
 821 static void
 822 forte_channel_free (struct forte_chip *chip, struct forte_channel *channel)
 823 {
 824         DPRINTK ("%s: %s\n", __FUNCTION__, channel->name);
 825
 826         if (!channel->buf_handle)
 827                 return;
 828
 829         pci_free_consistent (chip->pci_dev, channel->buf_pages * PAGE_SIZE,
 830                              channel->buf, channel->buf_handle);
 831
 832         memset (channel, 0x0, sizeof (*channel));
 833 }
 834
 835
 836 /* DSP --------------------------------------------------------------------- */
 837
 838
 839 /**
 840  * forte_dsp_ioctl:
 841  */
 842
 843 static int
 844 forte_dsp_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
 845                  unsigned long arg)
 846 {
 847         int ival=0, ret, rval=0, rd, wr, count;
 848         struct forte_chip *chip;
 849         struct audio_buf_info abi;
 850         struct count_info cinfo;
 851         void __user *argp = (void __user *)arg;
 852         int __user *p = argp;
 853
 854         chip = file->private_data;
 855
 856         if (file->f_mode & FMODE_WRITE)
 857                 wr = 1;
 858         else
 859                 wr = 0;
 860
 861         if (file->f_mode & FMODE_READ)
 862                 rd = 1;
 863         else
 864                 rd = 0;
 865
 866         switch (cmd) {
 867
 868         case OSS_GETVERSION:
 869                 return put_user (SOUND_VERSION, p);
 870
 871         case SNDCTL_DSP_GETCAPS:
 872                 DPRINTK ("%s: GETCAPS\n", __FUNCTION__);
 873
 874                 ival = FORTE_CAPS; /* DUPLEX */
 875                 return put_user (ival, p);
 876
 877         case SNDCTL_DSP_GETFMTS:
 878                 DPRINTK ("%s: GETFMTS\n", __FUNCTION__);
 879
 880                 ival = FORTE_FMTS; /* U8, 16LE */
 881                 return put_user (ival, p);
 882
 883         case SNDCTL_DSP_SETFMT: /* U8, 16LE */
 884                 DPRINTK ("%s: SETFMT\n", __FUNCTION__);
 885
 886                 if (get_user (ival, p))
 887                         return -EFAULT;
 888
 889                 spin_lock_irq (&chip->lock);
 890
 891                 if (rd) {
 892                         forte_channel_stop (&chip->rec);
 893                         rval = forte_channel_format (&chip->rec, ival);
 894                 }
 895
 896                 if (wr) {
 897                         forte_channel_stop (&chip->rec);
 898                         rval = forte_channel_format (&chip->play, ival);
 899                 }
 900
 901                 spin_unlock_irq (&chip->lock);
 902
 903                 return put_user (rval, p);
 904
 905         case SNDCTL_DSP_STEREO: /* 0 - mono, 1 - stereo */
 906                 DPRINTK ("%s: STEREO\n", __FUNCTION__);
 907
 908                 if (get_user (ival, p))
 909                         return -EFAULT;
 910
 911                 spin_lock_irq (&chip->lock);
 912
 913                 if (rd) {
 914                         forte_channel_stop (&chip->rec);
 915                         rval = forte_channel_stereo (&chip->rec, ival);
 916                 }
 917
 918                 if (wr) {
 919                         forte_channel_stop (&chip->rec);
 920                         rval = forte_channel_stereo (&chip->play, ival);
 921                 }
 922
 923                 spin_unlock_irq (&chip->lock);
 924
 925                 return put_user (rval, p);
 926
 927         case SNDCTL_DSP_CHANNELS: /* 1 - mono, 2 - stereo */
 928                 DPRINTK ("%s: CHANNELS\n", __FUNCTION__);
 929
 930                 if (get_user (ival, p))
 931                         return -EFAULT;
 932
 933                 spin_lock_irq (&chip->lock);
 934
 935                 if (rd) {
 936                         forte_channel_stop (&chip->rec);
 937                         rval = forte_channel_stereo (&chip->rec, ival-1) + 1;
 938                 }
 939
 940                 if (wr) {
 941                         forte_channel_stop (&chip->play);
 942                         rval = forte_channel_stereo (&chip->play, ival-1) + 1;
 943                 }
 944
 945                 spin_unlock_irq (&chip->lock);
 946
 947                 return put_user (rval, p);
 948
 949         case SNDCTL_DSP_SPEED:
 950                 DPRINTK ("%s: SPEED\n", __FUNCTION__);
 951
 952                 if (get_user (ival, p))
 953                         return -EFAULT;
 954
 955                 spin_lock_irq (&chip->lock);
 956
 957                 if (rd) {
 958                         forte_channel_stop (&chip->rec);
 959                         rval = forte_channel_rate (&chip->rec, ival);
 960                 }
 961
 962                 if (wr) {
 963                         forte_channel_stop (&chip->play);
 964                         rval = forte_channel_rate (&chip->play, ival);
 965                 }
 966
 967                 spin_unlock_irq (&chip->lock);
 968
 969                 return put_user(rval, p);
 970
 971         case SNDCTL_DSP_GETBLKSIZE:
 972                 DPRINTK ("%s: GETBLKSIZE\n", __FUNCTION__);
 973
 974                 spin_lock_irq (&chip->lock);
 975
 976                 if (rd)
 977                         ival = chip->rec.frag_sz;
 978
 979                 if (wr)
 980                         ival = chip->play.frag_sz;
 981
 982                 spin_unlock_irq (&chip->lock);
 983
 984                 return put_user (ival, p);
 985
 986         case SNDCTL_DSP_RESET:
 987                 DPRINTK ("%s: RESET\n", __FUNCTION__);
 988
 989                 spin_lock_irq (&chip->lock);
 990
 991                 if (rd)
 992                         forte_channel_reset (&chip->rec);
 993
 994                 if (wr)
 995                         forte_channel_reset (&chip->play);
 996
 997                 spin_unlock_irq (&chip->lock);
 998
 999                 return 0;
1000
1001         case SNDCTL_DSP_SYNC:
1002                 DPRINTK ("%s: SYNC\n", __FUNCTION__);
1003
1004                 if (wr)
1005                         ret = forte_channel_drain (&chip->play);
1006
1007                 return 0;
1008
1009         case SNDCTL_DSP_POST:
1010                 DPRINTK ("%s: POST\n", __FUNCTION__);
1011
1012                 if (wr) {
1013                         spin_lock_irq (&chip->lock);
1014
1015                         if (chip->play.filled_frags)
1016                                 forte_channel_start (&chip->play);
1017
1018                         spin_unlock_irq (&chip->lock);
1019                 }
1020
1021                 return 0;
1022
1023         case SNDCTL_DSP_SETFRAGMENT:
1024                 DPRINTK ("%s: SETFRAGMENT\n", __FUNCTION__);
1025
1026                 if (get_user (ival, p))
1027                         return -EFAULT;
1028
1029                 spin_lock_irq (&chip->lock);
1030
1031                 if (rd) {
1032                         forte_channel_buffer (&chip->rec, ival & 0xffff,
1033                                               (ival >> 16) & 0xffff);
1034                         ival = (chip->rec.frag_num << 16) + chip->rec.frag_sz;
1035                 }
1036
1037                 if (wr) {
1038                         forte_channel_buffer (&chip->play, ival & 0xffff,
1039                                               (ival >> 16) & 0xffff);
1040                         ival = (chip->play.frag_num << 16) +chip->play.frag_sz;
1041                 }
1042
1043                 spin_unlock_irq (&chip->lock);
1044
1045                 return put_user (ival, p);
1046
1047         case SNDCTL_DSP_GETISPACE:
1048                 DPRINTK ("%s: GETISPACE\n", __FUNCTION__);
1049
1050                 if (!rd)
1051                         return -EINVAL;
1052
1053                 spin_lock_irq (&chip->lock);
1054
1055                 abi.fragstotal = chip->rec.frag_num;
1056                 abi.fragsize = chip->rec.frag_sz;
1057
1058                 if (chip->rec.mapped) {
1059                         abi.fragments = chip->rec.frag_num - 2;
1060                         abi.bytes = abi.fragments * abi.fragsize;
1061                 }
1062                 else {
1063                         abi.fragments = chip->rec.filled_frags;
1064                         abi.bytes = abi.fragments * abi.fragsize;
1065                 }
1066
1067                 spin_unlock_irq (&chip->lock);
1068
1069                 return copy_to_user (argp, &abi, sizeof (abi)) ? -EFAULT : 0;
1070
1071         case SNDCTL_DSP_GETIPTR:
1072                 DPRINTK ("%s: GETIPTR\n", __FUNCTION__);
1073
1074                 if (!rd)
1075                         return -EINVAL;
1076
1077                 spin_lock_irq (&chip->lock);
1078
1079                 if (chip->rec.active)
1080                         cinfo.ptr = chip->rec.hwptr;
1081                 else
1082                         cinfo.ptr = 0;
1083
1084                 cinfo.bytes = chip->rec.bytes;
1085                 cinfo.blocks = chip->rec.nr_irqs;
1086                 chip->rec.nr_irqs = 0;
1087
1088                 spin_unlock_irq (&chip->lock);
1089
1090                 return copy_to_user (argp, &cinfo, sizeof (cinfo)) ? -EFAULT : 0;
1091
1092         case SNDCTL_DSP_GETOSPACE:
1093                 if (!wr)
1094                         return -EINVAL;
1095
1096                 spin_lock_irq (&chip->lock);
1097
1098                 abi.fragstotal = chip->play.frag_num;
1099                 abi.fragsize = chip->play.frag_sz;
1100
1101                 if (chip->play.mapped) {
1102                         abi.fragments = chip->play.frag_num - 2;
1103                         abi.bytes = chip->play.buf_sz;
1104                 }
1105                 else {
1106                         abi.fragments = chip->play.frag_num -
1107                                 chip->play.filled_frags;
1108
1109                         if (chip->play.residue)
1110                                 abi.fragments--;
1111
1112                         abi.bytes = abi.fragments * abi.fragsize +
1113                                 chip->play.residue;
1114                 }
1115
1116                 spin_unlock_irq (&chip->lock);
1117
1118                 return copy_to_user (argp, &abi, sizeof (abi)) ? -EFAULT : 0;
1119
1120         case SNDCTL_DSP_GETOPTR:
1121                 if (!wr)
1122                         return -EINVAL;
1123
1124                 spin_lock_irq (&chip->lock);
1125
1126                 if (chip->play.active)
1127                         cinfo.ptr = chip->play.hwptr;
1128                 else
1129                         cinfo.ptr = 0;
1130
1131                 cinfo.bytes = chip->play.bytes;
1132                 cinfo.blocks = chip->play.nr_irqs;
1133                 chip->play.nr_irqs = 0;
1134
1135                 spin_unlock_irq (&chip->lock);
1136
1137                 return copy_to_user (argp, &cinfo, sizeof (cinfo)) ? -EFAULT : 0;
1138
1139         case SNDCTL_DSP_GETODELAY:
1140                 if (!wr)
1141                         return -EINVAL;
1142
1143                 spin_lock_irq (&chip->lock);
1144
1145                 if (!chip->play.active) {
1146                         ival = 0;
1147                 }
1148                 else if (chip->play.mapped) {
1149                         count = inw (chip->play.iobase + FORTE_PLY_COUNT) + 1;
1150                         ival = chip->play.frag_sz - count;
1151                 }
1152                 else {
1153                         ival = chip->play.filled_frags * chip->play.frag_sz;
1154
1155                         if (chip->play.residue)
1156                                 ival += chip->play.frag_sz - chip->play.residue;
1157                 }
1158
1159                 spin_unlock_irq (&chip->lock);
1160
1161                 return put_user (ival, p);
1162
1163         case SNDCTL_DSP_SETDUPLEX:
1164                 DPRINTK ("%s: SETDUPLEX\n", __FUNCTION__);
1165
1166                 return -EINVAL;
1167
1168         case SNDCTL_DSP_GETTRIGGER:
1169                 DPRINTK ("%s: GETTRIGGER\n", __FUNCTION__);
1170
1171                 return put_user (chip->trigger, p);
1172
1173         case SNDCTL_DSP_SETTRIGGER:
1174
1175                 if (get_user (ival, p))
1176                         return -EFAULT;
1177
1178                 DPRINTK ("%s: SETTRIGGER %d\n", __FUNCTION__, ival);
1179
1180                 if (wr) {
1181                         spin_lock_irq (&chip->lock);
1182
1183                         if (ival & PCM_ENABLE_OUTPUT)
1184                                 forte_channel_start (&chip->play);
1185                         else {
1186                                 chip->trigger = 1;
1187                                 forte_channel_prep (&chip->play);
1188                                 forte_channel_stop (&chip->play);
1189                         }
1190
1191                         spin_unlock_irq (&chip->lock);
1192                 }
1193                 else if (rd) {
1194                         spin_lock_irq (&chip->lock);
1195
1196                         if (ival & PCM_ENABLE_INPUT)
1197                                 forte_channel_start (&chip->rec);
1198                         else {
1199                                 chip->trigger = 1;
1200                                 forte_channel_prep (&chip->rec);
1201                                 forte_channel_stop (&chip->rec);
1202                         }
1203
1204                         spin_unlock_irq (&chip->lock);
1205                 }
1206
1207                 return 0;
1208
1209         case SOUND_PCM_READ_RATE:
1210                 DPRINTK ("%s: PCM_READ_RATE\n", __FUNCTION__);
1211                 return put_user (chip->play.rate, p);
1212
1213         case SOUND_PCM_READ_CHANNELS:
1214                 DPRINTK ("%s: PCM_READ_CHANNELS\n", __FUNCTION__);
1215                 return put_user (chip->play.stereo, p);
1216
1217         case SOUND_PCM_READ_BITS:
1218                 DPRINTK ("%s: PCM_READ_BITS\n", __FUNCTION__);
1219                 return put_user (chip->play.format, p);
1220
1221         case SNDCTL_DSP_NONBLOCK:
1222                 DPRINTK ("%s: DSP_NONBLOCK\n", __FUNCTION__);
1223                 file->f_flags |= O_NONBLOCK;
1224                 return 0;
1225
1226         default:
1227                 DPRINTK ("Unsupported ioctl: %x (%p)\n", cmd, argp);
1228                 break;
1229         }
1230
1231         return -EINVAL;
1232 }
1233
1234
1235 /**
1236  * forte_dsp_open:
1237  */
1238
1239 static int
1240 forte_dsp_open (struct inode *inode, struct file *file)
1241 {
1242         struct forte_chip *chip = forte; /* FIXME: HACK FROM HELL! */
1243
1244         if (file->f_flags & O_NONBLOCK) {
1245                 if (!mutex_trylock(&chip->open_mutex)) {
1246                         DPRINTK ("%s: returning -EAGAIN\n", __FUNCTION__);
1247                         return -EAGAIN;
1248                 }
1249         }
1250         else {
1251                 if (mutex_lock_interruptible(&chip->open_mutex)) {
1252                         DPRINTK ("%s: returning -ERESTARTSYS\n", __FUNCTION__);
1253                         return -ERESTARTSYS;
1254                 }
1255         }
1256
1257         file->private_data = forte;
1258
1259         DPRINTK ("%s: dsp opened by %d\n", __FUNCTION__, current->pid);
1260
1261         if (file->f_mode & FMODE_WRITE)
1262                 forte_channel_init (forte, &forte->play);
1263
1264         if (file->f_mode & FMODE_READ)
1265                 forte_channel_init (forte, &forte->rec);
1266
1267         return nonseekable_open(inode, file);
1268 }
1269
1270
1271 /**
1272  * forte_dsp_release:
1273  */
1274
1275 static int
1276 forte_dsp_release (struct inode *inode, struct file *file)
1277 {
1278         struct forte_chip *chip = file->private_data;
1279         int ret = 0;
1280
1281         DPRINTK ("%s: chip @ %p\n", __FUNCTION__, chip);
1282
1283         if (file->f_mode & FMODE_WRITE) {
1284                 forte_channel_drain (&chip->play);
1285
1286                 spin_lock_irq (&chip->lock);
1287
1288                 forte_channel_free (chip, &chip->play);
1289
1290                 spin_unlock_irq (&chip->lock);
1291         }
1292
1293         if (file->f_mode & FMODE_READ) {
1294                 while (chip->rec.filled_frags > 0)
1295                         interruptible_sleep_on (&chip->rec.wait);
1296
1297                 spin_lock_irq (&chip->lock);
1298
1299                 forte_channel_stop (&chip->rec);
1300                 forte_channel_free (chip, &chip->rec);
1301
1302                 spin_unlock_irq (&chip->lock);
1303         }
1304
1305         mutex_unlock(&chip->open_mutex);
1306
1307         return ret;
1308 }
1309
1310
1311 /**
1312  * forte_dsp_poll:
1313  *
1314  */
1315
1316 static unsigned int
1317 forte_dsp_poll (struct file *file, struct poll_table_struct *wait)
1318 {
1319         struct forte_chip *chip;
1320         struct forte_channel *channel;
1321         unsigned int mask = 0;
1322
1323         chip = file->private_data;
1324
1325         if (file->f_mode & FMODE_WRITE) {
1326                 channel = &chip->play;
1327
1328                 if (channel->active)
1329                         poll_wait (file, &channel->wait, wait);
1330
1331                 spin_lock_irq (&chip->lock);
1332
1333                 if (channel->frag_num - channel->filled_frags > 0)
1334                         mask |= POLLOUT | POLLWRNORM;
1335
1336                 spin_unlock_irq (&chip->lock);
1337         }
1338
1339         if (file->f_mode & FMODE_READ) {
1340                 channel = &chip->rec;
1341
1342                 if (channel->active)
1343                         poll_wait (file, &channel->wait, wait);
1344
1345                 spin_lock_irq (&chip->lock);
1346
1347                 if (channel->filled_frags > 0)
1348                         mask |= POLLIN | POLLRDNORM;
1349
1350                 spin_unlock_irq (&chip->lock);
1351         }
1352
1353         return mask;
1354 }
1355
1356
1357 /**
1358  * forte_dsp_mmap:
1359  */
1360
1361 static int
1362 forte_dsp_mmap (struct file *file, struct vm_area_struct *vma)
1363 {
1364         struct forte_chip *chip;
1365         struct forte_channel *channel;
1366         unsigned long size;
1367         int ret;
1368
1369         chip = file->private_data;
1370
1371         DPRINTK ("%s: start %lXh, size %ld, pgoff %ld\n", __FUNCTION__,
1372                  vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_pgoff);
1373
1374         spin_lock_irq (&chip->lock);
1375
1376         if (vma->vm_flags & VM_WRITE && chip->play.active) {
1377                 ret = -EBUSY;
1378                 goto out;
1379         }
1380
1381         if (vma->vm_flags & VM_READ && chip->rec.active) {
1382                 ret = -EBUSY;
1383                 goto out;
1384         }
1385
1386         if (file->f_mode & FMODE_WRITE)
1387                 channel = &chip->play;
1388         else if (file->f_mode & FMODE_READ)
1389                 channel = &chip->rec;
1390         else {
1391                 ret = -EINVAL;
1392                 goto out;
1393         }
1394
1395         forte_channel_prep (channel);
1396         channel->mapped = 1;
1397
1398         if (vma->vm_pgoff != 0) {
1399                 ret = -EINVAL;
1400                 goto out;
1401         }
1402
1403         size = vma->vm_end - vma->vm_start;
1404
1405         if (size > channel->buf_pages * PAGE_SIZE) {
1406                 DPRINTK ("%s: size (%ld) > buf_sz (%d) \n", __FUNCTION__,
1407                          size, channel->buf_sz);
1408                 ret = -EINVAL;
1409                 goto out;
1410         }
1411
1412         if (remap_pfn_range(vma, vma->vm_start,
1413                               virt_to_phys(channel->buf) >> PAGE_SHIFT,
1414                               size, vma->vm_page_prot)) {
1415                 DPRINTK ("%s: remap el a no worko\n", __FUNCTION__);
1416                 ret = -EAGAIN;
1417                 goto out;
1418         }
1419
1420         ret = 0;
1421
1422  out:
1423         spin_unlock_irq (&chip->lock);
1424         return ret;
1425 }
1426
1427
1428 /**
1429  * forte_dsp_write:
1430  */
1431
1432 static ssize_t
1433 forte_dsp_write (struct file *file, const char __user *buffer, size_t bytes,
1434                  loff_t *ppos)
1435 {
1436         struct forte_chip *chip;
1437         struct forte_channel *channel;
1438         unsigned int i = bytes, sz = 0;
1439         unsigned long flags;
1440
1441         if (!access_ok (VERIFY_READ, buffer, bytes))
1442                 return -EFAULT;
1443
1444         chip = (struct forte_chip *) file->private_data;
1445
1446         if (!chip)
1447                 BUG();
1448
1449         channel = &chip->play;
1450
1451         if (!channel)
1452                 BUG();
1453
1454         spin_lock_irqsave (&chip->lock, flags);
1455
1456         /* Set up buffers with the right fragment size */
1457         forte_channel_prep (channel);
1458
1459         while (i) {
1460                 /* All fragment buffers in use -> wait */
1461                 if (channel->frag_num - channel->filled_frags == 0) {
1462                         DECLARE_WAITQUEUE (wait, current);
1463
1464                         /* For trigger or non-blocking operation, get out */
1465                         if (chip->trigger || file->f_flags & O_NONBLOCK) {
1466                                 spin_unlock_irqrestore (&chip->lock, flags);
1467                                 return -EAGAIN;
1468                         }
1469
1470                         /* Otherwise wait for buffers */
1471                         add_wait_queue (&channel->wait, &wait);
1472
1473                         for (;;) {
1474                                 spin_unlock_irqrestore (&chip->lock, flags);
1475
1476                                 set_current_state (TASK_INTERRUPTIBLE);
1477                                 schedule();
1478
1479                                 spin_lock_irqsave (&chip->lock, flags);
1480
1481                                 if (channel->frag_num - channel->filled_frags)
1482                                         break;
1483                         }
1484
1485                         remove_wait_queue (&channel->wait, &wait);
1486                         set_current_state (TASK_RUNNING);
1487
1488                         if (signal_pending (current)) {
1489                                 spin_unlock_irqrestore (&chip->lock, flags);
1490                                 return -ERESTARTSYS;
1491                         }
1492                 }
1493
1494                 if (channel->residue)
1495                         sz = channel->residue;
1496                 else if (i > channel->frag_sz)
1497                         sz = channel->frag_sz;
1498                 else
1499                         sz = i;
1500
1501                 spin_unlock_irqrestore (&chip->lock, flags);
1502
1503                 if (copy_from_user ((void *) channel->buf + channel->swptr, buffer, sz))
1504                         return -EFAULT;
1505
1506                 spin_lock_irqsave (&chip->lock, flags);
1507
1508                 /* Advance software pointer */
1509                 buffer += sz;
1510                 channel->swptr += sz;
1511                 channel->swptr %= channel->buf_sz;
1512                 i -= sz;
1513
1514                 /* Only bump filled_frags if a full fragment has been written */
1515                 if (channel->swptr % channel->frag_sz == 0) {
1516                         channel->filled_frags++;
1517                         channel->residue = 0;
1518                 }
1519                 else
1520                         channel->residue = channel->frag_sz - sz;
1521
1522                 /* If playback isn't active, start it */
1523                 if (channel->active == 0 && chip->trigger == 0)
1524                         forte_channel_start (channel);
1525         }
1526
1527         spin_unlock_irqrestore (&chip->lock, flags);
1528
1529         return bytes - i;
1530 }
1531
1532
1533 /**
1534  * forte_dsp_read:
1535  */
1536
1537 static ssize_t
1538 forte_dsp_read (struct file *file, char __user *buffer, size_t bytes,
1539                 loff_t *ppos)
1540 {
1541         struct forte_chip *chip;
1542         struct forte_channel *channel;
1543         unsigned int i = bytes, sz;
1544         unsigned long flags;
1545
1546         if (!access_ok (VERIFY_WRITE, buffer, bytes))
1547                 return -EFAULT;
1548
1549         chip = (struct forte_chip *) file->private_data;
1550
1551         if (!chip)
1552                 BUG();
1553
1554         channel = &chip->rec;
1555
1556         if (!channel)
1557                 BUG();
1558
1559         spin_lock_irqsave (&chip->lock, flags);
1560
1561         /* Set up buffers with the right fragment size */
1562         forte_channel_prep (channel);
1563
1564         /* Start recording */
1565         if (!chip->trigger)
1566                 forte_channel_start (channel);
1567
1568         while (i) {
1569                 /* No fragment buffers in use -> wait */
1570                 if (channel->filled_frags == 0) {
1571                         DECLARE_WAITQUEUE (wait, current);
1572
1573                         /* For trigger mode operation, get out */
1574                         if (chip->trigger) {
1575                                 spin_unlock_irqrestore (&chip->lock, flags);
1576                                 return -EAGAIN;
1577                         }
1578
1579                         add_wait_queue (&channel->wait, &wait);
1580
1581                         for (;;) {
1582                                 if (channel->active == 0)
1583                                         break;
1584
1585                                 if (channel->filled_frags)
1586                                         break;
1587
1588                                 spin_unlock_irqrestore (&chip->lock, flags);
1589
1590                                 set_current_state (TASK_INTERRUPTIBLE);
1591                                 schedule();
1592
1593                                 spin_lock_irqsave (&chip->lock, flags);
1594                         }
1595
1596                         set_current_state (TASK_RUNNING);
1597                         remove_wait_queue (&channel->wait, &wait);
1598                 }
1599
1600                 if (i > channel->frag_sz)
1601                         sz = channel->frag_sz;
1602                 else
1603                         sz = i;
1604
1605                 spin_unlock_irqrestore (&chip->lock, flags);
1606
1607                 if (copy_to_user (buffer, (void *)channel->buf+channel->swptr, sz)) {
1608                         DPRINTK ("%s: copy_to_user failed\n", __FUNCTION__);
1609                         return -EFAULT;
1610                 }
1611
1612                 spin_lock_irqsave (&chip->lock, flags);
1613
1614                 /* Advance software pointer */
1615                 buffer += sz;
1616                 if (channel->filled_frags > 0)
1617                         channel->filled_frags--;
1618                 channel->swptr += channel->frag_sz;
1619                 channel->swptr %= channel->buf_sz;
1620                 i -= sz;
1621         }
1622
1623         spin_unlock_irqrestore (&chip->lock, flags);
1624
1625         return bytes - i;
1626 }
1627
1628
1629 static struct file_operations forte_dsp_fops = {
1630         .owner                  = THIS_MODULE,
1631         .llseek                 = &no_llseek,
1632         .read                   = &forte_dsp_read,
1633         .write                  = &forte_dsp_write,
1634         .poll                   = &forte_dsp_poll,
1635         .ioctl                  = &forte_dsp_ioctl,
1636         .open                   = &forte_dsp_open,
1637         .release                = &forte_dsp_release,
1638         .mmap                   = &forte_dsp_mmap,
1639 };
1640
1641
1642 /* Common ------------------------------------------------------------------ */
1643
1644
1645 /**
1646  * forte_interrupt:
1647  */
1648
1649 static irqreturn_t
1650 forte_interrupt (int irq, void *dev_id, struct pt_regs *regs)
1651 {
1652         struct forte_chip *chip = dev_id;
1653         struct forte_channel *channel = NULL;
1654         u16 status, count;
1655
1656         status = inw (chip->iobase + FORTE_IRQ_STATUS);
1657
1658         /* If this is not for us, get outta here ASAP */
1659         if ((status & (FORTE_IRQ_PLAYBACK | FORTE_IRQ_CAPTURE)) == 0)
1660                 return IRQ_NONE;
1661
1662         if (status & FORTE_IRQ_PLAYBACK) {
1663                 channel = &chip->play;
1664
1665                 spin_lock (&chip->lock);
1666
1667                 if (channel->frag_sz == 0)
1668                         goto pack;
1669
1670                 /* Declare a fragment done */
1671                 if (channel->filled_frags > 0)
1672                         channel->filled_frags--;
1673                 channel->bytes += channel->frag_sz;
1674                 channel->nr_irqs++;
1675
1676                 /* Flip-flop between buffer I and II */
1677                 channel->next_buf ^= 1;
1678
1679                 /* Advance hardware pointer by fragment size and wrap around */
1680                 channel->hwptr += channel->frag_sz;
1681                 channel->hwptr %= channel->buf_sz;
1682
1683                 /* Buffer I or buffer II BAR */
1684                 outl (channel->buf_handle + channel->hwptr,
1685                       channel->next_buf == 0 ?
1686                       channel->iobase + FORTE_PLY_BUF1 :
1687                       channel->iobase + FORTE_PLY_BUF2);
1688
1689                 /* If the currently playing fragment is last, schedule pause */
1690                 if (channel->filled_frags == 1)
1691                         forte_channel_pause (channel);
1692
1693         pack:
1694                 /* Acknowledge interrupt */
1695                 outw (FORTE_IRQ_PLAYBACK, chip->iobase + FORTE_IRQ_STATUS);
1696
1697                 if (waitqueue_active (&channel->wait))
1698                         wake_up_all (&channel->wait);
1699
1700                 spin_unlock (&chip->lock);
1701         }
1702
1703         if (status & FORTE_IRQ_CAPTURE) {
1704                 channel = &chip->rec;
1705                 spin_lock (&chip->lock);
1706
1707                 /* One fragment filled */
1708                 channel->filled_frags++;
1709
1710                 /* Get # of completed bytes */
1711                 count = inw (channel->iobase + FORTE_PLY_COUNT) + 1;
1712
1713                 if (count == 0) {
1714                         DPRINTK ("%s: last, filled_frags = %d\n", __FUNCTION__,
1715                                  channel->filled_frags);
1716                         channel->filled_frags = 0;
1717                         goto rack;
1718                 }
1719
1720                 /* Buffer I or buffer II BAR */
1721                 outl (channel->buf_handle + channel->hwptr,
1722                       channel->next_buf == 0 ?
1723                       channel->iobase + FORTE_PLY_BUF1 :
1724                       channel->iobase + FORTE_PLY_BUF2);
1725
1726                 /* Flip-flop between buffer I and II */
1727                 channel->next_buf ^= 1;
1728
1729                 /* Advance hardware pointer by fragment size and wrap around */
1730                 channel->hwptr += channel->frag_sz;
1731                 channel->hwptr %= channel->buf_sz;
1732
1733                 /* Out of buffers */
1734                 if (channel->filled_frags == channel->frag_num - 1)
1735                         forte_channel_stop (channel);
1736         rack:
1737                 /* Acknowledge interrupt */
1738                 outw (FORTE_IRQ_CAPTURE, chip->iobase + FORTE_IRQ_STATUS);
1739
1740                 spin_unlock (&chip->lock);
1741
1742                 if (waitqueue_active (&channel->wait))
1743                         wake_up_all (&channel->wait);
1744         }
1745
1746         return IRQ_HANDLED;
1747 }
1748
1749
1750 /**
1751  * forte_proc_read:
1752  */
1753
1754 static int
1755 forte_proc_read (char *page, char **start, off_t off, int count,
1756                  int *eof, void *data)
1757 {
1758         int i = 0, p_rate, p_chan, r_rate;
1759         unsigned short p_reg, r_reg;
1760
1761         i += sprintf (page, "ForteMedia FM801 OSS Lite driver\n%s\n \n",
1762                       DRIVER_VERSION);
1763
1764         if (!forte->iobase)
1765                 return i;
1766
1767         p_rate = p_chan = -1;
1768         p_reg  = inw (forte->iobase + FORTE_PLY_CTRL);
1769         p_rate = (p_reg >> 8) & 15;
1770         p_chan = (p_reg >> 12) & 3;
1771
1772         if (p_rate >= 0 || p_rate <= 10)
1773                 p_rate = rates[p_rate];
1774
1775         if (p_chan >= 0 || p_chan <= 2)
1776                 p_chan = channels[p_chan];
1777
1778         r_rate = -1;
1779         r_reg  = inw (forte->iobase + FORTE_CAP_CTRL);
1780         r_rate = (r_reg >> 8) & 15;
1781
1782         if (r_rate >= 0 || r_rate <= 10)
1783                 r_rate = rates[r_rate];
1784
1785         i += sprintf (page + i,
1786                       "             Playback  Capture\n"
1787                       "FIFO empty : %-3s       %-3s\n"
1788                       "Buf1 Last  : %-3s       %-3s\n"
1789                       "Buf2 Last  : %-3s       %-3s\n"
1790                       "Started    : %-3s       %-3s\n"
1791                       "Paused     : %-3s       %-3s\n"
1792                       "Immed Stop : %-3s       %-3s\n"
1793                       "Rate       : %-5d     %-5d\n"
1794                       "Channels   : %-5d     -\n"
1795                       "16-bit     : %-3s       %-3s\n"
1796                       "Stereo     : %-3s       %-3s\n"
1797                       " \n"
1798                       "Buffer Sz  : %-6d    %-6d\n"
1799                       "Frag Sz    : %-6d    %-6d\n"
1800                       "Frag Num   : %-6d    %-6d\n"
1801                       "Frag msecs : %-6d    %-6d\n"
1802                       "Used Frags : %-6d    %-6d\n"
1803                       "Mapped     : %-3s       %-3s\n",
1804                       p_reg & 1<<0  ? "yes" : "no",
1805                       r_reg & 1<<0  ? "yes" : "no",
1806                       p_reg & 1<<1  ? "yes" : "no",
1807                       r_reg & 1<<1  ? "yes" : "no",
1808                       p_reg & 1<<2  ? "yes" : "no",
1809                       r_reg & 1<<2  ? "yes" : "no",
1810                       p_reg & 1<<5  ? "yes" : "no",
1811                       r_reg & 1<<5  ? "yes" : "no",
1812                       p_reg & 1<<6  ? "yes" : "no",
1813                       r_reg & 1<<6  ? "yes" : "no",
1814                       p_reg & 1<<7  ? "yes" : "no",
1815                       r_reg & 1<<7  ? "yes" : "no",
1816                       p_rate, r_rate,
1817                       p_chan,
1818                       p_reg & 1<<14 ? "yes" : "no",
1819                       r_reg & 1<<14 ? "yes" : "no",
1820                       p_reg & 1<<15 ? "yes" : "no",
1821                       r_reg & 1<<15 ? "yes" : "no",
1822                       forte->play.buf_sz,       forte->rec.buf_sz,
1823                       forte->play.frag_sz,      forte->rec.frag_sz,
1824                       forte->play.frag_num,     forte->rec.frag_num,
1825                       forte->play.frag_msecs,   forte->rec.frag_msecs,
1826                       forte->play.filled_frags, forte->rec.filled_frags,
1827                       forte->play.mapped ? "yes" : "no",
1828                       forte->rec.mapped ? "yes" : "no"
1829                 );
1830
1831         return i;
1832 }
1833
1834
1835 /**
1836  * forte_proc_init:
1837  *
1838  * Creates driver info entries in /proc
1839  */
1840
1841 static int __init
1842 forte_proc_init (void)
1843 {
1844         if (!proc_mkdir ("driver/forte", NULL))
1845                 return -EIO;
1846
1847         if (!create_proc_read_entry ("driver/forte/chip", 0, NULL, forte_proc_read, forte)) {
1848                 remove_proc_entry ("driver/forte", NULL);
1849                 return -EIO;
1850         }
1851
1852         if (!create_proc_read_entry("driver/forte/ac97", 0, NULL, ac97_read_proc, forte->ac97)) {
1853                 remove_proc_entry ("driver/forte/chip", NULL);
1854                 remove_proc_entry ("driver/forte", NULL);
1855                 return -EIO;
1856         }
1857
1858         return 0;
1859 }
1860
1861
1862 /**
1863  * forte_proc_remove:
1864  *
1865  * Removes driver info entries in /proc
1866  */
1867
1868 static void
1869 forte_proc_remove (void)
1870 {
1871         remove_proc_entry ("driver/forte/ac97", NULL);
1872         remove_proc_entry ("driver/forte/chip", NULL);
1873         remove_proc_entry ("driver/forte", NULL);
1874 }
1875
1876
1877 /**
1878  * forte_chip_init:
1879  * @chip:       Chip instance to initialize
1880  *
1881  * Description:
1882  *              Resets chip, configures codec and registers the driver with
1883  *              the sound subsystem.
1884  *
1885  *              Press and hold Start for 8 secs, then switch on Run
1886  *              and hold for 4 seconds.  Let go of Start.  Numbers
1887  *              assume a properly oiled TWG.
1888  */
1889
1890 static int __devinit
1891 forte_chip_init (struct forte_chip *chip)
1892 {
1893         u8 revision;
1894         u16 cmdw;
1895         struct ac97_codec *codec;
1896
1897         pci_read_config_byte (chip->pci_dev, PCI_REVISION_ID, &revision);
1898
1899         if (revision >= 0xB1) {
1900                 chip->multichannel = 1;
1901                 printk (KERN_INFO PFX "Multi-channel device detected.\n");
1902         }
1903
1904         /* Reset chip */
1905         outw (FORTE_CC_CODEC_RESET | FORTE_CC_AC97_RESET,
1906               chip->iobase + FORTE_CODEC_CTRL);
1907         udelay(100);
1908         outw (0, chip->iobase + FORTE_CODEC_CTRL);
1909
1910         /* Request read from AC97 */
1911         outw (FORTE_AC97_READ | (0 << FORTE_AC97_ADDR_SHIFT),
1912               chip->iobase + FORTE_AC97_CMD);
1913         mdelay(750);
1914
1915         if ((inw (chip->iobase + FORTE_AC97_CMD) & (3<<8)) != (1<<8)) {
1916                 printk (KERN_INFO PFX "AC97 codec not responding");
1917                 return -EIO;
1918         }
1919
1920         /* Init volume */
1921         outw (0x0808, chip->iobase + FORTE_PCM_VOL);
1922         outw (0x9f1f, chip->iobase + FORTE_FM_VOL);
1923         outw (0x8808, chip->iobase + FORTE_I2S_VOL);
1924
1925         /* I2S control - I2S mode */
1926         outw (0x0003, chip->iobase + FORTE_I2S_MODE);
1927
1928         /* Interrupt setup - unmask PLAYBACK & CAPTURE */
1929         cmdw = inw (chip->iobase + FORTE_IRQ_MASK);
1930         cmdw &= ~0x0003;
1931         outw (cmdw, chip->iobase + FORTE_IRQ_MASK);
1932
1933         /* Interrupt clear */
1934         outw (FORTE_IRQ_PLAYBACK|FORTE_IRQ_CAPTURE,
1935               chip->iobase + FORTE_IRQ_STATUS);
1936
1937         /* Set up the AC97 codec */
1938         if ((codec = ac97_alloc_codec()) == NULL)
1939                 return -ENOMEM;
1940         codec->private_data = chip;
1941         codec->codec_read = forte_ac97_read;
1942         codec->codec_write = forte_ac97_write;
1943         codec->id = 0;
1944
1945         if (ac97_probe_codec (codec) == 0) {
1946                 printk (KERN_ERR PFX "codec probe failed\n");
1947                 ac97_release_codec(codec);
1948                 return -1;
1949         }
1950
1951         /* Register mixer */
1952         if ((codec->dev_mixer =
1953              register_sound_mixer (&forte_mixer_fops, -1)) < 0) {
1954                 printk (KERN_ERR PFX "couldn't register mixer!\n");
1955                 ac97_release_codec(codec);
1956                 return -1;
1957         }
1958
1959         chip->ac97 = codec;
1960
1961         /* Register DSP */
1962         if ((chip->dsp = register_sound_dsp (&forte_dsp_fops, -1) ) < 0) {
1963                 printk (KERN_ERR PFX "couldn't register dsp!\n");
1964                 return -1;
1965         }
1966
1967         /* Register with /proc */
1968         if (forte_proc_init()) {
1969                 printk (KERN_ERR PFX "couldn't add entries to /proc!\n");
1970                 return -1;
1971         }
1972
1973         return 0;
1974 }
1975
1976
1977 /**
1978  * forte_probe:
1979  * @pci_dev:    PCI struct for probed device
1980  * @pci_id:
1981  *
1982  * Description:
1983  *              Allocates chip instance, I/O region, and IRQ
1984  */
1985 static int __init
1986 forte_probe (struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
1987 {
1988         struct forte_chip *chip;
1989         int ret = 0;
1990
1991         /* FIXME: Support more than one chip */
1992         if (found++)
1993                 return -EIO;
1994
1995         /* Ignition */
1996         if (pci_enable_device (pci_dev))
1997                 return -EIO;
1998
1999         pci_set_master (pci_dev);
2000
2001         /* Allocate chip instance and configure */
2002         forte = (struct forte_chip *)
2003                 kmalloc (sizeof (struct forte_chip), GFP_KERNEL);
2004         chip = forte;
2005
2006         if (chip == NULL) {
2007                 printk (KERN_WARNING PFX "Out of memory");
2008                 return -ENOMEM;
2009         }
2010
2011         memset (chip, 0, sizeof (struct forte_chip));
2012         chip->pci_dev = pci_dev;
2013
2014         mutex_init(&chip->open_mutex);
2015         spin_lock_init (&chip->lock);
2016         spin_lock_init (&chip->ac97_lock);
2017
2018         if (! request_region (pci_resource_start (pci_dev, 0),
2019                               pci_resource_len (pci_dev, 0), DRIVER_NAME)) {
2020                 printk (KERN_WARNING PFX "Unable to reserve I/O space");
2021                 ret = -ENOMEM;
2022                 goto error;
2023         }
2024
2025         chip->iobase = pci_resource_start (pci_dev, 0);
2026         chip->irq = pci_dev->irq;
2027
2028         if (request_irq (chip->irq, forte_interrupt, IRQF_SHARED, DRIVER_NAME,
2029                          chip)) {
2030                 printk (KERN_WARNING PFX "Unable to reserve IRQ");
2031                 ret = -EIO;
2032                 goto error;
2033         }
2034
2035         pci_set_drvdata (pci_dev, chip);
2036
2037         printk (KERN_INFO PFX "FM801 chip found at 0x%04lX-0x%16llX IRQ %u\n",
2038                 chip->iobase, (unsigned long long)pci_resource_end (pci_dev, 0),
2039                 chip->irq);
2040
2041         /* Power it up */
2042         if ((ret = forte_chip_init (chip)) == 0)
2043                 return 0;
2044
2045  error:
2046         if (chip->irq)
2047                 free_irq (chip->irq, chip);
2048
2049         if (chip->iobase)
2050                 release_region (pci_resource_start (pci_dev, 0),
2051                                 pci_resource_len (pci_dev, 0));
2052
2053         kfree (chip);
2054
2055         return ret;
2056 }
2057
2058
2059 /**
2060  * forte_remove:
2061  * @pci_dev:    PCI device to unclaim
2062  *
2063  */
2064
2065 static void
2066 forte_remove (struct pci_dev *pci_dev)
2067 {
2068         struct forte_chip *chip = pci_get_drvdata (pci_dev);
2069
2070         if (chip == NULL)
2071                 return;
2072
2073         /* Turn volume down to avoid popping */
2074         outw (0x1f1f, chip->iobase + FORTE_PCM_VOL);
2075         outw (0x1f1f, chip->iobase + FORTE_FM_VOL);
2076         outw (0x1f1f, chip->iobase + FORTE_I2S_VOL);
2077
2078         forte_proc_remove();
2079         free_irq (chip->irq, chip);
2080         release_region (chip->iobase, pci_resource_len (pci_dev, 0));
2081
2082         unregister_sound_dsp (chip->dsp);
2083         unregister_sound_mixer (chip->ac97->dev_mixer);
2084         ac97_release_codec(chip->ac97);
2085         kfree (chip);
2086
2087         printk (KERN_INFO PFX "driver released\n");
2088 }
2089
2090
2091 static struct pci_device_id forte_pci_ids[] = {
2092         { 0x1319, 0x0801, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
2093         { 0, }
2094 };
2095
2096
2097 static struct pci_driver forte_pci_driver = {
2098         .name                   = DRIVER_NAME,
2099         .id_table               = forte_pci_ids,
2100         .probe                  = forte_probe,
2101         .remove                 = forte_remove,
2102
2103 };
2104
2105
2106 /**
2107  * forte_init_module:
2108  *
2109  */
2110
2111 static int __init
2112 forte_init_module (void)
2113 {
2114         printk (KERN_INFO PFX DRIVER_VERSION "\n");
2115
2116         return pci_register_driver (&forte_pci_driver);
2117 }
2118
2119
2120 /**
2121  * forte_cleanup_module:
2122  *
2123  */
2124
2125 static void __exit
2126 forte_cleanup_module (void)
2127 {
2128         pci_unregister_driver (&forte_pci_driver);
2129 }
2130
2131
2132 module_init(forte_init_module);
2133 module_exit(forte_cleanup_module);
2134
2135 MODULE_AUTHOR("Martin K. Petersen <mkp@mkp.net>");
2136 MODULE_DESCRIPTION("ForteMedia FM801 OSS Driver");
2137 MODULE_LICENSE("GPL");
2138 MODULE_DEVICE_TABLE (pci, forte_pci_ids);