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