sound/oss/trident.c

   1 /*
   2  *      OSS driver for Linux 2.[46].x for
   3  *
   4  *      Trident 4D-Wave
   5  *      SiS 7018
   6  *      ALi 5451
   7  *      Tvia/IGST CyberPro 5050
   8  *
   9  *      Driver: Alan Cox <alan@redhat.com>
  10  *
  11  *  Built from:
  12  *      Low level code: <audio@tridentmicro.com> from ALSA
  13  *      Framework: Thomas Sailer <sailer@ife.ee.ethz.ch>
  14  *      Extended by: Zach Brown <zab@redhat.com>
  15  *
  16  *  Hacked up by:
  17  *      Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  18  *      Ollie Lho <ollie@sis.com.tw> SiS 7018 Audio Core Support
  19  *      Ching-Ling Lee <cling-li@ali.com.tw> ALi 5451 Audio Core Support
  20  *      Matt Wu <mattwu@acersoftech.com.cn> ALi 5451 Audio Core Support
  21  *      Peter Wächtler <pwaechtler@loewe-komp.de> CyberPro5050 support
  22  *      Muli Ben-Yehuda <mulix@mulix.org>
  23  *
  24  *
  25  *      This program is free software; you can redistribute it and/or modify
  26  *      it under the terms of the GNU General Public License as published by
  27  *      the Free Software Foundation; either version 2 of the License, or
  28  *      (at your option) any later version.
  29  *
  30  *      This program is distributed in the hope that it will be useful,
  31  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  32  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33  *      GNU General Public License for more details.
  34  *
  35  *      You should have received a copy of the GNU General Public License
  36  *      along with this program; if not, write to the Free Software
  37  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  38  *
  39  *  History
  40  *  v0.14.10j
  41  *      January 3 2004 Eugene Teo <eugeneteo@eugeneteo.net>
  42  *      minor cleanup to use pr_debug instead of TRDBG since it is already
  43  *      defined in linux/kernel.h.
  44  *  v0.14.10i
  45  *      December 29 2003 Muli Ben-Yehuda <mulix@mulix.org>
  46  *      major cleanup for 2.6, fix a few error patch buglets
  47  *      with returning without properly cleaning up first,
  48  *      get rid of lock_kernel().
  49  *  v0.14.10h
  50  *      Sept 10 2002 Pascal Schmidt <der.eremit@email.de>
  51  *      added support for ALi 5451 joystick port
  52  *  v0.14.10g
  53  *      Sept 05 2002 Alan Cox <alan@redhat.com>
  54  *      adapt to new pci joystick attachment interface
  55  *  v0.14.10f
  56  *      July 24 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  57  *      patch from Eric Lemar (via Ian Soboroff): in suspend and resume,
  58  *      fix wrong cast from pci_dev* to struct trident_card*.
  59  *  v0.14.10e
  60  *      July 19 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  61  *      rewrite the DMA buffer allocation/deallcoation functions, to make it
  62  *      modular and fix a bug where we would call free_pages on memory
  63  *      obtained with pci_alloc_consistent. Also remove unnecessary #ifdef
  64  *      CONFIG_PROC_FS and various other cleanups.
  65  *  v0.14.10d
  66  *      July 19 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  67  *      made several printk(KERN_NOTICE...) into TRDBG(...), to avoid spamming
  68  *      my syslog with hundreds of messages.
  69  *  v0.14.10c
  70  *      July 16 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  71  *      Cleaned up Lei Hu's 0.4.10 driver to conform to Documentation/CodingStyle
  72  *      and the coding style used in the rest of the file.
  73  *  v0.14.10b
  74  *      June 23 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  75  *      add a missing unlock_set_fmt, remove a superflous lock/unlock pair
  76  *      with nothing in between.
  77  *  v0.14.10a
  78  *      June 21 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  79  *      use a debug macro instead of #ifdef CONFIG_DEBUG, trim to 80 columns
  80  *      per line, use 'do {} while (0)' in statement macros.
  81  *  v0.14.10
  82  *      June 6 2002 Lei Hu <Lei_hu@ali.com.tw>
  83  *      rewrite the part to read/write registers of audio codec for Ali5451
  84  *  v0.14.9e
  85  *      January 2 2002 Vojtech Pavlik <vojtech@ucw.cz> added gameport
  86  *      support to avoid resource conflict with pcigame.c
  87  *  v0.14.9d
  88  *      October 8 2001 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  89  *      use set_current_state, properly release resources on failure in
  90  *      trident_probe, get rid of check_region
  91  *  v0.14.9c
  92  *      August 10 2001 Peter Wächtler <pwaechtler@loewe-komp.de>
  93  *      added support for Tvia (formerly Integraphics/IGST) CyberPro5050
  94  *      this chip is often found in settop boxes (combined video+audio)
  95  *  v0.14.9b
  96  *      Switch to static inline not extern inline (gcc 3)
  97  *  v0.14.9a
  98  *      Aug 6 2001 Alan Cox
  99  *      0.14.9 crashed on rmmod due to a timer/bh left running. Simplified
 100  *      the existing logic (the BH doesn't help as ac97 is lock_irqsave)
 101  *      and used del_timer_sync to clean up
 102  *      Fixed a problem where the ALi change broke my generic card
 103  *  v0.14.9
 104  *      Jul 10 2001 Matt Wu
 105  *      Add H/W Volume Control
 106  *  v0.14.8a
 107  *      July 7 2001 Alan Cox
 108  *      Moved Matt Wu's ac97 register cache into the card structure
 109  *  v0.14.8
 110  *      Apr 30 2001 Matt Wu
 111  *      Set EBUF1 and EBUF2 to still mode
 112  *      Add dc97/ac97 reset function
 113  *      Fix power management: ali_restore_regs
 114  *  unreleased
 115  *      Mar 09 2001 Matt Wu
 116  *      Add cache for ac97 access
 117  *  v0.14.7
 118  *      Feb 06 2001 Matt Wu
 119  *      Fix ac97 initialization
 120  *      Fix bug: an extra tail will be played when playing
 121  *      Jan 05 2001 Matt Wu
 122  *      Implement multi-channels and S/PDIF in support for ALi 1535+
 123  *  v0.14.6
 124  *      Nov 1 2000 Ching-Ling Lee
 125  *      Fix the bug of memory leak when switching 5.1-channels to 2 channels.
 126  *      Add lock protection into dynamic changing format of data.
 127  *      Oct 18 2000 Ching-Ling Lee
 128  *      5.1-channels support for ALi
 129  *      June 28 2000 Ching-Ling Lee
 130  *      S/PDIF out/in(playback/record) support for ALi 1535+, using /proc to be selected by user
 131  *      Simple Power Management support for ALi
 132  *  v0.14.5 May 23 2000 Ollie Lho
 133  *      Misc bug fix from the Net
 134  *  v0.14.4 May 20 2000 Aaron Holtzman
 135  *      Fix kfree'd memory access in release
 136  *      Fix race in open while looking for a free virtual channel slot
 137  *      remove open_wait wq (which appears to be unused)
 138  *  v0.14.3 May 10 2000 Ollie Lho
 139  *      fixed a small bug in trident_update_ptr, xmms 1.0.1 no longer uses 100% CPU
 140  *  v0.14.2 Mar 29 2000 Ching-Ling Lee
 141  *      Add clear to silence advance in trident_update_ptr
 142  *      fix invalid data of the end of the sound
 143  *  v0.14.1 Mar 24 2000 Ching-Ling Lee
 144  *      ALi 5451 support added, playback and recording O.K.
 145  *      ALi 5451 originally developed and structured based on sonicvibes, and
 146  *      suggested to merge into this file by Alan Cox.
 147  *  v0.14 Mar 15 2000 Ollie Lho
 148  *      5.1 channel output support with channel binding. What's the Matrix ?
 149  *  v0.13.1 Mar 10 2000 Ollie Lho
 150  *      few minor bugs on dual codec support, needs more testing
 151  *  v0.13 Mar 03 2000 Ollie Lho
 152  *      new pci_* for 2.4 kernel, back ported to 2.2
 153  *  v0.12 Feb 23 2000 Ollie Lho
 154  *      Preliminary Recording support
 155  *  v0.11.2 Feb 19 2000 Ollie Lho
 156  *      removed incomplete full-dulplex support
 157  *  v0.11.1 Jan 28 2000 Ollie Lho
 158  *      small bug in setting sample rate for 4d-nx (reported by Aaron)
 159  *  v0.11 Jan 27 2000 Ollie Lho
 160  *      DMA bug, scheduler latency, second try
 161  *  v0.10 Jan 24 2000 Ollie Lho
 162  *      DMA bug fixed, found kernel scheduling problem
 163  *  v0.09 Jan 20 2000 Ollie Lho
 164  *      Clean up of channel register access routine (prepare for channel binding)
 165  *  v0.08 Jan 14 2000 Ollie Lho
 166  *      Isolation of AC97 codec code
 167  *  v0.07 Jan 13 2000 Ollie Lho
 168  *      Get rid of ugly old low level access routines (e.g. CHRegs.lp****)
 169  *  v0.06 Jan 11 2000 Ollie Lho
 170  *      Preliminary support for dual (more ?) AC97 codecs
 171  *  v0.05 Jan 08 2000 Luca Montecchiani <m.luca@iname.com>
 172  *      adapt to 2.3.x new __setup/__init call
 173  *  v0.04 Dec 31 1999 Ollie Lho
 174  *      Multiple Open, using Middle Loop Interrupt to smooth playback
 175  *  v0.03 Dec 24 1999 Ollie Lho
 176  *      mem leak in prog_dmabuf and dealloc_dmabuf removed
 177  *  v0.02 Dec 15 1999 Ollie Lho
 178  *      SiS 7018 support added, playback O.K.
 179  *  v0.01 Alan Cox et. al.
 180  *      Initial Release in kernel 2.3.30, does not work
 181  *
 182  *  ToDo
 183  *      Clean up of low level channel register access code. (done)
 184  *      Fix the bug on dma buffer management in update_ptr, read/write, drain_dac (done)
 185  *      Dual AC97 codecs support (done)
 186  *      Recording support (done)
 187  *      Mmap support
 188  *      "Channel Binding" ioctl extension (done)
 189  *      new pci device driver interface for 2.4 kernel (done)
 190  *
 191  *      Lock order (high->low)
 192  *              lock    -       hardware lock
 193  *              open_sem -      guard opens
 194  *              sem     -       guard dmabuf, write re-entry etc
 195  */
 196
 197 #include <linux/config.h>
 198 #include <linux/module.h>
 199 #include <linux/string.h>
 200 #include <linux/ctype.h>
 201 #include <linux/ioport.h>
 202 #include <linux/sched.h>
 203 #include <linux/delay.h>
 204 #include <linux/sound.h>
 205 #include <linux/slab.h>
 206 #include <linux/soundcard.h>
 207 #include <linux/pci.h>
 208 #include <linux/init.h>
 209 #include <linux/poll.h>
 210 #include <linux/spinlock.h>
 211 #include <linux/smp_lock.h>
 212 #include <linux/ac97_codec.h>
 213 #include <linux/bitops.h>
 214 #include <linux/proc_fs.h>
 215 #include <linux/interrupt.h>
 216 #include <linux/pm.h>
 217 #include <linux/gameport.h>
 218 #include <linux/kernel.h>
 219 #include <asm/uaccess.h>
 220 #include <asm/hardirq.h>
 221 #include <asm/io.h>
 222 #include <asm/dma.h>
 223
 224 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
 225 #include <asm/hwrpb.h>
 226 #endif
 227
 228 #include "trident.h"
 229
 230 #define DRIVER_VERSION "0.14.10j-2.6"
 231
 232 /* magic numbers to protect our data structures */
 233 #define TRIDENT_CARD_MAGIC      0x5072696E      /* "Prin" */
 234 #define TRIDENT_STATE_MAGIC     0x63657373      /* "cess" */
 235
 236 #define TRIDENT_DMA_MASK        0x3fffffff      /* DMA buffer mask for pci_alloc_consist */
 237 #define ALI_DMA_MASK            0x7fffffff      /* ALI Tridents have 31-bit DMA. Wow. */
 238
 239 #define NR_HW_CH                32
 240
 241 /* maximum number of AC97 codecs connected, AC97 2.0 defined 4, but 7018 and 4D-NX only
 242    have 2 SDATA_IN lines (currently) */
 243 #define NR_AC97         2
 244
 245 /* minor number of /dev/swmodem (temporary, experimental) */
 246 #define SND_DEV_SWMODEM 7
 247
 248 static const unsigned ali_multi_channels_5_1[] = {
 249         /*ALI_SURR_LEFT_CHANNEL, ALI_SURR_RIGHT_CHANNEL, */
 250         ALI_CENTER_CHANNEL,
 251         ALI_LEF_CHANNEL,
 252         ALI_SURR_LEFT_CHANNEL,
 253         ALI_SURR_RIGHT_CHANNEL
 254 };
 255
 256 static const unsigned sample_size[] = { 1, 2, 2, 4 };
 257 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
 258
 259 static const char invalid_magic[] = KERN_CRIT "trident: invalid magic value in %s\n";
 260
 261 enum {
 262         TRIDENT_4D_DX = 0,
 263         TRIDENT_4D_NX,
 264         SIS_7018,
 265         ALI_5451,
 266         CYBER5050
 267 };
 268
 269 static char *card_names[] = {
 270         "Trident 4DWave DX",
 271         "Trident 4DWave NX",
 272         "SiS 7018 PCI Audio",
 273         "ALi Audio Accelerator",
 274         "Tvia/IGST CyberPro 5050"
 275 };
 276
 277 static struct pci_device_id trident_pci_tbl[] = {
 278         {PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_DX,
 279          PCI_ANY_ID, PCI_ANY_ID, 0, 0, TRIDENT_4D_DX},
 280         {PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_NX,
 281          PCI_ANY_ID, PCI_ANY_ID, 0, 0, TRIDENT_4D_NX},
 282         {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7018,
 283          PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_7018},
 284         {PCI_VENDOR_ID_ALI, PCI_DEVICE_ID_ALI_5451,
 285          PCI_ANY_ID, PCI_ANY_ID, 0, 0, ALI_5451},
 286         {PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_5050,
 287          PCI_ANY_ID, PCI_ANY_ID, 0, 0, CYBER5050},
 288         {0,}
 289 };
 290
 291 MODULE_DEVICE_TABLE(pci, trident_pci_tbl);
 292
 293 /* "software" or virtual channel, an instance of opened /dev/dsp */
 294 struct trident_state {
 295         unsigned int magic;
 296         struct trident_card *card;      /* Card info */
 297
 298         /* file mode */
 299         mode_t open_mode;
 300
 301         /* virtual channel number */
 302         int virt;
 303
 304         struct dmabuf {
 305                 /* wave sample stuff */
 306                 unsigned int rate;
 307                 unsigned char fmt, enable;
 308
 309                 /* hardware channel */
 310                 struct trident_channel *channel;
 311
 312                 /* OSS buffer management stuff */
 313                 void *rawbuf;
 314                 dma_addr_t dma_handle;
 315                 unsigned buforder;
 316                 unsigned numfrag;
 317                 unsigned fragshift;
 318
 319                 /* our buffer acts like a circular ring */
 320                 unsigned hwptr; /* where dma last started, updated by update_ptr */
 321                 unsigned swptr; /* where driver last clear/filled, updated by read/write */
 322                 int count;      /* bytes to be comsumed or been generated by dma machine */
 323                 unsigned total_bytes;   /* total bytes dmaed by hardware */
 324
 325                 unsigned error; /* number of over/underruns */
 326                 /* put process on wait queue when no more space in buffer */
 327                 wait_queue_head_t wait;
 328
 329                 /* redundant, but makes calculations easier */
 330                 unsigned fragsize;
 331                 unsigned dmasize;
 332                 unsigned fragsamples;
 333
 334                 /* OSS stuff */
 335                 unsigned mapped:1;
 336                 unsigned ready:1;
 337                 unsigned endcleared:1;
 338                 unsigned update_flag;
 339                 unsigned ossfragshift;
 340                 int ossmaxfrags;
 341                 unsigned subdivision;
 342
 343         } dmabuf;
 344
 345         /* 5.1 channels */
 346         struct trident_state *other_states[4];
 347         int multi_channels_adjust_count;
 348         unsigned chans_num;
 349         unsigned long fmt_flag;
 350         /* Guard against mmap/write/read races */
 351         struct semaphore sem;
 352
 353 };
 354
 355 /* hardware channels */
 356 struct trident_channel {
 357         int num; /* channel number */
 358         u32 lba; /* Loop Begine Address, where dma buffer starts */
 359         u32 eso; /* End Sample Offset, wehre dma buffer ends */
 360                  /* (in the unit of samples) */
 361         u32 delta; /* delta value, sample rate / 48k for playback, */
 362                    /* 48k/sample rate for recording */
 363         u16 attribute; /* control where PCM data go and come  */
 364         u16 fm_vol;
 365         u32 control; /* signed/unsigned, 8/16 bits, mono/stereo */
 366 };
 367
 368 struct trident_pcm_bank_address {
 369         u32 start;
 370         u32 stop;
 371         u32 aint;
 372         u32 aint_en;
 373 };
 374
 375 static struct trident_pcm_bank_address bank_a_addrs = {
 376         T4D_START_A,
 377         T4D_STOP_A,
 378         T4D_AINT_A,
 379         T4D_AINTEN_A
 380 };
 381
 382 static struct trident_pcm_bank_address bank_b_addrs = {
 383         T4D_START_B,
 384         T4D_STOP_B,
 385         T4D_AINT_B,
 386         T4D_AINTEN_B
 387 };
 388
 389 struct trident_pcm_bank {
 390         /* register addresses to control bank operations */
 391         struct trident_pcm_bank_address *addresses;
 392         /* each bank has 32 channels */
 393         u32 bitmap;             /* channel allocation bitmap */
 394         struct trident_channel channels[32];
 395 };
 396
 397 struct trident_card {
 398         unsigned int magic;
 399
 400         /* We keep trident cards in a linked list */
 401         struct trident_card *next;
 402
 403         /* single open lock mechanism, only used for recording */
 404         struct semaphore open_sem;
 405
 406         /* The trident has a certain amount of cross channel interaction
 407            so we use a single per card lock */
 408         spinlock_t lock;
 409
 410         /* PCI device stuff */
 411         struct pci_dev *pci_dev;
 412         u16 pci_id;
 413         u8 revision;
 414
 415         /* soundcore stuff */
 416         int dev_audio;
 417
 418         /* structures for abstraction of hardware facilities, codecs, */
 419         /* banks and channels */
 420         struct ac97_codec *ac97_codec[NR_AC97];
 421         struct trident_pcm_bank banks[NR_BANKS];
 422         struct trident_state *states[NR_HW_CH];
 423
 424         /* hardware resources */
 425         unsigned long iobase;
 426         u32 irq;
 427
 428         /* Function support */
 429         struct trident_channel *(*alloc_pcm_channel) (struct trident_card *);
 430         struct trident_channel *(*alloc_rec_pcm_channel) (struct trident_card *);
 431         void (*free_pcm_channel) (struct trident_card *, unsigned int chan);
 432         void (*address_interrupt) (struct trident_card *);
 433
 434         /* Added by Matt Wu 01-05-2001 for spdif in */
 435         int multi_channel_use_count;
 436         int rec_channel_use_count;
 437         u16 mixer_regs[64][NR_AC97];    /* Made card local by Alan */
 438         int mixer_regs_ready;
 439
 440         /* Added for hardware volume control */
 441         int hwvolctl;
 442         struct timer_list timer;
 443
 444         /* Game port support */
 445         struct gameport gameport;
 446 };
 447
 448 enum dmabuf_mode {
 449         DM_PLAYBACK = 0,
 450         DM_RECORD
 451 };
 452
 453 /* table to map from CHANNELMASK to channel attribute for SiS 7018 */
 454 static u16 mask2attr[] = {
 455         PCM_LR, PCM_LR, SURR_LR, CENTER_LFE,
 456         HSET, MIC, MODEM_LINE1, MODEM_LINE2,
 457         I2S_LR, SPDIF_LR
 458 };
 459
 460 /* table to map from channel attribute to CHANNELMASK for SiS 7018 */
 461 static int attr2mask[] = {
 462         DSP_BIND_MODEM1, DSP_BIND_MODEM2, DSP_BIND_FRONT, DSP_BIND_HANDSET,
 463         DSP_BIND_I2S, DSP_BIND_CENTER_LFE, DSP_BIND_SURR, DSP_BIND_SPDIF
 464 };
 465
 466 /* Added by Matt Wu 01-05-2001 for spdif in */
 467 static int ali_close_multi_channels(void);
 468 static void ali_delay(struct trident_card *card, int interval);
 469 static void ali_detect_spdif_rate(struct trident_card *card);
 470
 471 static void ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val);
 472 static u16 ali_ac97_read(struct ac97_codec *codec, u8 reg);
 473
 474 static struct trident_card *devs;
 475
 476 static void trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val);
 477 static u16 trident_ac97_get(struct ac97_codec *codec, u8 reg);
 478
 479 static int trident_open_mixdev(struct inode *inode, struct file *file);
 480 static int trident_ioctl_mixdev(struct inode *inode, struct file *file,
 481                                 unsigned int cmd, unsigned long arg);
 482
 483 static void ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val);
 484 static u16 ali_ac97_get(struct trident_card *card, int secondary, u8 reg);
 485 static void ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate);
 486 static void ali_enable_special_channel(struct trident_state *stat);
 487 static struct trident_channel *ali_alloc_rec_pcm_channel(struct trident_card *card);
 488 static struct trident_channel *ali_alloc_pcm_channel(struct trident_card *card);
 489 static void ali_restore_regs(struct trident_card *card);
 490 static void ali_save_regs(struct trident_card *card);
 491 static int trident_suspend(struct pci_dev *dev, u32 unused);
 492 static int trident_resume(struct pci_dev *dev);
 493 static void ali_free_pcm_channel(struct trident_card *card, unsigned int channel);
 494 static int ali_setup_multi_channels(struct trident_card *card, int chan_nums);
 495 static unsigned int ali_get_spdif_in_rate(struct trident_card *card);
 496 static void ali_setup_spdif_in(struct trident_card *card);
 497 static void ali_disable_spdif_in(struct trident_card *card);
 498 static void ali_disable_special_channel(struct trident_card *card, int ch);
 499 static void ali_setup_spdif_out(struct trident_card *card, int flag);
 500 static int ali_write_5_1(struct trident_state *state,
 501                          const char __user *buffer,
 502                          int cnt_for_multi_channel, unsigned int *copy_count,
 503                          unsigned int *state_cnt);
 504 static int ali_allocate_other_states_resources(struct trident_state *state,
 505                                                int chan_nums);
 506 static void ali_free_other_states_resources(struct trident_state *state);
 507
 508 /* save registers for ALi Power Management */
 509 static struct ali_saved_registers {
 510         unsigned long global_regs[ALI_GLOBAL_REGS];
 511         unsigned long channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS];
 512         unsigned mixer_regs[ALI_MIXER_REGS];
 513 } ali_registers;
 514
 515 #define seek_offset(dma_ptr, buffer, cnt, offset, copy_count)   do { \
 516         (dma_ptr) += (offset);    \
 517         (buffer) += (offset);     \
 518         (cnt) -= (offset);        \
 519         (copy_count) += (offset); \
 520 } while (0)
 521
 522 static inline int lock_set_fmt(struct trident_state* state)
 523 {
 524         if (test_and_set_bit(0, &state->fmt_flag))
 525                 return -EFAULT;
 526
 527         return 0;
 528 }
 529
 530 static inline void unlock_set_fmt(struct trident_state* state)
 531 {
 532         clear_bit(0, &state->fmt_flag);
 533 }
 534
 535 static int
 536 trident_enable_loop_interrupts(struct trident_card *card)
 537 {
 538         u32 global_control;
 539
 540         global_control = inl(TRID_REG(card, T4D_LFO_GC_CIR));
 541
 542         switch (card->pci_id) {
 543         case PCI_DEVICE_ID_SI_7018:
 544                 global_control |= (ENDLP_IE | MIDLP_IE | BANK_B_EN);
 545                 break;
 546         case PCI_DEVICE_ID_ALI_5451:
 547         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 548         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 549         case PCI_DEVICE_ID_INTERG_5050:
 550                 global_control |= (ENDLP_IE | MIDLP_IE);
 551                 break;
 552         default:
 553                 return 0;
 554         }
 555
 556         outl(global_control, TRID_REG(card, T4D_LFO_GC_CIR));
 557
 558         pr_debug("trident: Enable Loop Interrupts, globctl = 0x%08X\n",
 559                  inl(TRID_REG(card, T4D_LFO_GC_CIR)));
 560
 561         return 1;
 562 }
 563
 564 static int
 565 trident_disable_loop_interrupts(struct trident_card *card)
 566 {
 567         u32 global_control;
 568
 569         global_control = inl(TRID_REG(card, T4D_LFO_GC_CIR));
 570         global_control &= ~(ENDLP_IE | MIDLP_IE);
 571         outl(global_control, TRID_REG(card, T4D_LFO_GC_CIR));
 572
 573         pr_debug("trident: Disabled Loop Interrupts, globctl = 0x%08X\n",
 574                  global_control);
 575
 576         return 1;
 577 }
 578
 579 static void
 580 trident_enable_voice_irq(struct trident_card *card, unsigned int channel)
 581 {
 582         unsigned int mask = 1 << (channel & 0x1f);
 583         struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 584         u32 reg, addr = bank->addresses->aint_en;
 585
 586         reg = inl(TRID_REG(card, addr));
 587         reg |= mask;
 588         outl(reg, TRID_REG(card, addr));
 589
 590 #ifdef DEBUG
 591         reg = inl(TRID_REG(card, addr));
 592         pr_debug("trident: enabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
 593                  channel, addr == T4D_AINTEN_B ? "AINTEN_B" : "AINTEN_A",
 594                  reg, addr);
 595 #endif /* DEBUG */
 596 }
 597
 598 static void
 599 trident_disable_voice_irq(struct trident_card *card, unsigned int channel)
 600 {
 601         unsigned int mask = 1 << (channel & 0x1f);
 602         struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 603         u32 reg, addr = bank->addresses->aint_en;
 604
 605         reg = inl(TRID_REG(card, addr));
 606         reg &= ~mask;
 607         outl(reg, TRID_REG(card, addr));
 608
 609         /* Ack the channel in case the interrupt was set before we disable it. */
 610         outl(mask, TRID_REG(card, bank->addresses->aint));
 611
 612 #ifdef DEBUG
 613         reg = inl(TRID_REG(card, addr));
 614         pr_debug("trident: disabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
 615                  channel, addr == T4D_AINTEN_B ? "AINTEN_B" : "AINTEN_A",
 616                  reg, addr);
 617 #endif /* DEBUG */
 618 }
 619
 620 static void
 621 trident_start_voice(struct trident_card *card, unsigned int channel)
 622 {
 623         unsigned int mask = 1 << (channel & 0x1f);
 624         struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 625         u32 addr = bank->addresses->start;
 626
 627 #ifdef DEBUG
 628         u32 reg;
 629 #endif /* DEBUG */
 630
 631         outl(mask, TRID_REG(card, addr));
 632
 633 #ifdef DEBUG
 634         reg = inl(TRID_REG(card, addr));
 635         pr_debug("trident: start voice on channel %d, %s = 0x%08x(addr:%X)\n",
 636                  channel, addr == T4D_START_B ? "START_B" : "START_A",
 637                  reg, addr);
 638 #endif /* DEBUG */
 639 }
 640
 641 static void
 642 trident_stop_voice(struct trident_card *card, unsigned int channel)
 643 {
 644         unsigned int mask = 1 << (channel & 0x1f);
 645         struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 646         u32 addr = bank->addresses->stop;
 647
 648 #ifdef DEBUG
 649         u32 reg;
 650 #endif /* DEBUG */
 651
 652         outl(mask, TRID_REG(card, addr));
 653
 654 #ifdef DEBUG
 655         reg = inl(TRID_REG(card, addr));
 656         pr_debug("trident: stop voice on channel %d, %s = 0x%08x(addr:%X)\n",
 657                  channel, addr == T4D_STOP_B ? "STOP_B" : "STOP_A",
 658                  reg, addr);
 659 #endif /* DEBUG */
 660 }
 661
 662 static u32
 663 trident_get_interrupt_mask(struct trident_card *card, unsigned int channel)
 664 {
 665         struct trident_pcm_bank *bank = &card->banks[channel];
 666         u32 addr = bank->addresses->aint;
 667         return inl(TRID_REG(card, addr));
 668 }
 669
 670 static int
 671 trident_check_channel_interrupt(struct trident_card *card, unsigned int channel)
 672 {
 673         unsigned int mask = 1 << (channel & 0x1f);
 674         u32 reg = trident_get_interrupt_mask(card, channel >> 5);
 675
 676 #ifdef DEBUG
 677         if (reg & mask)
 678                 pr_debug("trident: channel %d has interrupt, %s = 0x%08x\n",
 679                          channel, reg == T4D_AINT_B ? "AINT_B" : "AINT_A",
 680                          reg);
 681 #endif /* DEBUG */
 682         return (reg & mask) ? 1 : 0;
 683 }
 684
 685 static void
 686 trident_ack_channel_interrupt(struct trident_card *card, unsigned int channel)
 687 {
 688         unsigned int mask = 1 << (channel & 0x1f);
 689         struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 690         u32 reg, addr = bank->addresses->aint;
 691
 692         reg = inl(TRID_REG(card, addr));
 693         reg &= mask;
 694         outl(reg, TRID_REG(card, addr));
 695
 696 #ifdef DEBUG
 697         reg = inl(TRID_REG(card, T4D_AINT_B));
 698         pr_debug("trident: Ack channel %d interrupt, AINT_B = 0x%08x\n",
 699                  channel, reg);
 700 #endif /* DEBUG */
 701 }
 702
 703 static struct trident_channel *
 704 trident_alloc_pcm_channel(struct trident_card *card)
 705 {
 706         struct trident_pcm_bank *bank;
 707         int idx;
 708
 709         bank = &card->banks[BANK_B];
 710
 711         for (idx = 31; idx >= 0; idx--) {
 712                 if (!(bank->bitmap & (1 << idx))) {
 713                         struct trident_channel *channel = &bank->channels[idx];
 714                         bank->bitmap |= 1 << idx;
 715                         channel->num = idx + 32;
 716                         return channel;
 717                 }
 718         }
 719
 720         /* no more free channels available */
 721         printk(KERN_ERR "trident: no more channels available on Bank B.\n");
 722         return NULL;
 723 }
 724
 725 static void
 726 trident_free_pcm_channel(struct trident_card *card, unsigned int channel)
 727 {
 728         int bank;
 729         unsigned char b;
 730
 731         if (channel < 31 || channel > 63)
 732                 return;
 733
 734         if (card->pci_id == PCI_DEVICE_ID_TRIDENT_4DWAVE_DX ||
 735             card->pci_id == PCI_DEVICE_ID_TRIDENT_4DWAVE_NX) {
 736                 b = inb(TRID_REG(card, T4D_REC_CH));
 737                 if ((b & ~0x80) == channel)
 738                         outb(0x0, TRID_REG(card, T4D_REC_CH));
 739         }
 740
 741         bank = channel >> 5;
 742         channel = channel & 0x1f;
 743
 744         card->banks[bank].bitmap &= ~(1 << (channel));
 745 }
 746
 747 static struct trident_channel *
 748 cyber_alloc_pcm_channel(struct trident_card *card)
 749 {
 750         struct trident_pcm_bank *bank;
 751         int idx;
 752
 753         /* The cyberpro 5050 has only 32 voices and one bank */
 754         /* .. at least they are not documented (if you want to call that
 755          * crap documentation), perhaps broken ? */
 756
 757         bank = &card->banks[BANK_A];
 758
 759         for (idx = 31; idx >= 0; idx--) {
 760                 if (!(bank->bitmap & (1 << idx))) {
 761                         struct trident_channel *channel = &bank->channels[idx];
 762                         bank->bitmap |= 1 << idx;
 763                         channel->num = idx;
 764                         return channel;
 765                 }
 766         }
 767
 768         /* no more free channels available */
 769         printk(KERN_ERR "cyberpro5050: no more channels available on Bank A.\n");
 770         return NULL;
 771 }
 772
 773 static void
 774 cyber_free_pcm_channel(struct trident_card *card, unsigned int channel)
 775 {
 776         if (channel > 31)
 777                 return;
 778         card->banks[BANK_A].bitmap &= ~(1 << (channel));
 779 }
 780
 781 static inline void
 782 cyber_outidx(int port, int idx, int data)
 783 {
 784         outb(idx, port);
 785         outb(data, port + 1);
 786 }
 787
 788 static inline int
 789 cyber_inidx(int port, int idx)
 790 {
 791         outb(idx, port);
 792         return inb(port + 1);
 793 }
 794
 795 static int
 796 cyber_init_ritual(struct trident_card *card)
 797 {
 798         /* some black magic, taken from SDK samples */
 799         /* remove this and nothing will work */
 800         int portDat;
 801         int ret = 0;
 802         unsigned long flags;
 803
 804         /*
 805          *      Keep interrupts off for the configure - we don't want to
 806          *      clash with another cyberpro config event
 807          */
 808
 809         spin_lock_irqsave(&card->lock, flags);
 810         portDat = cyber_inidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE);
 811         /* enable, if it was disabled */
 812         if ((portDat & CYBER_BMSK_AUENZ) != CYBER_BMSK_AUENZ_ENABLE) {
 813                 printk(KERN_INFO "cyberpro5050: enabling audio controller\n");
 814                 cyber_outidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE,
 815                              portDat | CYBER_BMSK_AUENZ_ENABLE);
 816                 /* check again if hardware is enabled now */
 817                 portDat = cyber_inidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE);
 818         }
 819         if ((portDat & CYBER_BMSK_AUENZ) != CYBER_BMSK_AUENZ_ENABLE) {
 820                 printk(KERN_ERR "cyberpro5050: initAudioAccess: no success\n");
 821                 ret = -1;
 822         } else {
 823                 cyber_outidx(CYBER_PORT_AUDIO, CYBER_IDX_IRQ_ENABLE,
 824                              CYBER_BMSK_AUDIO_INT_ENABLE);
 825                 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x01);
 826                 cyber_outidx(CYBER_PORT_AUDIO, 0xba, 0x20);
 827                 cyber_outidx(CYBER_PORT_AUDIO, 0xbb, 0x08);
 828                 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x02);
 829                 cyber_outidx(CYBER_PORT_AUDIO, 0xb3, 0x06);
 830                 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x00);
 831         }
 832         spin_unlock_irqrestore(&card->lock, flags);
 833         return ret;
 834 }
 835
 836 /*  called with spin lock held */
 837
 838 static int
 839 trident_load_channel_registers(struct trident_card *card, u32 * data,
 840                                unsigned int channel)
 841 {
 842         int i;
 843
 844         if (channel > 63)
 845                 return 0;
 846
 847         /* select hardware channel to write */
 848         outb(channel, TRID_REG(card, T4D_LFO_GC_CIR));
 849
 850         /* Output the channel registers, but don't write register
 851            three to an ALI chip. */
 852         for (i = 0; i < CHANNEL_REGS; i++) {
 853                 if (i == 3 && card->pci_id == PCI_DEVICE_ID_ALI_5451)
 854                         continue;
 855                 outl(data[i], TRID_REG(card, CHANNEL_START + 4 * i));
 856         }
 857         if (card->pci_id == PCI_DEVICE_ID_ALI_5451 ||
 858             card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
 859                 outl(ALI_EMOD_Still, TRID_REG(card, ALI_EBUF1));
 860                 outl(ALI_EMOD_Still, TRID_REG(card, ALI_EBUF2));
 861         }
 862         return 1;
 863 }
 864
 865 /* called with spin lock held */
 866 static int
 867 trident_write_voice_regs(struct trident_state *state)
 868 {
 869         unsigned int data[CHANNEL_REGS + 1];
 870         struct trident_channel *channel;
 871
 872         channel = state->dmabuf.channel;
 873
 874         data[1] = channel->lba;
 875         data[4] = channel->control;
 876
 877         switch (state->card->pci_id) {
 878         case PCI_DEVICE_ID_ALI_5451:
 879                 data[0] = 0;    /* Current Sample Offset */
 880                 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
 881                 data[3] = 0;
 882                 break;
 883         case PCI_DEVICE_ID_SI_7018:
 884         case PCI_DEVICE_ID_INTERG_5050:
 885                 data[0] = 0;    /* Current Sample Offset */
 886                 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
 887                 data[3] = (channel->attribute << 16) | (channel->fm_vol & 0xffff);
 888                 break;
 889         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 890                 data[0] = 0;    /* Current Sample Offset */
 891                 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
 892                 data[3] = channel->fm_vol & 0xffff;
 893                 break;
 894         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 895                 data[0] = (channel->delta << 24);
 896                 data[2] = ((channel->delta << 16) & 0xff000000) |
 897                         (channel->eso & 0x00ffffff);
 898                 data[3] = channel->fm_vol & 0xffff;
 899                 break;
 900         default:
 901                 return 0;
 902         }
 903
 904         return trident_load_channel_registers(state->card, data, channel->num);
 905 }
 906
 907 static int
 908 compute_rate_play(u32 rate)
 909 {
 910         int delta;
 911         /* We special case 44100 and 8000 since rounding with the equation
 912            does not give us an accurate enough value. For 11025 and 22050
 913            the equation gives us the best answer. All other frequencies will
 914            also use the equation. JDW */
 915         if (rate == 44100)
 916                 delta = 0xeb3;
 917         else if (rate == 8000)
 918                 delta = 0x2ab;
 919         else if (rate == 48000)
 920                 delta = 0x1000;
 921         else
 922                 delta = (((rate << 12) + rate) / 48000) & 0x0000ffff;
 923         return delta;
 924 }
 925
 926 static int
 927 compute_rate_rec(u32 rate)
 928 {
 929         int delta;
 930
 931         if (rate == 44100)
 932                 delta = 0x116a;
 933         else if (rate == 8000)
 934                 delta = 0x6000;
 935         else if (rate == 48000)
 936                 delta = 0x1000;
 937         else
 938                 delta = ((48000 << 12) / rate) & 0x0000ffff;
 939
 940         return delta;
 941 }
 942
 943 /* set playback sample rate */
 944 static unsigned int
 945 trident_set_dac_rate(struct trident_state *state, unsigned int rate)
 946 {
 947         struct dmabuf *dmabuf = &state->dmabuf;
 948
 949         if (rate > 48000)
 950                 rate = 48000;
 951         if (rate < 4000)
 952                 rate = 4000;
 953
 954         dmabuf->rate = rate;
 955         dmabuf->channel->delta = compute_rate_play(rate);
 956
 957         trident_write_voice_regs(state);
 958
 959         pr_debug("trident: called trident_set_dac_rate : rate = %d\n", rate);
 960
 961         return rate;
 962 }
 963
 964 /* set recording sample rate */
 965 static unsigned int
 966 trident_set_adc_rate(struct trident_state *state, unsigned int rate)
 967 {
 968         struct dmabuf *dmabuf = &state->dmabuf;
 969
 970         if (rate > 48000)
 971                 rate = 48000;
 972         if (rate < 4000)
 973                 rate = 4000;
 974
 975         dmabuf->rate = rate;
 976         dmabuf->channel->delta = compute_rate_rec(rate);
 977
 978         trident_write_voice_regs(state);
 979
 980         pr_debug("trident: called trident_set_adc_rate : rate = %d\n", rate);
 981
 982         return rate;
 983 }
 984
 985 /* prepare channel attributes for playback */
 986 static void
 987 trident_play_setup(struct trident_state *state)
 988 {
 989         struct dmabuf *dmabuf = &state->dmabuf;
 990         struct trident_channel *channel = dmabuf->channel;
 991
 992         channel->lba = dmabuf->dma_handle;
 993         channel->delta = compute_rate_play(dmabuf->rate);
 994
 995         channel->eso = dmabuf->dmasize >> sample_shift[dmabuf->fmt];
 996         channel->eso -= 1;
 997
 998         if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
 999                 channel->attribute = 0;
1000                 if (state->card->pci_id == PCI_DEVICE_ID_ALI_5451) {
1001                         if ((channel->num == ALI_SPDIF_IN_CHANNEL) ||
1002                             (channel->num == ALI_PCM_IN_CHANNEL))
1003                                 ali_disable_special_channel(state->card, channel->num);
1004                         else if ((inl(TRID_REG(state->card, ALI_GLOBAL_CONTROL))
1005                                   & ALI_SPDIF_OUT_CH_ENABLE)
1006                                  && (channel->num == ALI_SPDIF_OUT_CHANNEL)) {
1007                                 ali_set_spdif_out_rate(state->card,
1008                                                        state->dmabuf.rate);
1009                                 state->dmabuf.channel->delta = 0x1000;
1010                         }
1011                 }
1012         }
1013
1014         channel->fm_vol = 0x0;
1015
1016         channel->control = CHANNEL_LOOP;
1017         if (dmabuf->fmt & TRIDENT_FMT_16BIT) {
1018                 /* 16-bits */
1019                 channel->control |= CHANNEL_16BITS;
1020                 /* signed */
1021                 channel->control |= CHANNEL_SIGNED;
1022         }
1023         if (dmabuf->fmt & TRIDENT_FMT_STEREO)
1024                 /* stereo */
1025                 channel->control |= CHANNEL_STEREO;
1026
1027         pr_debug("trident: trident_play_setup, LBA = 0x%08x, Delta = 0x%08x, "
1028                  "ESO = 0x%08x, Control = 0x%08x\n", channel->lba,
1029                  channel->delta, channel->eso, channel->control);
1030
1031         trident_write_voice_regs(state);
1032 }
1033
1034 /* prepare channel attributes for recording */
1035 static void
1036 trident_rec_setup(struct trident_state *state)
1037 {
1038         u16 w;
1039         u8 bval;
1040
1041         struct trident_card *card = state->card;
1042         struct dmabuf *dmabuf = &state->dmabuf;
1043         struct trident_channel *channel = dmabuf->channel;
1044         unsigned int rate;
1045
1046         /* Enable AC-97 ADC (capture) */
1047         switch (card->pci_id) {
1048         case PCI_DEVICE_ID_ALI_5451:
1049                 ali_enable_special_channel(state);
1050                 break;
1051         case PCI_DEVICE_ID_SI_7018:
1052                 /* for 7018, the ac97 is always in playback/record (duplex) mode */
1053                 break;
1054         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
1055                 w = inb(TRID_REG(card, DX_ACR2_AC97_COM_STAT));
1056                 outb(w | 0x48, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
1057                 /* enable and set record channel */
1058                 outb(0x80 | channel->num, TRID_REG(card, T4D_REC_CH));
1059                 break;
1060         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
1061                 w = inw(TRID_REG(card, T4D_MISCINT));
1062                 outw(w | 0x1000, TRID_REG(card, T4D_MISCINT));
1063                 /* enable and set record channel */
1064                 outb(0x80 | channel->num, TRID_REG(card, T4D_REC_CH));
1065                 break;
1066         case PCI_DEVICE_ID_INTERG_5050:
1067                 /* don't know yet, using special channel 22 in GC1(0xd4)? */
1068                 break;
1069         default:
1070                 return;
1071         }
1072
1073         channel->lba = dmabuf->dma_handle;
1074         channel->delta = compute_rate_rec(dmabuf->rate);
1075         if ((card->pci_id == PCI_DEVICE_ID_ALI_5451) &&
1076             (channel->num == ALI_SPDIF_IN_CHANNEL)) {
1077                 rate = ali_get_spdif_in_rate(card);
1078                 if (rate == 0) {
1079                         printk(KERN_WARNING "trident: ALi 5451 "
1080                                "S/PDIF input setup error!\n");
1081                         rate = 48000;
1082                 }
1083                 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
1084                 if (bval & 0x10) {
1085                         outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
1086                         printk(KERN_WARNING "trident: cleared ALi "
1087                                "5451 S/PDIF parity error flag.\n");
1088                 }
1089
1090                 if (rate != 48000)
1091                         channel->delta = ((rate << 12) / dmabuf->rate) & 0x0000ffff;
1092         }
1093
1094         channel->eso = dmabuf->dmasize >> sample_shift[dmabuf->fmt];
1095         channel->eso -= 1;
1096
1097         if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
1098                 channel->attribute = 0;
1099         }
1100
1101         channel->fm_vol = 0x0;
1102
1103         channel->control = CHANNEL_LOOP;
1104         if (dmabuf->fmt & TRIDENT_FMT_16BIT) {
1105                 /* 16-bits */
1106                 channel->control |= CHANNEL_16BITS;
1107                 /* signed */
1108                 channel->control |= CHANNEL_SIGNED;
1109         }
1110         if (dmabuf->fmt & TRIDENT_FMT_STEREO)
1111                 /* stereo */
1112                 channel->control |= CHANNEL_STEREO;
1113
1114         pr_debug("trident: trident_rec_setup, LBA = 0x%08x, Delat = 0x%08x, "
1115                  "ESO = 0x%08x, Control = 0x%08x\n", channel->lba,
1116                  channel->delta, channel->eso, channel->control);
1117
1118         trident_write_voice_regs(state);
1119 }
1120
1121 /* get current playback/recording dma buffer pointer (byte offset from LBA),
1122    called with spinlock held! */
1123 static inline unsigned
1124 trident_get_dma_addr(struct trident_state *state)
1125 {
1126         struct dmabuf *dmabuf = &state->dmabuf;
1127         u32 cso;
1128
1129         if (!dmabuf->enable)
1130                 return 0;
1131
1132         outb(dmabuf->channel->num, TRID_REG(state->card, T4D_LFO_GC_CIR));
1133
1134         switch (state->card->pci_id) {
1135         case PCI_DEVICE_ID_ALI_5451:
1136         case PCI_DEVICE_ID_SI_7018:
1137         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
1138         case PCI_DEVICE_ID_INTERG_5050:
1139                 /* 16 bits ESO, CSO for 7018 and DX */
1140                 cso = inw(TRID_REG(state->card, CH_DX_CSO_ALPHA_FMS + 2));
1141                 break;
1142         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
1143                 /* 24 bits ESO, CSO for NX */
1144                 cso = inl(TRID_REG(state->card, CH_NX_DELTA_CSO)) & 0x00ffffff;
1145                 break;
1146         default:
1147                 return 0;
1148         }
1149
1150         pr_debug("trident: trident_get_dma_addr: chip reported channel: %d, "
1151                  "cso = 0x%04x\n", dmabuf->channel->num, cso);
1152
1153         /* ESO and CSO are in units of Samples, convert to byte offset */
1154         cso <<= sample_shift[dmabuf->fmt];
1155
1156         return (cso % dmabuf->dmasize);
1157 }
1158
1159 /* Stop recording (lock held) */
1160 static inline void
1161 __stop_adc(struct trident_state *state)
1162 {
1163         struct dmabuf *dmabuf = &state->dmabuf;
1164         unsigned int chan_num = dmabuf->channel->num;
1165         struct trident_card *card = state->card;
1166
1167         dmabuf->enable &= ~ADC_RUNNING;
1168         trident_stop_voice(card, chan_num);
1169         trident_disable_voice_irq(card, chan_num);
1170 }
1171
1172 static void
1173 stop_adc(struct trident_state *state)
1174 {
1175         struct trident_card *card = state->card;
1176         unsigned long flags;
1177
1178         spin_lock_irqsave(&card->lock, flags);
1179         __stop_adc(state);
1180         spin_unlock_irqrestore(&card->lock, flags);
1181 }
1182
1183 static void
1184 start_adc(struct trident_state *state)
1185 {
1186         struct dmabuf *dmabuf = &state->dmabuf;
1187         unsigned int chan_num = dmabuf->channel->num;
1188         struct trident_card *card = state->card;
1189         unsigned long flags;
1190
1191         spin_lock_irqsave(&card->lock, flags);
1192         if ((dmabuf->mapped ||
1193              dmabuf->count < (signed) dmabuf->dmasize) &&
1194             dmabuf->ready) {
1195                 dmabuf->enable |= ADC_RUNNING;
1196                 trident_enable_voice_irq(card, chan_num);
1197                 trident_start_voice(card, chan_num);
1198         }
1199         spin_unlock_irqrestore(&card->lock, flags);
1200 }
1201
1202 /* stop playback (lock held) */
1203 static inline void
1204 __stop_dac(struct trident_state *state)
1205 {
1206         struct dmabuf *dmabuf = &state->dmabuf;
1207         unsigned int chan_num = dmabuf->channel->num;
1208         struct trident_card *card = state->card;
1209
1210         dmabuf->enable &= ~DAC_RUNNING;
1211         trident_stop_voice(card, chan_num);
1212         if (state->chans_num == 6) {
1213                 trident_stop_voice(card, state->other_states[0]->
1214                                    dmabuf.channel->num);
1215                 trident_stop_voice(card, state->other_states[1]->
1216                                    dmabuf.channel->num);
1217                 trident_stop_voice(card, state->other_states[2]->
1218                                    dmabuf.channel->num);
1219                 trident_stop_voice(card, state->other_states[3]->
1220                                    dmabuf.channel->num);
1221         }
1222         trident_disable_voice_irq(card, chan_num);
1223 }
1224
1225 static void
1226 stop_dac(struct trident_state *state)
1227 {
1228         struct trident_card *card = state->card;
1229         unsigned long flags;
1230
1231         spin_lock_irqsave(&card->lock, flags);
1232         __stop_dac(state);
1233         spin_unlock_irqrestore(&card->lock, flags);
1234 }
1235
1236 static void
1237 start_dac(struct trident_state *state)
1238 {
1239         struct dmabuf *dmabuf = &state->dmabuf;
1240         unsigned int chan_num = dmabuf->channel->num;
1241         struct trident_card *card = state->card;
1242         unsigned long flags;
1243
1244         spin_lock_irqsave(&card->lock, flags);
1245         if ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) {
1246                 dmabuf->enable |= DAC_RUNNING;
1247                 trident_enable_voice_irq(card, chan_num);
1248                 trident_start_voice(card, chan_num);
1249                 if (state->chans_num == 6) {
1250                         trident_start_voice(card, state->other_states[0]->
1251                                             dmabuf.channel->num);
1252                         trident_start_voice(card, state->other_states[1]->
1253                                             dmabuf.channel->num);
1254                         trident_start_voice(card, state->other_states[2]->
1255                                             dmabuf.channel->num);
1256                         trident_start_voice(card, state->other_states[3]->
1257                                             dmabuf.channel->num);
1258                 }
1259         }
1260         spin_unlock_irqrestore(&card->lock, flags);
1261 }
1262
1263 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
1264 #define DMABUF_MINORDER 1
1265
1266 /* alloc a DMA buffer of with a buffer of this order */
1267 static int
1268 alloc_dmabuf(struct dmabuf *dmabuf, struct pci_dev *pci_dev, int order)
1269 {
1270         void *rawbuf = NULL;
1271         struct page *page, *pend;
1272
1273         if (!(rawbuf = pci_alloc_consistent(pci_dev, PAGE_SIZE << order,
1274                                             &dmabuf->dma_handle)))
1275                 return -ENOMEM;
1276
1277         pr_debug("trident: allocated %ld (order = %d) bytes at %p\n",
1278                  PAGE_SIZE << order, order, rawbuf);
1279
1280         dmabuf->ready = dmabuf->mapped = 0;
1281         dmabuf->rawbuf = rawbuf;
1282         dmabuf->buforder = order;
1283
1284         /* now mark the pages as reserved; otherwise */
1285         /* remap_page_range doesn't do what we want */
1286         pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
1287         for (page = virt_to_page(rawbuf); page <= pend; page++)
1288                 SetPageReserved(page);
1289
1290         return 0;
1291 }
1292
1293 /* allocate the main DMA buffer, playback and recording buffer should be */
1294 /* allocated separately */
1295 static int
1296 alloc_main_dmabuf(struct trident_state *state)
1297 {
1298         struct dmabuf *dmabuf = &state->dmabuf;
1299         int order;
1300         int ret = -ENOMEM;
1301
1302         /* alloc as big a chunk as we can, FIXME: is this necessary ?? */
1303         for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
1304                 if (!(ret = alloc_dmabuf(dmabuf, state->card->pci_dev, order)))
1305                         return 0;
1306                 /* else try again */
1307         }
1308         return ret;
1309 }
1310
1311 /* deallocate a DMA buffer */
1312 static void
1313 dealloc_dmabuf(struct dmabuf *dmabuf, struct pci_dev *pci_dev)
1314 {
1315         struct page *page, *pend;
1316
1317         if (dmabuf->rawbuf) {
1318                 /* undo marking the pages as reserved */
1319                 pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
1320                 for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
1321                         ClearPageReserved(page);
1322                 pci_free_consistent(pci_dev, PAGE_SIZE << dmabuf->buforder,
1323                                     dmabuf->rawbuf, dmabuf->dma_handle);
1324                 dmabuf->rawbuf = NULL;
1325         }
1326         dmabuf->mapped = dmabuf->ready = 0;
1327 }
1328
1329 static int
1330 prog_dmabuf(struct trident_state *state, enum dmabuf_mode rec)
1331 {
1332         struct dmabuf *dmabuf = &state->dmabuf;
1333         unsigned bytepersec;
1334         struct trident_state *s = state;
1335         unsigned bufsize, dma_nums;
1336         unsigned long flags;
1337         int ret, i, order;
1338
1339         if ((ret = lock_set_fmt(state)) < 0)
1340                 return ret;
1341
1342         if (state->chans_num == 6)
1343                 dma_nums = 5;
1344         else
1345                 dma_nums = 1;
1346
1347         for (i = 0; i < dma_nums; i++) {
1348                 if (i > 0) {
1349                         s = state->other_states[i - 1];
1350                         dmabuf = &s->dmabuf;
1351                         dmabuf->fmt = state->dmabuf.fmt;
1352                         dmabuf->rate = state->dmabuf.rate;
1353                 }
1354
1355                 spin_lock_irqsave(&s->card->lock, flags);
1356                 dmabuf->hwptr = dmabuf->swptr = dmabuf->total_bytes = 0;
1357                 dmabuf->count = dmabuf->error = 0;
1358                 spin_unlock_irqrestore(&s->card->lock, flags);
1359
1360                 /* allocate DMA buffer if not allocated yet */
1361                 if (!dmabuf->rawbuf) {
1362                         if (i == 0) {
1363                                 if ((ret = alloc_main_dmabuf(state))) {
1364                                         unlock_set_fmt(state);
1365                                         return ret;
1366                                 }
1367                         } else {
1368                                 ret = -ENOMEM;
1369                                 order = state->dmabuf.buforder - 1;
1370                                 if (order >= DMABUF_MINORDER) {
1371                                         ret = alloc_dmabuf(dmabuf,
1372                                                            state->card->pci_dev,
1373                                                            order);
1374                                 }
1375                                 if (ret) {
1376                                         /* release the main DMA buffer */
1377                                         dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
1378                                         /* release the auxiliary DMA buffers */
1379                                         for (i -= 2; i >= 0; i--)
1380                                                 dealloc_dmabuf(&state->other_states[i]->dmabuf,
1381                                                                state->card->pci_dev);
1382                                         unlock_set_fmt(state);
1383                                         return ret;
1384                                 }
1385                         }
1386                 }
1387                 /* FIXME: figure out all this OSS fragment stuff */
1388                 bytepersec = dmabuf->rate << sample_shift[dmabuf->fmt];
1389                 bufsize = PAGE_SIZE << dmabuf->buforder;
1390                 if (dmabuf->ossfragshift) {
1391                         if ((1000 << dmabuf->ossfragshift) < bytepersec)
1392                                 dmabuf->fragshift = ld2(bytepersec / 1000);
1393                         else
1394                                 dmabuf->fragshift = dmabuf->ossfragshift;
1395                 } else {
1396                         /* lets hand out reasonable big ass buffers by default */
1397                         dmabuf->fragshift = (dmabuf->buforder + PAGE_SHIFT - 2);
1398                 }
1399                 dmabuf->numfrag = bufsize >> dmabuf->fragshift;
1400                 while (dmabuf->numfrag < 4 && dmabuf->fragshift > 3) {
1401                         dmabuf->fragshift--;
1402                         dmabuf->numfrag = bufsize >> dmabuf->fragshift;
1403                 }
1404                 dmabuf->fragsize = 1 << dmabuf->fragshift;
1405                 if (dmabuf->ossmaxfrags >= 4 && dmabuf->ossmaxfrags < dmabuf->numfrag)
1406                         dmabuf->numfrag = dmabuf->ossmaxfrags;
1407                 dmabuf->fragsamples = dmabuf->fragsize >> sample_shift[dmabuf->fmt];
1408                 dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
1409
1410                 memset(dmabuf->rawbuf, (dmabuf->fmt & TRIDENT_FMT_16BIT) ? 0 : 0x80,
1411                        dmabuf->dmasize);
1412
1413                 spin_lock_irqsave(&s->card->lock, flags);
1414                 if (rec == DM_RECORD)
1415                         trident_rec_setup(s);
1416                 else /* DM_PLAYBACK */
1417                         trident_play_setup(s);
1418
1419                 spin_unlock_irqrestore(&s->card->lock, flags);
1420
1421                 /* set the ready flag for the dma buffer */
1422                 dmabuf->ready = 1;
1423
1424                 pr_debug("trident: prog_dmabuf(%d), sample rate = %d, "
1425                          "format = %d, numfrag = %d, fragsize = %d "
1426                          "dmasize = %d\n", dmabuf->channel->num,
1427                          dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1428                          dmabuf->fragsize, dmabuf->dmasize);
1429         }
1430         unlock_set_fmt(state);
1431         return 0;
1432 }
1433
1434
1435 static inline int prog_dmabuf_record(struct trident_state* state)
1436 {
1437         return prog_dmabuf(state, DM_RECORD);
1438 }
1439
1440 static inline int prog_dmabuf_playback(struct trident_state* state)
1441 {
1442         return prog_dmabuf(state, DM_PLAYBACK);
1443 }
1444
1445 /* we are doing quantum mechanics here, the buffer can only be empty, half or full filled i.e.
1446    |------------|------------|   or   |xxxxxxxxxxxx|------------|   or   |xxxxxxxxxxxx|xxxxxxxxxxxx|
1447    but we almost always get this
1448    |xxxxxx------|------------|   or   |xxxxxxxxxxxx|xxxxx-------|
1449    so we have to clear the tail space to "silence"
1450    |xxxxxx000000|------------|   or   |xxxxxxxxxxxx|xxxxxx000000|
1451 */
1452 static void
1453 trident_clear_tail(struct trident_state *state)
1454 {
1455         struct dmabuf *dmabuf = &state->dmabuf;
1456         unsigned swptr;
1457         unsigned char silence = (dmabuf->fmt & TRIDENT_FMT_16BIT) ? 0 : 0x80;
1458         unsigned int len;
1459         unsigned long flags;
1460
1461         spin_lock_irqsave(&state->card->lock, flags);
1462         swptr = dmabuf->swptr;
1463         spin_unlock_irqrestore(&state->card->lock, flags);
1464
1465         if (swptr == 0 || swptr == dmabuf->dmasize / 2 ||
1466             swptr == dmabuf->dmasize)
1467                 return;
1468
1469         if (swptr < dmabuf->dmasize / 2)
1470                 len = dmabuf->dmasize / 2 - swptr;
1471         else
1472                 len = dmabuf->dmasize - swptr;
1473
1474         memset(dmabuf->rawbuf + swptr, silence, len);
1475         if (state->card->pci_id != PCI_DEVICE_ID_ALI_5451) {
1476                 spin_lock_irqsave(&state->card->lock, flags);
1477                 dmabuf->swptr += len;
1478                 dmabuf->count += len;
1479                 spin_unlock_irqrestore(&state->card->lock, flags);
1480         }
1481
1482         /* restart the dma machine in case it is halted */
1483         start_dac(state);
1484 }
1485
1486 static int
1487 drain_dac(struct trident_state *state, int nonblock)
1488 {
1489         DECLARE_WAITQUEUE(wait, current);
1490         struct dmabuf *dmabuf = &state->dmabuf;
1491         unsigned long flags;
1492         unsigned long tmo;
1493         int count;
1494         unsigned long diff = 0;
1495
1496         if (dmabuf->mapped || !dmabuf->ready)
1497                 return 0;
1498
1499         add_wait_queue(&dmabuf->wait, &wait);
1500         for (;;) {
1501                 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1502                    every time to make the process really go to sleep */
1503                 set_current_state(TASK_INTERRUPTIBLE);
1504
1505                 spin_lock_irqsave(&state->card->lock, flags);
1506                 count = dmabuf->count;
1507                 spin_unlock_irqrestore(&state->card->lock, flags);
1508
1509                 if (count <= 0)
1510                         break;
1511
1512                 if (signal_pending(current))
1513                         break;
1514
1515                 if (nonblock) {
1516                         remove_wait_queue(&dmabuf->wait, &wait);
1517                         set_current_state(TASK_RUNNING);
1518                         return -EBUSY;
1519                 }
1520
1521                 /* No matter how much data is left in the buffer, we have to wait until
1522                    CSO == ESO/2 or CSO == ESO when address engine interrupts */
1523                 if (state->card->pci_id == PCI_DEVICE_ID_ALI_5451 ||
1524                     state->card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
1525                         diff = dmabuf->swptr - trident_get_dma_addr(state) + dmabuf->dmasize;
1526                         diff = diff % (dmabuf->dmasize);
1527                         tmo = (diff * HZ) / dmabuf->rate;
1528                 } else {
1529                         tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1530                 }
1531                 tmo >>= sample_shift[dmabuf->fmt];
1532                 if (!schedule_timeout(tmo ? tmo : 1) && tmo) {
1533                         break;
1534                 }
1535         }
1536         remove_wait_queue(&dmabuf->wait, &wait);
1537         set_current_state(TASK_RUNNING);
1538         if (signal_pending(current))
1539                 return -ERESTARTSYS;
1540
1541         return 0;
1542 }
1543
1544 /* update buffer manangement pointers, especially, */
1545 /* dmabuf->count and dmabuf->hwptr */
1546 static void
1547 trident_update_ptr(struct trident_state *state)
1548 {
1549         struct dmabuf *dmabuf = &state->dmabuf;
1550         unsigned hwptr, swptr;
1551         int clear_cnt = 0;
1552         int diff;
1553         unsigned char silence;
1554         unsigned half_dmasize;
1555
1556         /* update hardware pointer */
1557         hwptr = trident_get_dma_addr(state);
1558         diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1559         dmabuf->hwptr = hwptr;
1560         dmabuf->total_bytes += diff;
1561
1562         /* error handling and process wake up for ADC */
1563         if (dmabuf->enable == ADC_RUNNING) {
1564                 if (dmabuf->mapped) {
1565                         dmabuf->count -= diff;
1566                         if (dmabuf->count >= (signed) dmabuf->fragsize)
1567                                 wake_up(&dmabuf->wait);
1568                 } else {
1569                         dmabuf->count += diff;
1570
1571                         if (dmabuf->count < 0 ||
1572                             dmabuf->count > dmabuf->dmasize) {
1573                                 /* buffer underrun or buffer overrun, */
1574                                 /* we have no way to recover it here, just */
1575                                 /* stop the machine and let the process */
1576                                 /* force hwptr and swptr to sync */
1577                                 __stop_adc(state);
1578                                 dmabuf->error++;
1579                         }
1580                         if (dmabuf->count < (signed) dmabuf->dmasize / 2)
1581                                 wake_up(&dmabuf->wait);
1582                 }
1583         }
1584
1585         /* error handling and process wake up for DAC */
1586         if (dmabuf->enable == DAC_RUNNING) {
1587                 if (dmabuf->mapped) {
1588                         dmabuf->count += diff;
1589                         if (dmabuf->count >= (signed) dmabuf->fragsize)
1590                                 wake_up(&dmabuf->wait);
1591                 } else {
1592                         dmabuf->count -= diff;
1593
1594                         if (dmabuf->count < 0 ||
1595                             dmabuf->count > dmabuf->dmasize) {
1596                                 /* buffer underrun or buffer overrun, we have no way to recover
1597                                    it here, just stop the machine and let the process force hwptr
1598                                    and swptr to sync */
1599                                 __stop_dac(state);
1600                                 dmabuf->error++;
1601                         } else if (!dmabuf->endcleared) {
1602                                 swptr = dmabuf->swptr;
1603                                 silence = (dmabuf->fmt & TRIDENT_FMT_16BIT ? 0 : 0x80);
1604                                 if (dmabuf->update_flag & ALI_ADDRESS_INT_UPDATE) {
1605                                         /* We must clear end data of 1/2 dmabuf if needed.
1606                                            According to 1/2 algorithm of Address Engine Interrupt,
1607                                            check the validation of the data of half dmasize. */
1608                                         half_dmasize = dmabuf->dmasize / 2;
1609                                         if ((diff = hwptr - half_dmasize) < 0)
1610                                                 diff = hwptr;
1611                                         if ((dmabuf->count + diff) < half_dmasize) {
1612                                                 //there is invalid data in the end of half buffer
1613                                                 if ((clear_cnt = half_dmasize - swptr) < 0)
1614                                                         clear_cnt += half_dmasize;
1615                                                 //clear the invalid data
1616                                                 memset(dmabuf->rawbuf + swptr, silence, clear_cnt);
1617                                                 if (state->chans_num == 6) {
1618                                                         clear_cnt = clear_cnt / 2;
1619                                                         swptr = swptr / 2;
1620                                                         memset(state->other_states[0]->dmabuf.rawbuf + swptr,
1621                                                                silence, clear_cnt);
1622                                                         memset(state->other_states[1]->dmabuf.rawbuf + swptr,
1623                                                                silence, clear_cnt);
1624                                                         memset(state->other_states[2]->dmabuf.rawbuf + swptr,
1625                                                                silence, clear_cnt);
1626                                                         memset(state->other_states[3]->dmabuf.rawbuf + swptr,
1627                                                                silence, clear_cnt);
1628                                                 }
1629                                                 dmabuf->endcleared = 1;
1630                                         }
1631                                 } else if (dmabuf->count < (signed) dmabuf->fragsize) {
1632                                         clear_cnt = dmabuf->fragsize;
1633                                         if ((swptr + clear_cnt) > dmabuf->dmasize)
1634                                                 clear_cnt = dmabuf->dmasize - swptr;
1635                                         memset(dmabuf->rawbuf + swptr, silence, clear_cnt);
1636                                         if (state->chans_num == 6) {
1637                                                 clear_cnt = clear_cnt / 2;
1638                                                 swptr = swptr / 2;
1639                                                 memset(state->other_states[0]->dmabuf.rawbuf + swptr,
1640                                                        silence, clear_cnt);
1641                                                 memset(state->other_states[1]->dmabuf.rawbuf + swptr,
1642                                                        silence, clear_cnt);
1643                                                 memset(state->other_states[2]->dmabuf.rawbuf + swptr,
1644                                                        silence, clear_cnt);
1645                                                 memset(state->other_states[3]->dmabuf.rawbuf + swptr,
1646                                                        silence, clear_cnt);
1647                                         }
1648                                         dmabuf->endcleared = 1;
1649                                 }
1650                         }
1651                         /* trident_update_ptr is called by interrupt handler or by process via
1652                            ioctl/poll, we only wake up the waiting process when we have more
1653                            than 1/2 buffer free (always true for interrupt handler) */
1654                         if (dmabuf->count < (signed) dmabuf->dmasize / 2)
1655                                 wake_up(&dmabuf->wait);
1656                 }
1657         }
1658         dmabuf->update_flag &= ~ALI_ADDRESS_INT_UPDATE;
1659 }
1660
1661 static void
1662 trident_address_interrupt(struct trident_card *card)
1663 {
1664         int i;
1665         struct trident_state *state;
1666         unsigned int channel;
1667
1668         /* Update the pointers for all channels we are running. */
1669         /* FIXME: should read interrupt status only once */
1670         for (i = 0; i < NR_HW_CH; i++) {
1671                 channel = 63 - i;
1672                 if (trident_check_channel_interrupt(card, channel)) {
1673                         trident_ack_channel_interrupt(card, channel);
1674                         if ((state = card->states[i]) != NULL) {
1675                                 trident_update_ptr(state);
1676                         } else {
1677                                 printk(KERN_WARNING "trident: spurious channel "
1678                                        "irq %d.\n", channel);
1679                                 trident_stop_voice(card, channel);
1680                                 trident_disable_voice_irq(card, channel);
1681                         }
1682                 }
1683         }
1684 }
1685
1686 static void
1687 ali_hwvol_control(struct trident_card *card, int opt)
1688 {
1689         u16 dwTemp, volume[2], mute, diff, *pVol[2];
1690
1691         dwTemp = ali_ac97_read(card->ac97_codec[0], 0x02);
1692         mute = dwTemp & 0x8000;
1693         volume[0] = dwTemp & 0x001f;
1694         volume[1] = (dwTemp & 0x1f00) >> 8;
1695         if (volume[0] < volume[1]) {
1696                 pVol[0] = &volume[0];
1697                 pVol[1] = &volume[1];
1698         } else {
1699                 pVol[1] = &volume[0];
1700                 pVol[0] = &volume[1];
1701         }
1702         diff = *(pVol[1]) - *(pVol[0]);
1703
1704         if (opt == 1) {         // MUTE
1705                 dwTemp ^= 0x8000;
1706                 ali_ac97_write(card->ac97_codec[0],
1707                                0x02, dwTemp);
1708         } else if (opt == 2) {  // Down
1709                 if (mute)
1710                         return;
1711                 if (*(pVol[1]) < 0x001f) {
1712                         (*pVol[1])++;
1713                         *(pVol[0]) = *(pVol[1]) - diff;
1714                 }
1715                 dwTemp &= 0xe0e0;
1716                 dwTemp |= (volume[0]) | (volume[1] << 8);
1717                 ali_ac97_write(card->ac97_codec[0], 0x02, dwTemp);
1718                 card->ac97_codec[0]->mixer_state[0] = ((32 - volume[0]) * 25 / 8) |
1719                         (((32 - volume[1]) * 25 / 8) << 8);
1720         } else if (opt == 4) {  // Up
1721                 if (mute)
1722                         return;
1723                 if (*(pVol[0]) > 0) {
1724                         (*pVol[0])--;
1725                         *(pVol[1]) = *(pVol[0]) + diff;
1726                 }
1727                 dwTemp &= 0xe0e0;
1728                 dwTemp |= (volume[0]) | (volume[1] << 8);
1729                 ali_ac97_write(card->ac97_codec[0], 0x02, dwTemp);
1730                 card->ac97_codec[0]->mixer_state[0] = ((32 - volume[0]) * 25 / 8) |
1731                         (((32 - volume[1]) * 25 / 8) << 8);
1732         } else {
1733                 /* Nothing needs doing */
1734         }
1735 }
1736
1737 /*
1738  *      Re-enable reporting of vol change after 0.1 seconds
1739  */
1740
1741 static void
1742 ali_timeout(unsigned long ptr)
1743 {
1744         struct trident_card *card = (struct trident_card *) ptr;
1745         u16 temp = 0;
1746
1747         /* Enable GPIO IRQ (MISCINT bit 18h) */
1748         temp = inw(TRID_REG(card, T4D_MISCINT + 2));
1749         temp |= 0x0004;
1750         outw(temp, TRID_REG(card, T4D_MISCINT + 2));
1751 }
1752
1753 /*
1754  *      Set up the timer to clear the vol change notification
1755  */
1756
1757 static void
1758 ali_set_timer(struct trident_card *card)
1759 {
1760         /* Add Timer Routine to Enable GPIO IRQ */
1761         del_timer(&card->timer);        /* Never queue twice */
1762         card->timer.function = ali_timeout;
1763         card->timer.data = (unsigned long) card;
1764         card->timer.expires = jiffies + HZ / 10;
1765         add_timer(&card->timer);
1766 }
1767
1768 /*
1769  *      Process a GPIO event
1770  */
1771
1772 static void
1773 ali_queue_task(struct trident_card *card, int opt)
1774 {
1775         u16 temp;
1776
1777         /* Disable GPIO IRQ (MISCINT bit 18h) */
1778         temp = inw(TRID_REG(card, T4D_MISCINT + 2));
1779         temp &= (u16) (~0x0004);
1780         outw(temp, TRID_REG(card, T4D_MISCINT + 2));
1781
1782         /* Adjust the volume */
1783         ali_hwvol_control(card, opt);
1784
1785         /* Set the timer for 1/10th sec */
1786         ali_set_timer(card);
1787 }
1788
1789 static void
1790 cyber_address_interrupt(struct trident_card *card)
1791 {
1792         int i, irq_status;
1793         struct trident_state *state;
1794         unsigned int channel;
1795
1796         /* Update the pointers for all channels we are running. */
1797         /* FIXED: read interrupt status only once */
1798         irq_status = inl(TRID_REG(card, T4D_AINT_A));
1799
1800         pr_debug("cyber_address_interrupt: irq_status 0x%X\n", irq_status);
1801
1802         for (i = 0; i < NR_HW_CH; i++) {
1803                 channel = 31 - i;
1804                 if (irq_status & (1 << channel)) {
1805                         /* clear bit by writing a 1, zeroes are ignored */
1806                         outl((1 << channel), TRID_REG(card, T4D_AINT_A));
1807
1808                         pr_debug("cyber_interrupt: channel %d\n", channel);
1809
1810                         if ((state = card->states[i]) != NULL) {
1811                                 trident_update_ptr(state);
1812                         } else {
1813                                 printk(KERN_WARNING "cyber5050: spurious "
1814                                        "channel irq %d.\n", channel);
1815                                 trident_stop_voice(card, channel);
1816                                 trident_disable_voice_irq(card, channel);
1817                         }
1818                 }
1819         }
1820 }
1821
1822 static irqreturn_t
1823 trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1824 {
1825         struct trident_card *card = (struct trident_card *) dev_id;
1826         u32 event;
1827         u32 gpio;
1828
1829         spin_lock(&card->lock);
1830         event = inl(TRID_REG(card, T4D_MISCINT));
1831
1832         pr_debug("trident: trident_interrupt called, MISCINT = 0x%08x\n",
1833                  event);
1834
1835         if (event & ADDRESS_IRQ) {
1836                 card->address_interrupt(card);
1837         }
1838
1839         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
1840                 /* GPIO IRQ (H/W Volume Control) */
1841                 event = inl(TRID_REG(card, T4D_MISCINT));
1842                 if (event & (1 << 25)) {
1843                         gpio = inl(TRID_REG(card, ALI_GPIO));
1844                         if (!timer_pending(&card->timer))
1845                                 ali_queue_task(card, gpio & 0x07);
1846                 }
1847                 event = inl(TRID_REG(card, T4D_MISCINT));
1848                 outl(event | (ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
1849                      TRID_REG(card, T4D_MISCINT));
1850                 spin_unlock(&card->lock);
1851                 return IRQ_HANDLED;
1852         }
1853
1854         /* manually clear interrupt status, bad hardware design, blame T^2 */
1855         outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
1856              TRID_REG(card, T4D_MISCINT));
1857         spin_unlock(&card->lock);
1858         return IRQ_HANDLED;
1859 }
1860
1861 /* in this loop, dmabuf.count signifies the amount of data that is waiting */
1862 /* to be copied to the user's buffer.  it is filled by the dma machine and */
1863 /* drained by this loop. */
1864 static ssize_t
1865 trident_read(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
1866 {
1867         struct trident_state *state = (struct trident_state *)file->private_data;
1868         struct dmabuf *dmabuf = &state->dmabuf;
1869         ssize_t ret = 0;
1870         unsigned long flags;
1871         unsigned swptr;
1872         int cnt;
1873
1874         pr_debug("trident: trident_read called, count = %d\n", count);
1875
1876         VALIDATE_STATE(state);
1877         if (ppos != &file->f_pos)
1878                 return -ESPIPE;
1879
1880         if (dmabuf->mapped)
1881                 return -ENXIO;
1882         if (!access_ok(VERIFY_WRITE, buffer, count))
1883                 return -EFAULT;
1884
1885         down(&state->sem);
1886         if (!dmabuf->ready && (ret = prog_dmabuf_record(state)))
1887                 goto out;
1888
1889         while (count > 0) {
1890                 spin_lock_irqsave(&state->card->lock, flags);
1891                 if (dmabuf->count > (signed) dmabuf->dmasize) {
1892                         /* buffer overrun, we are recovering from */
1893                         /* sleep_on_timeout, resync hwptr and swptr, */
1894                         /* make process flush the buffer */
1895                         dmabuf->count = dmabuf->dmasize;
1896                         dmabuf->swptr = dmabuf->hwptr;
1897                 }
1898                 swptr = dmabuf->swptr;
1899                 cnt = dmabuf->dmasize - swptr;
1900                 if (dmabuf->count < cnt)
1901                         cnt = dmabuf->count;
1902                 spin_unlock_irqrestore(&state->card->lock, flags);
1903
1904                 if (cnt > count)
1905                         cnt = count;
1906                 if (cnt <= 0) {
1907                         unsigned long tmo;
1908                         /* buffer is empty, start the dma machine and */
1909                         /* wait for data to be recorded */
1910                         start_adc(state);
1911                         if (file->f_flags & O_NONBLOCK) {
1912                                 if (!ret)
1913                                         ret = -EAGAIN;
1914                                 goto out;
1915                         }
1916
1917                         up(&state->sem);
1918                         /* No matter how much space left in the buffer, */
1919                         /* we have to wait until CSO == ESO/2 or CSO == ESO */
1920                         /* when address engine interrupts */
1921                         tmo = (dmabuf->dmasize * HZ) / (dmabuf->rate * 2);
1922                         tmo >>= sample_shift[dmabuf->fmt];
1923                         /* There are two situations when sleep_on_timeout returns, one is when
1924                            the interrupt is serviced correctly and the process is waked up by
1925                            ISR ON TIME. Another is when timeout is expired, which means that
1926                            either interrupt is NOT serviced correctly (pending interrupt) or it
1927                            is TOO LATE for the process to be scheduled to run (scheduler latency)
1928                            which results in a (potential) buffer overrun. And worse, there is
1929                            NOTHING we can do to prevent it. */
1930                         if (!interruptible_sleep_on_timeout(&dmabuf->wait, tmo)) {
1931                                 pr_debug(KERN_ERR "trident: recording schedule timeout, "
1932                                          "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1933                                          dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
1934                                          dmabuf->hwptr, dmabuf->swptr);
1935
1936                                 /* a buffer overrun, we delay the recovery until next time the
1937                                    while loop begin and we REALLY have space to record */
1938                         }
1939                         if (signal_pending(current)) {
1940                                 if (!ret)
1941                                         ret = -ERESTARTSYS;
1942                                 goto out;
1943                         }
1944                         down(&state->sem);
1945                         if (dmabuf->mapped) {
1946                                 if (!ret)
1947                                         ret = -ENXIO;
1948                                 goto out;
1949                         }
1950                         continue;
1951                 }
1952
1953                 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1954                         if (!ret)
1955                                 ret = -EFAULT;
1956                         goto out;
1957                 }
1958
1959                 swptr = (swptr + cnt) % dmabuf->dmasize;
1960
1961                 spin_lock_irqsave(&state->card->lock, flags);
1962                 dmabuf->swptr = swptr;
1963                 dmabuf->count -= cnt;
1964                 spin_unlock_irqrestore(&state->card->lock, flags);
1965
1966                 count -= cnt;
1967                 buffer += cnt;
1968                 ret += cnt;
1969                 start_adc(state);
1970         }
1971 out:
1972         up(&state->sem);
1973         return ret;
1974 }
1975
1976 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1977    the soundcard.  it is drained by the dma machine and filled by this loop. */
1978
1979 static ssize_t
1980 trident_write(struct file *file, const char __user *buffer, size_t count, loff_t * ppos)
1981 {
1982         struct trident_state *state = (struct trident_state *)file->private_data;
1983         struct dmabuf *dmabuf = &state->dmabuf;
1984         ssize_t ret;
1985         unsigned long flags;
1986         unsigned swptr;
1987         int cnt;
1988         unsigned int state_cnt;
1989         unsigned int copy_count;
1990         int lret; /* for lock_set_fmt */
1991
1992         pr_debug("trident: trident_write called, count = %d\n", count);
1993
1994         VALIDATE_STATE(state);
1995         if (ppos != &file->f_pos)
1996                 return -ESPIPE;
1997
1998         /*
1999          *      Guard against an mmap or ioctl while writing
2000          */
2001
2002         down(&state->sem);
2003
2004         if (dmabuf->mapped) {
2005                 ret = -ENXIO;
2006                 goto out;
2007         }
2008         if (!dmabuf->ready && (ret = prog_dmabuf_playback(state)))
2009                 goto out;
2010
2011         if (!access_ok(VERIFY_READ, buffer, count)) {
2012                 ret = -EFAULT;
2013                 goto out;
2014         }
2015
2016         ret = 0;
2017
2018         while (count > 0) {
2019                 spin_lock_irqsave(&state->card->lock, flags);
2020                 if (dmabuf->count < 0) {
2021                         /* buffer underrun, we are recovering from */
2022                         /* sleep_on_timeout, resync hwptr and swptr */
2023                         dmabuf->count = 0;
2024                         dmabuf->swptr = dmabuf->hwptr;
2025                 }
2026                 swptr = dmabuf->swptr;
2027                 cnt = dmabuf->dmasize - swptr;
2028                 if (dmabuf->count + cnt > dmabuf->dmasize)
2029                         cnt = dmabuf->dmasize - dmabuf->count;
2030                 spin_unlock_irqrestore(&state->card->lock, flags);
2031
2032                 if (cnt > count)
2033                         cnt = count;
2034                 if (cnt <= 0) {
2035                         unsigned long tmo;
2036                         /* buffer is full, start the dma machine and */
2037                         /* wait for data to be played */
2038                         start_dac(state);
2039                         if (file->f_flags & O_NONBLOCK) {
2040                                 if (!ret)
2041                                         ret = -EAGAIN;
2042                                 goto out;
2043                         }
2044                         /* No matter how much data left in the buffer, */
2045                         /* we have to wait until CSO == ESO/2 or CSO == ESO */
2046                         /* when address engine interrupts */
2047                         lock_set_fmt(state);
2048                         tmo = (dmabuf->dmasize * HZ) / (dmabuf->rate * 2);
2049                         tmo >>= sample_shift[dmabuf->fmt];
2050                         unlock_set_fmt(state);
2051                         up(&state->sem);
2052
2053                         /* There are two situations when sleep_on_timeout */
2054                         /* returns, one is when the interrupt is serviced */
2055                         /* correctly and the process is waked up by ISR */
2056                         /* ON TIME. Another is when timeout is expired, which */
2057                         /* means that either interrupt is NOT serviced */
2058                         /* correctly (pending interrupt) or it is TOO LATE */
2059                         /* for the process to be scheduled to run */
2060                         /* (scheduler latency) which results in a (potential) */
2061                         /* buffer underrun. And worse, there is NOTHING we */
2062                         /* can do to prevent it. */
2063                         if (!interruptible_sleep_on_timeout(&dmabuf->wait, tmo)) {
2064                                 pr_debug(KERN_ERR "trident: playback schedule "
2065                                          "timeout, dmasz %u fragsz %u count %i "
2066                                          "hwptr %u swptr %u\n", dmabuf->dmasize,
2067                                          dmabuf->fragsize, dmabuf->count,
2068                                          dmabuf->hwptr, dmabuf->swptr);
2069
2070                                 /* a buffer underrun, we delay the recovery */
2071                                 /* until next time the while loop begin and */
2072                                 /* we REALLY have data to play */
2073                         }
2074                         if (signal_pending(current)) {
2075                                 if (!ret)
2076                                         ret = -ERESTARTSYS;
2077                                 goto out_nolock;
2078                         }
2079                         down(&state->sem);
2080                         if (dmabuf->mapped) {
2081                                 if (!ret)
2082                                         ret = -ENXIO;
2083                                 goto out;
2084                         }
2085                         continue;
2086                 }
2087                 if ((lret = lock_set_fmt(state)) < 0) {
2088                         ret = lret;
2089                         goto out;
2090                 }
2091
2092                 if (state->chans_num == 6) {
2093                         copy_count = 0;
2094                         state_cnt = 0;
2095                         if (ali_write_5_1(state, buffer, cnt, &copy_count,
2096                                           &state_cnt) == -EFAULT) {
2097                                 if (state_cnt) {
2098                                         swptr = (swptr + state_cnt) % dmabuf->dmasize;
2099                                         spin_lock_irqsave(&state->card->lock, flags);
2100                                         dmabuf->swptr = swptr;
2101                                         dmabuf->count += state_cnt;
2102                                         dmabuf->endcleared = 0;
2103                                         spin_unlock_irqrestore(&state->card->lock, flags);
2104                                 }
2105                                 ret += copy_count;
2106                                 if (!ret)
2107                                         ret = -EFAULT;
2108                                 unlock_set_fmt(state);
2109                                 goto out;
2110                         }
2111                 } else {
2112                         if (copy_from_user(dmabuf->rawbuf + swptr,
2113                                            buffer, cnt)) {
2114                                 if (!ret)
2115                                         ret = -EFAULT;
2116                                 unlock_set_fmt(state);
2117                                 goto out;
2118                         }
2119                         state_cnt = cnt;
2120                 }
2121                 unlock_set_fmt(state);
2122
2123                 swptr = (swptr + state_cnt) % dmabuf->dmasize;
2124
2125                 spin_lock_irqsave(&state->card->lock, flags);
2126                 dmabuf->swptr = swptr;
2127                 dmabuf->count += state_cnt;
2128                 dmabuf->endcleared = 0;
2129                 spin_unlock_irqrestore(&state->card->lock, flags);
2130
2131                 count -= cnt;
2132                 buffer += cnt;
2133                 ret += cnt;
2134                 start_dac(state);
2135         }
2136 out:
2137         up(&state->sem);
2138 out_nolock:
2139         return ret;
2140 }
2141
2142 /* No kernel lock - we have our own spinlock */
2143 static unsigned int
2144 trident_poll(struct file *file, struct poll_table_struct *wait)
2145 {
2146         struct trident_state *state = (struct trident_state *)file->private_data;
2147         struct dmabuf *dmabuf = &state->dmabuf;
2148         unsigned long flags;
2149         unsigned int mask = 0;
2150
2151         VALIDATE_STATE(state);
2152
2153         /*
2154          *      Guard against a parallel poll and write causing multiple
2155          *      prog_dmabuf events
2156          */
2157
2158         down(&state->sem);
2159
2160         if (file->f_mode & FMODE_WRITE) {
2161                 if (!dmabuf->ready && prog_dmabuf_playback(state)) {
2162                         up(&state->sem);
2163                         return 0;
2164                 }
2165                 poll_wait(file, &dmabuf->wait, wait);
2166         }
2167         if (file->f_mode & FMODE_READ) {
2168                 if (!dmabuf->ready && prog_dmabuf_record(state)) {
2169                         up(&state->sem);
2170                         return 0;
2171                 }
2172                 poll_wait(file, &dmabuf->wait, wait);
2173         }
2174
2175         up(&state->sem);
2176
2177         spin_lock_irqsave(&state->card->lock, flags);
2178         trident_update_ptr(state);
2179         if (file->f_mode & FMODE_READ) {
2180                 if (dmabuf->count >= (signed) dmabuf->fragsize)
2181                         mask |= POLLIN | POLLRDNORM;
2182         }
2183         if (file->f_mode & FMODE_WRITE) {
2184                 if (dmabuf->mapped) {
2185                         if (dmabuf->count >= (signed) dmabuf->fragsize)
2186                                 mask |= POLLOUT | POLLWRNORM;
2187                 } else {
2188                         if ((signed) dmabuf->dmasize >= dmabuf->count +
2189                             (signed) dmabuf->fragsize)
2190                                 mask |= POLLOUT | POLLWRNORM;
2191                 }
2192         }
2193         spin_unlock_irqrestore(&state->card->lock, flags);
2194
2195         return mask;
2196 }
2197
2198 static int
2199 trident_mmap(struct file *file, struct vm_area_struct *vma)
2200 {
2201         struct trident_state *state = (struct trident_state *)file->private_data;
2202         struct dmabuf *dmabuf = &state->dmabuf;
2203         int ret = -EINVAL;
2204         unsigned long size;
2205
2206         VALIDATE_STATE(state);
2207
2208         /*
2209          *      Lock against poll read write or mmap creating buffers. Also lock
2210          *      a read or write against an mmap.
2211          */
2212
2213         down(&state->sem);
2214
2215         if (vma->vm_flags & VM_WRITE) {
2216                 if ((ret = prog_dmabuf_playback(state)) != 0)
2217                         goto out;
2218         } else if (vma->vm_flags & VM_READ) {
2219                 if ((ret = prog_dmabuf_record(state)) != 0)
2220                         goto out;
2221         } else
2222                 goto out;
2223
2224         ret = -EINVAL;
2225         if (vma->vm_pgoff != 0)
2226                 goto out;
2227         size = vma->vm_end - vma->vm_start;
2228         if (size > (PAGE_SIZE << dmabuf->buforder))
2229                 goto out;
2230         ret = -EAGAIN;
2231         if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf),
2232                              size, vma->vm_page_prot))
2233                 goto out;
2234         dmabuf->mapped = 1;
2235         ret = 0;
2236 out:
2237         up(&state->sem);
2238         return ret;
2239 }
2240
2241 static int
2242 trident_ioctl(struct inode *inode, struct file *file,
2243               unsigned int cmd, unsigned long arg)
2244 {
2245         struct trident_state *state = (struct trident_state *)file->private_data;
2246         struct dmabuf *dmabuf = &state->dmabuf;
2247         unsigned long flags;
2248         audio_buf_info abinfo;
2249         count_info cinfo;
2250         int val, mapped, ret = 0;
2251         struct trident_card *card = state->card;
2252         void __user *argp = (void __user *)arg;
2253         int __user *p = argp;
2254
2255         VALIDATE_STATE(state);
2256
2257
2258         mapped = ((file->f_mode & (FMODE_WRITE | FMODE_READ)) && dmabuf->mapped);
2259
2260         pr_debug("trident: trident_ioctl, command = %2d, arg = 0x%08x\n",
2261                  _IOC_NR(cmd), arg ? *p : 0);
2262
2263         switch (cmd) {
2264         case OSS_GETVERSION:
2265                 ret = put_user(SOUND_VERSION, p);
2266                 break;
2267
2268         case SNDCTL_DSP_RESET:
2269                 /* FIXME: spin_lock ? */
2270                 if (file->f_mode & FMODE_WRITE) {
2271                         stop_dac(state);
2272                         synchronize_irq(card->irq);
2273                         dmabuf->ready = 0;
2274                         dmabuf->swptr = dmabuf->hwptr = 0;
2275                         dmabuf->count = dmabuf->total_bytes = 0;
2276                 }
2277                 if (file->f_mode & FMODE_READ) {
2278                         stop_adc(state);
2279                         synchronize_irq(card->irq);
2280                         dmabuf->ready = 0;
2281                         dmabuf->swptr = dmabuf->hwptr = 0;
2282                         dmabuf->count = dmabuf->total_bytes = 0;
2283                 }
2284                 break;
2285
2286         case SNDCTL_DSP_SYNC:
2287                 if (file->f_mode & FMODE_WRITE)
2288                         ret = drain_dac(state, file->f_flags & O_NONBLOCK);
2289                 break;
2290
2291         case SNDCTL_DSP_SPEED:  /* set smaple rate */
2292                 if (get_user(val, p)) {
2293                         ret = -EFAULT;
2294                         break;
2295                 }
2296                 if (val >= 0) {
2297                         if (file->f_mode & FMODE_WRITE) {
2298                                 stop_dac(state);
2299                                 dmabuf->ready = 0;
2300                                 spin_lock_irqsave(&state->card->lock, flags);
2301                                 trident_set_dac_rate(state, val);
2302                                 spin_unlock_irqrestore(&state->card->lock, flags);
2303                         }
2304                         if (file->f_mode & FMODE_READ) {
2305                                 stop_adc(state);
2306                                 dmabuf->ready = 0;
2307                                 spin_lock_irqsave(&state->card->lock, flags);
2308                                 trident_set_adc_rate(state, val);
2309                                 spin_unlock_irqrestore(&state->card->lock, flags);
2310                         }
2311                 }
2312                 ret = put_user(dmabuf->rate, p);
2313                 break;
2314
2315         case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2316                 if (get_user(val, p)) {
2317                         ret = -EFAULT;
2318                         break;
2319                 }
2320                 if ((ret = lock_set_fmt(state)) < 0)
2321                         return ret;
2322
2323                 if (file->f_mode & FMODE_WRITE) {
2324                         stop_dac(state);
2325                         dmabuf->ready = 0;
2326                         if (val)
2327                                 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2328                         else
2329                                 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2330                 }
2331                 if (file->f_mode & FMODE_READ) {
2332                         stop_adc(state);
2333                         dmabuf->ready = 0;
2334                         if (val)
2335                                 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2336                         else
2337                                 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2338                 }
2339                 unlock_set_fmt(state);
2340                 break;
2341
2342         case SNDCTL_DSP_GETBLKSIZE:
2343                 if (file->f_mode & FMODE_WRITE) {
2344                         if ((val = prog_dmabuf_playback(state)))
2345                                 ret = val;
2346                         else
2347                                 ret = put_user(dmabuf->fragsize, p);
2348                         break;
2349                 }
2350                 if (file->f_mode & FMODE_READ) {
2351                         if ((val = prog_dmabuf_record(state)))
2352                                 ret = val;
2353                         else
2354                                 ret = put_user(dmabuf->fragsize, p);
2355                         break;
2356                 }
2357                 /* neither READ nor WRITE? is this even possible? */
2358                 ret = -EINVAL;
2359                 break;
2360
2361
2362         case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format */
2363                 ret = put_user(AFMT_S16_LE | AFMT_U16_LE | AFMT_S8 |
2364                                AFMT_U8, p);
2365                 break;
2366
2367         case SNDCTL_DSP_SETFMT: /* Select sample format */
2368                 if (get_user(val, p)) {
2369                         ret = -EFAULT;
2370                         break;
2371                 }
2372                 if ((ret = lock_set_fmt(state)) < 0)
2373                         return ret;
2374
2375                 if (val != AFMT_QUERY) {
2376                         if (file->f_mode & FMODE_WRITE) {
2377                                 stop_dac(state);
2378                                 dmabuf->ready = 0;
2379                                 if (val == AFMT_S16_LE)
2380                                         dmabuf->fmt |= TRIDENT_FMT_16BIT;
2381                                 else
2382                                         dmabuf->fmt &= ~TRIDENT_FMT_16BIT;
2383                         }
2384                         if (file->f_mode & FMODE_READ) {
2385                                 stop_adc(state);
2386                                 dmabuf->ready = 0;
2387                                 if (val == AFMT_S16_LE)
2388                                         dmabuf->fmt |= TRIDENT_FMT_16BIT;
2389                                 else
2390                                         dmabuf->fmt &= ~TRIDENT_FMT_16BIT;
2391                         }
2392                 }
2393                 unlock_set_fmt(state);
2394                 ret = put_user((dmabuf->fmt & TRIDENT_FMT_16BIT) ? AFMT_S16_LE :
2395                                AFMT_U8, p);
2396                 break;
2397
2398         case SNDCTL_DSP_CHANNELS:
2399                 if (get_user(val, p)) {
2400                         ret = -EFAULT;
2401                         break;
2402                 }
2403                 if (val != 0) {
2404                         if ((ret = lock_set_fmt(state)) < 0)
2405                                 return ret;
2406
2407                         if (file->f_mode & FMODE_WRITE) {
2408                                 stop_dac(state);
2409                                 dmabuf->ready = 0;
2410
2411                                 //prevent from memory leak
2412                                 if ((state->chans_num > 2) && (state->chans_num != val)) {
2413                                         ali_free_other_states_resources(state);
2414                                         state->chans_num = 1;
2415                                 }
2416
2417                                 if (val >= 2) {
2418
2419                                         dmabuf->fmt |= TRIDENT_FMT_STEREO;
2420                                         if ((val == 6) && (state->card->pci_id == PCI_DEVICE_ID_ALI_5451)) {
2421                                                 if (card->rec_channel_use_count > 0) {
2422                                                         printk(KERN_ERR "trident: Record is "
2423                                                                "working on the card!\n");
2424                                                         ret = -EBUSY;
2425                                                         unlock_set_fmt(state);
2426                                                         break;
2427                                                 }
2428
2429                                                 ret = ali_setup_multi_channels(state->card, 6);
2430                                                 if (ret < 0) {
2431                                                         unlock_set_fmt(state);
2432                                                         break;
2433                                                 }
2434                                                 down(&state->card->open_sem);
2435                                                 ret = ali_allocate_other_states_resources(state, 6);
2436                                                 if (ret < 0) {
2437                                                         up(&state->card->open_sem);
2438                                                         unlock_set_fmt(state);
2439                                                         break;
2440                                                 }
2441                                                 state->card->multi_channel_use_count++;
2442                                                 up(&state->card->open_sem);
2443                                         } else
2444                                                 val = 2;        /*yield to 2-channels */
2445                                 } else
2446                                         dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2447                                 state->chans_num = val;
2448                         }
2449                         if (file->f_mode & FMODE_READ) {
2450                                 stop_adc(state);
2451                                 dmabuf->ready = 0;
2452                                 if (val >= 2) {
2453                                         if (!((file->f_mode & FMODE_WRITE) &&
2454                                               (val == 6)))
2455                                                 val = 2;
2456                                         dmabuf->fmt |= TRIDENT_FMT_STEREO;
2457                                 } else
2458                                         dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2459                                 state->chans_num = val;
2460                         }
2461                         unlock_set_fmt(state);
2462                 }
2463                 ret = put_user(val, p);
2464                 break;
2465
2466         case SNDCTL_DSP_POST:
2467                 /* Cause the working fragment to be output */
2468                 break;
2469
2470         case SNDCTL_DSP_SUBDIVIDE:
2471                 if (dmabuf->subdivision) {
2472                         ret = -EINVAL;
2473                         break;
2474                 }
2475                 if (get_user(val, p)) {
2476                         ret = -EFAULT;
2477                         break;
2478                 }
2479                 if (val != 1 && val != 2 && val != 4) {
2480                         ret = -EINVAL;
2481                         break;
2482                 }
2483                 dmabuf->subdivision = val;
2484                 break;
2485
2486         case SNDCTL_DSP_SETFRAGMENT:
2487                 if (get_user(val, p)) {
2488                         ret = -EFAULT;
2489                         break;
2490                 }
2491
2492                 dmabuf->ossfragshift = val & 0xffff;
2493                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2494                 if (dmabuf->ossfragshift < 4)
2495                         dmabuf->ossfragshift = 4;
2496                 if (dmabuf->ossfragshift > 15)
2497                         dmabuf->ossfragshift = 15;
2498                 if (dmabuf->ossmaxfrags < 4)
2499                         dmabuf->ossmaxfrags = 4;
2500
2501                 break;
2502
2503         case SNDCTL_DSP_GETOSPACE:
2504                 if (!(file->f_mode & FMODE_WRITE)) {
2505                         ret = -EINVAL;
2506                         break;
2507                 }
2508                 if (!dmabuf->ready && (val = prog_dmabuf_playback(state)) != 0) {
2509                         ret = val;
2510                         break;
2511                 }
2512                 spin_lock_irqsave(&state->card->lock, flags);
2513                 trident_update_ptr(state);
2514                 abinfo.fragsize = dmabuf->fragsize;
2515                 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2516                 abinfo.fragstotal = dmabuf->numfrag;
2517                 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2518                 spin_unlock_irqrestore(&state->card->lock, flags);
2519                 ret = copy_to_user(argp, &abinfo, sizeof (abinfo)) ?
2520                         -EFAULT : 0;
2521                 break;
2522
2523         case SNDCTL_DSP_GETISPACE:
2524                 if (!(file->f_mode & FMODE_READ)) {
2525                         ret = -EINVAL;
2526                         break;
2527                 }
2528                 if (!dmabuf->ready && (val = prog_dmabuf_record(state)) != 0) {
2529                         ret = val;
2530                         break;
2531                 }
2532                 spin_lock_irqsave(&state->card->lock, flags);
2533                 trident_update_ptr(state);
2534                 abinfo.fragsize = dmabuf->fragsize;
2535                 abinfo.bytes = dmabuf->count;
2536                 abinfo.fragstotal = dmabuf->numfrag;
2537                 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2538                 spin_unlock_irqrestore(&state->card->lock, flags);
2539                 ret = copy_to_user(argp, &abinfo, sizeof (abinfo)) ?
2540                         -EFAULT : 0;
2541                 break;
2542
2543         case SNDCTL_DSP_NONBLOCK:
2544                 file->f_flags |= O_NONBLOCK;
2545                 break;
2546
2547         case SNDCTL_DSP_GETCAPS:
2548                 ret = put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2549                                DSP_CAP_MMAP | DSP_CAP_BIND, p);
2550                 break;
2551
2552         case SNDCTL_DSP_GETTRIGGER:
2553                 val = 0;
2554                 if ((file->f_mode & FMODE_READ) && dmabuf->enable)
2555                         val |= PCM_ENABLE_INPUT;
2556                 if ((file->f_mode & FMODE_WRITE) && dmabuf->enable)
2557                         val |= PCM_ENABLE_OUTPUT;
2558                 ret = put_user(val, p);
2559                 break;
2560
2561         case SNDCTL_DSP_SETTRIGGER:
2562                 if (get_user(val, p)) {
2563                         ret = -EFAULT;
2564                         break;
2565                 }
2566                 if (file->f_mode & FMODE_READ) {
2567                         if (val & PCM_ENABLE_INPUT) {
2568                                 if (!dmabuf->ready &&
2569                                     (ret = prog_dmabuf_record(state)))
2570                                         break;
2571                                 start_adc(state);
2572                         } else
2573                                 stop_adc(state);
2574                 }
2575                 if (file->f_mode & FMODE_WRITE) {
2576                         if (val & PCM_ENABLE_OUTPUT) {
2577                                 if (!dmabuf->ready &&
2578                                     (ret = prog_dmabuf_playback(state)))
2579                                         break;
2580                                 start_dac(state);
2581                         } else
2582                                 stop_dac(state);
2583                 }
2584                 break;
2585
2586         case SNDCTL_DSP_GETIPTR:
2587                 if (!(file->f_mode & FMODE_READ)) {
2588                         ret = -EINVAL;
2589                         break;
2590                 }
2591                 if (!dmabuf->ready && (val = prog_dmabuf_record(state))
2592                     != 0) {
2593                         ret = val;
2594                         break;
2595                 }
2596                 spin_lock_irqsave(&state->card->lock, flags);
2597                 trident_update_ptr(state);
2598                 cinfo.bytes = dmabuf->total_bytes;
2599                 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2600                 cinfo.ptr = dmabuf->hwptr;
2601                 if (dmabuf->mapped)
2602                         dmabuf->count &= dmabuf->fragsize - 1;
2603                 spin_unlock_irqrestore(&state->card->lock, flags);
2604                 ret = copy_to_user(argp, &cinfo, sizeof (cinfo)) ?
2605                         -EFAULT : 0;
2606                 break;
2607
2608         case SNDCTL_DSP_GETOPTR:
2609                 if (!(file->f_mode & FMODE_WRITE)) {
2610                         ret = -EINVAL;
2611                         break;
2612                 }
2613                 if (!dmabuf->ready && (val = prog_dmabuf_playback(state))
2614                     != 0) {
2615                         ret = val;
2616                         break;
2617                 }
2618
2619                 spin_lock_irqsave(&state->card->lock, flags);
2620                 trident_update_ptr(state);
2621                 cinfo.bytes = dmabuf->total_bytes;
2622                 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2623                 cinfo.ptr = dmabuf->hwptr;
2624                 if (dmabuf->mapped)
2625                         dmabuf->count &= dmabuf->fragsize - 1;
2626                 spin_unlock_irqrestore(&state->card->lock, flags);
2627                 ret = copy_to_user(argp, &cinfo, sizeof (cinfo)) ?
2628                         -EFAULT : 0;
2629                 break;
2630
2631         case SNDCTL_DSP_SETDUPLEX:
2632                 ret = -EINVAL;
2633                 break;
2634
2635         case SNDCTL_DSP_GETODELAY:
2636                 if (!(file->f_mode & FMODE_WRITE)) {
2637                         ret = -EINVAL;
2638                         break;
2639                 }
2640                 if (!dmabuf->ready && (val = prog_dmabuf_playback(state)) != 0) {
2641                         ret = val;
2642                         break;
2643                 }
2644                 spin_lock_irqsave(&state->card->lock, flags);
2645                 trident_update_ptr(state);
2646                 val = dmabuf->count;
2647                 spin_unlock_irqrestore(&state->card->lock, flags);
2648                 ret = put_user(val, p);
2649                 break;
2650
2651         case SOUND_PCM_READ_RATE:
2652                 ret = put_user(dmabuf->rate, p);
2653                 break;
2654
2655         case SOUND_PCM_READ_CHANNELS:
2656                 ret = put_user((dmabuf->fmt & TRIDENT_FMT_STEREO) ? 2 : 1,
2657                                p);
2658                 break;
2659
2660         case SOUND_PCM_READ_BITS:
2661                 ret = put_user((dmabuf->fmt & TRIDENT_FMT_16BIT) ? AFMT_S16_LE :
2662                                AFMT_U8, p);
2663                 break;
2664
2665         case SNDCTL_DSP_GETCHANNELMASK:
2666                 ret = put_user(DSP_BIND_FRONT | DSP_BIND_SURR |
2667                                DSP_BIND_CENTER_LFE,  p);
2668                 break;
2669
2670         case SNDCTL_DSP_BIND_CHANNEL:
2671                 if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
2672                         ret = -EINVAL;
2673                         break;
2674                 }
2675
2676                 if (get_user(val, p)) {
2677                         ret = -EFAULT;
2678                         break;
2679                 }
2680                 if (val == DSP_BIND_QUERY) {
2681                         val = dmabuf->channel->attribute | 0x3c00;
2682                         val = attr2mask[val >> 8];
2683                 } else {
2684                         dmabuf->ready = 0;
2685                         if (file->f_mode & FMODE_READ)
2686                                 dmabuf->channel->attribute = (CHANNEL_REC |
2687                                                               SRC_ENABLE);
2688                         if (file->f_mode & FMODE_WRITE)
2689                                 dmabuf->channel->attribute = (CHANNEL_SPC_PB |
2690                                                               SRC_ENABLE);
2691                         dmabuf->channel->attribute |= mask2attr[ffs(val)];
2692                 }
2693                 ret = put_user(val, p);
2694                 break;
2695
2696         case SNDCTL_DSP_MAPINBUF:
2697         case SNDCTL_DSP_MAPOUTBUF:
2698         case SNDCTL_DSP_SETSYNCRO:
2699         case SOUND_PCM_WRITE_FILTER:
2700         case SOUND_PCM_READ_FILTER:
2701         default:
2702                 ret = -EINVAL;
2703                 break;
2704
2705         }
2706         return ret;
2707 }
2708
2709 static int
2710 trident_open(struct inode *inode, struct file *file)
2711 {
2712         int i = 0;
2713         int minor = iminor(inode);
2714         struct trident_card *card = devs;
2715         struct trident_state *state = NULL;
2716         struct dmabuf *dmabuf = NULL;
2717
2718         /* Added by Matt Wu 01-05-2001 */
2719         /* TODO: there's some redundacy here wrt the check below */
2720         /* for multi_use_count > 0. Should we return -EBUSY or find */
2721         /* a different card? for now, don't break current behaviour */
2722         /* -- mulix */
2723         if (file->f_mode & FMODE_READ) {
2724                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2725                         if (card->multi_channel_use_count > 0)
2726                                 return -EBUSY;
2727                 }
2728         }
2729
2730         /* find an available virtual channel (instance of /dev/dsp) */
2731         while (card != NULL) {
2732                 down(&card->open_sem);
2733                 if (file->f_mode & FMODE_READ) {
2734                         /* Skip opens on cards that are in 6 channel mode */
2735                         if (card->multi_channel_use_count > 0) {
2736                                 up(&card->open_sem);
2737                                 card = card->next;
2738                                 continue;
2739                         }
2740                 }
2741                 for (i = 0; i < NR_HW_CH; i++) {
2742                         if (card->states[i] == NULL) {
2743                                 state = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
2744                                 if (state == NULL) {
2745                                         up(&card->open_sem);
2746                                         return -ENOMEM;
2747                                 }
2748                                 memset(state, 0, sizeof(*state));
2749                                 init_MUTEX(&state->sem);
2750                                 dmabuf = &state->dmabuf;
2751                                 goto found_virt;
2752                         }
2753                 }
2754                 up(&card->open_sem);
2755                 card = card->next;
2756         }
2757         /* no more virtual channel avaiable */
2758         if (!state) {
2759                 return -ENODEV;
2760         }
2761       found_virt:
2762         /* found a free virtual channel, allocate hardware channels */
2763         if (file->f_mode & FMODE_READ)
2764                 dmabuf->channel = card->alloc_rec_pcm_channel(card);
2765         else
2766                 dmabuf->channel = card->alloc_pcm_channel(card);
2767
2768         if (dmabuf->channel == NULL) {
2769                 kfree(card->states[i]);
2770                 card->states[i] = NULL;
2771                 return -ENODEV;
2772         }
2773
2774         /* initialize the virtual channel */
2775         state->virt = i;
2776         state->card = card;
2777         state->magic = TRIDENT_STATE_MAGIC;
2778         init_waitqueue_head(&dmabuf->wait);
2779         file->private_data = state;
2780
2781         /* set default sample format. According to OSS Programmer's */
2782         /* Guide  /dev/dsp should be default to unsigned 8-bits, mono, */
2783         /* with sample rate 8kHz and /dev/dspW will accept 16-bits sample */
2784         if (file->f_mode & FMODE_WRITE) {
2785                 dmabuf->fmt &= ~TRIDENT_FMT_MASK;
2786                 if ((minor & 0x0f) == SND_DEV_DSP16)
2787                         dmabuf->fmt |= TRIDENT_FMT_16BIT;
2788                 dmabuf->ossfragshift = 0;
2789                 dmabuf->ossmaxfrags = 0;
2790                 dmabuf->subdivision = 0;
2791                 if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
2792                         /* set default channel attribute to normal playback */
2793                         dmabuf->channel->attribute = CHANNEL_PB;
2794                 }
2795                 trident_set_dac_rate(state, 8000);
2796         }
2797
2798         if (file->f_mode & FMODE_READ) {
2799                 /* FIXME: Trident 4d can only record in signed 16-bits stereo, */
2800                 /* 48kHz sample, to be dealed with in trident_set_adc_rate() ?? */
2801                 dmabuf->fmt &= ~TRIDENT_FMT_MASK;
2802                 if ((minor & 0x0f) == SND_DEV_DSP16)
2803                         dmabuf->fmt |= TRIDENT_FMT_16BIT;
2804                 dmabuf->ossfragshift = 0;
2805                 dmabuf->ossmaxfrags = 0;
2806                 dmabuf->subdivision = 0;
2807                 if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
2808                         /* set default channel attribute to 0x8a80, record from
2809                            PCM L/R FIFO and mono = (left + right + 1)/2 */
2810                         dmabuf->channel->attribute = (CHANNEL_REC | PCM_LR |
2811                                                       MONO_MIX);
2812                 }
2813                 trident_set_adc_rate(state, 8000);
2814
2815                 /* Added by Matt Wu 01-05-2001 */
2816                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451)
2817                         card->rec_channel_use_count++;
2818         }
2819
2820         state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2821         up(&card->open_sem);
2822
2823         pr_debug("trident: open virtual channel %d, hard channel %d\n",
2824                  state->virt, dmabuf->channel->num);
2825
2826         return 0;
2827 }
2828
2829 static int
2830 trident_release(struct inode *inode, struct file *file)
2831 {
2832         struct trident_state *state = (struct trident_state *)file->private_data;
2833         struct trident_card *card;
2834         struct dmabuf *dmabuf;
2835
2836         VALIDATE_STATE(state);
2837
2838         card = state->card;
2839         dmabuf = &state->dmabuf;
2840
2841         if (file->f_mode & FMODE_WRITE) {
2842                 trident_clear_tail(state);
2843                 drain_dac(state, file->f_flags & O_NONBLOCK);
2844         }
2845
2846         pr_debug("trident: closing virtual channel %d, hard channel %d\n",
2847                  state->virt, dmabuf->channel->num);
2848
2849         /* stop DMA state machine and free DMA buffers/channels */
2850         down(&card->open_sem);
2851
2852         if (file->f_mode & FMODE_WRITE) {
2853                 stop_dac(state);
2854                 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
2855                 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
2856
2857                 /* Added by Matt Wu */
2858                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2859                         if (state->chans_num > 2) {
2860                                 if (card->multi_channel_use_count-- < 0)
2861                                         card->multi_channel_use_count = 0;
2862                                 if (card->multi_channel_use_count == 0)
2863                                         ali_close_multi_channels();
2864                                 ali_free_other_states_resources(state);
2865                         }
2866                 }
2867         }
2868         if (file->f_mode & FMODE_READ) {
2869                 stop_adc(state);
2870                 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
2871                 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
2872
2873                 /* Added by Matt Wu */
2874                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2875                         if (card->rec_channel_use_count-- < 0)
2876                                 card->rec_channel_use_count = 0;
2877                 }
2878         }
2879
2880         card->states[state->virt] = NULL;
2881         kfree(state);
2882
2883         /* we're covered by the open_sem */
2884         up(&card->open_sem);
2885
2886         return 0;
2887 }
2888
2889 static /*const */ struct file_operations trident_audio_fops = {
2890         .owner = THIS_MODULE,
2891         .llseek = no_llseek,
2892         .read = trident_read,
2893         .write = trident_write,
2894         .poll = trident_poll,
2895         .ioctl = trident_ioctl,
2896         .mmap = trident_mmap,
2897         .open = trident_open,
2898         .release = trident_release,
2899 };
2900
2901 /* trident specific AC97 functions */
2902 /* Write AC97 codec registers */
2903 static void
2904 trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val)
2905 {
2906         struct trident_card *card = (struct trident_card *)codec->private_data;
2907         unsigned int address, mask, busy;
2908         unsigned short count = 0xffff;
2909         unsigned long flags;
2910         u32 data;
2911
2912         data = ((u32) val) << 16;
2913
2914         switch (card->pci_id) {
2915         default:
2916         case PCI_DEVICE_ID_SI_7018:
2917                 address = SI_AC97_WRITE;
2918                 mask = SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY;
2919                 if (codec->id)
2920                         mask |= SI_AC97_SECONDARY;
2921                 busy = SI_AC97_BUSY_WRITE;
2922                 break;
2923         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
2924                 address = DX_ACR0_AC97_W;
2925                 mask = busy = DX_AC97_BUSY_WRITE;
2926                 break;
2927         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
2928                 address = NX_ACR1_AC97_W;
2929                 mask = NX_AC97_BUSY_WRITE;
2930                 if (codec->id)
2931                         mask |= NX_AC97_WRITE_SECONDARY;
2932                 busy = NX_AC97_BUSY_WRITE;
2933                 break;
2934         case PCI_DEVICE_ID_INTERG_5050:
2935                 address = SI_AC97_WRITE;
2936                 mask = busy = SI_AC97_BUSY_WRITE;
2937                 if (codec->id)
2938                         mask |= SI_AC97_SECONDARY;
2939                 break;
2940         }
2941
2942         spin_lock_irqsave(&card->lock, flags);
2943         do {
2944                 if ((inw(TRID_REG(card, address)) & busy) == 0)
2945                         break;
2946         } while (count--);
2947
2948         data |= (mask | (reg & AC97_REG_ADDR));
2949
2950         if (count == 0) {
2951                 printk(KERN_ERR "trident: AC97 CODEC write timed out.\n");
2952                 spin_unlock_irqrestore(&card->lock, flags);
2953                 return;
2954         }
2955
2956         outl(data, TRID_REG(card, address));
2957         spin_unlock_irqrestore(&card->lock, flags);
2958 }
2959
2960 /* Read AC97 codec registers */
2961 static u16
2962 trident_ac97_get(struct ac97_codec *codec, u8 reg)
2963 {
2964         struct trident_card *card = (struct trident_card *)codec->private_data;
2965         unsigned int address, mask, busy;
2966         unsigned short count = 0xffff;
2967         unsigned long flags;
2968         u32 data;
2969
2970         switch (card->pci_id) {
2971         default:
2972         case PCI_DEVICE_ID_SI_7018:
2973                 address = SI_AC97_READ;
2974                 mask = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY;
2975                 if (codec->id)
2976                         mask |= SI_AC97_SECONDARY;
2977                 busy = SI_AC97_BUSY_READ;
2978                 break;
2979         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
2980                 address = DX_ACR1_AC97_R;
2981                 mask = busy = DX_AC97_BUSY_READ;
2982                 break;
2983         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
2984                 if (codec->id)
2985                         address = NX_ACR3_AC97_R_SECONDARY;
2986                 else
2987                         address = NX_ACR2_AC97_R_PRIMARY;
2988                 mask = NX_AC97_BUSY_READ;
2989                 busy = NX_AC97_BUSY_READ | NX_AC97_BUSY_DATA;
2990                 break;
2991         case PCI_DEVICE_ID_INTERG_5050:
2992                 address = SI_AC97_READ;
2993                 mask = busy = SI_AC97_BUSY_READ;
2994                 if (codec->id)
2995                         mask |= SI_AC97_SECONDARY;
2996                 break;
2997         }
2998
2999         data = (mask | (reg & AC97_REG_ADDR));
3000
3001         spin_lock_irqsave(&card->lock, flags);
3002         outl(data, TRID_REG(card, address));
3003         do {
3004                 data = inl(TRID_REG(card, address));
3005                 if ((data & busy) == 0)
3006                         break;
3007         } while (count--);
3008         spin_unlock_irqrestore(&card->lock, flags);
3009
3010         if (count == 0) {
3011                 printk(KERN_ERR "trident: AC97 CODEC read timed out.\n");
3012                 data = 0;
3013         }
3014         return ((u16) (data >> 16));
3015 }
3016
3017 /* rewrite ac97 read and write mixer register by hulei for ALI*/
3018 static int
3019 acquirecodecaccess(struct trident_card *card)
3020 {
3021         u16 wsemamask = 0x6000; /* bit 14..13 */
3022         u16 wsemabits;
3023         u16 wcontrol;
3024         int block = 0;
3025         int ncount = 25;
3026         while (1) {
3027                 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3028                 wsemabits = wcontrol & wsemamask;
3029
3030                 if (wsemabits == 0x4000)
3031                         return 1;       /* 0x4000 is audio ,then success */
3032                 if (ncount-- < 0)
3033                         break;
3034                 if (wsemabits == 0) {
3035                       unlock:
3036                         outl(((u32) (wcontrol & 0x1eff) | 0x00004000),
3037                              TRID_REG(card, ALI_AC97_WRITE));
3038                         continue;
3039                 }
3040                 udelay(20);
3041         }
3042         if (!block) {
3043                 pr_debug("accesscodecsemaphore: try unlock\n");
3044                 block = 1;
3045                 goto unlock;
3046         }
3047         return 0;
3048 }
3049
3050 static void
3051 releasecodecaccess(struct trident_card *card)
3052 {
3053         unsigned long wcontrol;
3054         wcontrol = inl(TRID_REG(card, ALI_AC97_WRITE));
3055         outl((wcontrol & 0xffff1eff), TRID_REG(card, ALI_AC97_WRITE));
3056 }
3057
3058 static int
3059 waitforstimertick(struct trident_card *card)
3060 {
3061         unsigned long chk1, chk2;
3062         unsigned int wcount = 0xffff;
3063         chk1 = inl(TRID_REG(card, ALI_STIMER));
3064
3065         while (1) {
3066                 chk2 = inl(TRID_REG(card, ALI_STIMER));
3067                 if ((wcount > 0) && chk1 != chk2)
3068                         return 1;
3069                 if (wcount <= 0)
3070                         break;
3071                 udelay(50);
3072         }
3073         return 0;
3074 }
3075
3076 /* Read AC97 codec registers for ALi*/
3077 static u16
3078 ali_ac97_get(struct trident_card *card, int secondary, u8 reg)
3079 {
3080         unsigned int address, mask;
3081         unsigned int ncount;
3082         unsigned long aud_reg;
3083         u32 data;
3084         u16 wcontrol;
3085         unsigned long flags;
3086
3087         if (!card)
3088                 BUG();
3089
3090         address = ALI_AC97_READ;
3091         if (card->revision == ALI_5451_V02) {
3092                 address = ALI_AC97_WRITE;
3093         }
3094         mask = ALI_AC97_READ_ACTION | ALI_AC97_AUDIO_BUSY;
3095         if (secondary)
3096                 mask |= ALI_AC97_SECONDARY;
3097
3098         spin_lock_irqsave(&card->lock, flags);
3099
3100         if (!acquirecodecaccess(card))
3101                 printk(KERN_ERR "access codec fail\n");
3102
3103         wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3104         wcontrol &= 0xfe00;
3105         wcontrol |= (0x8000 | reg);
3106         outw(wcontrol, TRID_REG(card, ALI_AC97_WRITE));
3107
3108         data = (mask | (reg & AC97_REG_ADDR));
3109
3110         if (!waitforstimertick(card)) {
3111                 printk(KERN_ERR "ali_ac97_read: BIT_CLOCK is dead\n");
3112                 goto releasecodec;
3113         }
3114
3115         udelay(20);
3116
3117         ncount = 10;
3118
3119         while (1) {
3120                 if ((inw(TRID_REG(card, ALI_AC97_WRITE)) & ALI_AC97_BUSY_READ)
3121                     != 0)
3122                         break;
3123                 if (ncount <= 0)
3124                         break;
3125                 if (ncount-- == 1) {
3126                         pr_debug("ali_ac97_read :try clear busy flag\n");
3127                         aud_reg = inl(TRID_REG(card, ALI_AC97_WRITE));
3128                         outl((aud_reg & 0xffff7fff),
3129                              TRID_REG(card, ALI_AC97_WRITE));
3130                 }
3131                 udelay(10);
3132         }
3133
3134         data = inl(TRID_REG(card, address));
3135
3136         spin_unlock_irqrestore(&card->lock, flags);
3137
3138         return ((u16) (data >> 16));
3139
3140       releasecodec:
3141         releasecodecaccess(card);
3142         spin_unlock_irqrestore(&card->lock, flags);
3143         printk(KERN_ERR "ali_ac97_read: AC97 CODEC read timed out.\n");
3144         return 0;
3145 }
3146
3147 /* Write AC97 codec registers for hulei*/
3148 static void
3149 ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val)
3150 {
3151         unsigned int address, mask;
3152         unsigned int ncount;
3153         u32 data;
3154         u16 wcontrol;
3155         unsigned long flags;
3156
3157         data = ((u32) val) << 16;
3158
3159         if (!card)
3160                 BUG();
3161
3162         address = ALI_AC97_WRITE;
3163         mask = ALI_AC97_WRITE_ACTION | ALI_AC97_AUDIO_BUSY;
3164         if (secondary)
3165                 mask |= ALI_AC97_SECONDARY;
3166         if (card->revision == ALI_5451_V02)
3167                 mask |= ALI_AC97_WRITE_MIXER_REGISTER;
3168
3169         spin_lock_irqsave(&card->lock, flags);
3170         if (!acquirecodecaccess(card))
3171                 printk(KERN_ERR "ali_ac97_write: access codec fail\n");
3172
3173         wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3174         wcontrol &= 0xff00;
3175         wcontrol |= (0x8100 | reg); /* bit 8=1: (ali1535 )reserved/ */
3176                                     /* ali1535+ write */
3177         outl((data | wcontrol), TRID_REG(card, ALI_AC97_WRITE));
3178
3179         if (!waitforstimertick(card)) {
3180                 printk(KERN_ERR "BIT_CLOCK is dead\n");
3181                 goto releasecodec;
3182         }
3183
3184         ncount = 10;
3185         while (1) {
3186                 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3187                 if (!(wcontrol & 0x8000))
3188                         break;
3189                 if (ncount <= 0)
3190                         break;
3191                 if (ncount-- == 1) {
3192                         pr_debug("ali_ac97_set :try clear busy flag!!\n");
3193                         outw(wcontrol & 0x7fff,
3194                              TRID_REG(card, ALI_AC97_WRITE));
3195                 }
3196                 udelay(10);
3197         }
3198
3199       releasecodec:
3200         releasecodecaccess(card);
3201         spin_unlock_irqrestore(&card->lock, flags);
3202         return;
3203 }
3204
3205 static void
3206 ali_enable_special_channel(struct trident_state *stat)
3207 {
3208         struct trident_card *card = stat->card;
3209         unsigned long s_channels;
3210
3211         s_channels = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3212         s_channels |= (1 << stat->dmabuf.channel->num);
3213         outl(s_channels, TRID_REG(card, ALI_GLOBAL_CONTROL));
3214 }
3215
3216 static u16
3217 ali_ac97_read(struct ac97_codec *codec, u8 reg)
3218 {
3219         int id;
3220         u16 data;
3221         struct trident_card *card = NULL;
3222
3223         /* Added by Matt Wu */
3224         if (!codec)
3225                 BUG();
3226
3227         card = (struct trident_card *) codec->private_data;
3228
3229         if (!card->mixer_regs_ready)
3230                 return ali_ac97_get(card, codec->id, reg);
3231
3232         /*
3233          *      FIXME: need to stop this caching some registers
3234          */
3235         if (codec->id)
3236                 id = 1;
3237         else
3238                 id = 0;
3239
3240         data = card->mixer_regs[reg / 2][id];
3241         return data;
3242 }
3243
3244 static void
3245 ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val)
3246 {
3247         int id;
3248         struct trident_card *card;
3249
3250         /*  Added by Matt Wu */
3251         if (!codec)
3252                 BUG();
3253
3254         card = (struct trident_card *) codec->private_data;
3255
3256         if (!card->mixer_regs_ready) {
3257                 ali_ac97_set(card, codec->id, reg, val);
3258                 return;
3259         }
3260
3261         if (codec->id)
3262                 id = 1;
3263         else
3264                 id = 0;
3265
3266         card->mixer_regs[reg / 2][id] = val;
3267         ali_ac97_set(card, codec->id, reg, val);
3268 }
3269
3270 /*
3271 flag:   ALI_SPDIF_OUT_TO_SPDIF_OUT
3272         ALI_PCM_TO_SPDIF_OUT
3273 */
3274
3275 static void
3276 ali_setup_spdif_out(struct trident_card *card, int flag)
3277 {
3278         unsigned long spdif;
3279         unsigned char ch;
3280
3281         char temp;
3282         struct pci_dev *pci_dev = NULL;
3283
3284         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3285                                   pci_dev);
3286         if (pci_dev == NULL)
3287                 return;
3288         pci_read_config_byte(pci_dev, 0x61, &temp);
3289         temp |= 0x40;
3290         pci_write_config_byte(pci_dev, 0x61, temp);
3291         pci_read_config_byte(pci_dev, 0x7d, &temp);
3292         temp |= 0x01;
3293         pci_write_config_byte(pci_dev, 0x7d, temp);
3294         pci_read_config_byte(pci_dev, 0x7e, &temp);
3295         temp &= (~0x20);
3296         temp |= 0x10;
3297         pci_write_config_byte(pci_dev, 0x7e, temp);
3298
3299         ch = inb(TRID_REG(card, ALI_SCTRL));
3300         outb(ch | ALI_SPDIF_OUT_ENABLE, TRID_REG(card, ALI_SCTRL));
3301         ch = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3302         outb(ch & ALI_SPDIF_OUT_CH_STATUS, TRID_REG(card, ALI_SPDIF_CTRL));
3303
3304         if (flag & ALI_SPDIF_OUT_TO_SPDIF_OUT) {
3305                 spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
3306                 spdif |= ALI_SPDIF_OUT_CH_ENABLE;
3307                 spdif &= ALI_SPDIF_OUT_SEL_SPDIF;
3308                 outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3309                 spdif = inw(TRID_REG(card, ALI_SPDIF_CS));
3310                 if (flag & ALI_SPDIF_OUT_NON_PCM)
3311                         spdif |= 0x0002;
3312                 else
3313                         spdif &= (~0x0002);
3314                 outw(spdif, TRID_REG(card, ALI_SPDIF_CS));
3315         } else {
3316                 spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
3317                 spdif |= ALI_SPDIF_OUT_SEL_PCM;
3318                 outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3319         }
3320 }
3321
3322 static void
3323 ali_disable_special_channel(struct trident_card *card, int ch)
3324 {
3325         unsigned long sc;
3326
3327         sc = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3328         sc &= ~(1 << ch);
3329         outl(sc, TRID_REG(card, ALI_GLOBAL_CONTROL));
3330 }
3331
3332 static void
3333 ali_disable_spdif_in(struct trident_card *card)
3334 {
3335         unsigned long spdif;
3336
3337         spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3338         spdif &= (~ALI_SPDIF_IN_SUPPORT);
3339         outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3340
3341         ali_disable_special_channel(card, ALI_SPDIF_IN_CHANNEL);
3342 }
3343
3344 static void
3345 ali_setup_spdif_in(struct trident_card *card)
3346 {
3347         unsigned long spdif;
3348
3349         //Set SPDIF IN Supported
3350         spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3351         spdif |= ALI_SPDIF_IN_SUPPORT;
3352         outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3353
3354         //Set SPDIF IN Rec
3355         spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3356         spdif |= ALI_SPDIF_IN_CH_ENABLE;
3357         outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3358
3359         spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3360         spdif |= ALI_SPDIF_IN_CH_STATUS;
3361         outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3362 /*
3363         spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3364         spdif |= ALI_SPDIF_IN_FUNC_ENABLE;
3365         outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3366 */
3367 }
3368
3369 static void
3370 ali_delay(struct trident_card *card, int interval)
3371 {
3372         unsigned long begintimer, currenttimer;
3373
3374         begintimer = inl(TRID_REG(card, ALI_STIMER));
3375         currenttimer = inl(TRID_REG(card, ALI_STIMER));
3376
3377         while (currenttimer < begintimer + interval)
3378                 currenttimer = inl(TRID_REG(card, ALI_STIMER));
3379 }
3380
3381 static void
3382 ali_detect_spdif_rate(struct trident_card *card)
3383 {
3384         u16 wval = 0;
3385         u16 count = 0;
3386         u8 bval = 0, R1 = 0, R2 = 0;
3387
3388         bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3389         bval |= 0x02;
3390         outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
3391
3392         bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3393         bval |= 0x1F;
3394         outb(bval, TRID_REG(card, ALI_SPDIF_CTRL + 1));
3395
3396         while (((R1 < 0x0B) || (R1 > 0x0E)) && (R1 != 0x12) &&
3397                count <= 50000) {
3398                 count++;
3399
3400                 ali_delay(card, 6);
3401
3402                 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3403                 R1 = bval & 0x1F;
3404         }
3405
3406         if (count > 50000) {
3407                 printk(KERN_WARNING "trident: Error in "
3408                        "ali_detect_spdif_rate!\n");
3409                 return;
3410         }
3411
3412         count = 0;
3413
3414         while (count <= 50000) {
3415                 count++;
3416
3417                 ali_delay(card, 6);
3418
3419                 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3420                 R2 = bval & 0x1F;
3421
3422                 if (R2 != R1)
3423                         R1 = R2;
3424                 else
3425                         break;
3426         }
3427
3428         if (count > 50000) {
3429                 printk(KERN_WARNING "trident: Error in "
3430                        "ali_detect_spdif_rate!\n");
3431                 return;
3432         }
3433
3434         switch (R2) {
3435         case 0x0b:
3436         case 0x0c:
3437         case 0x0d:
3438         case 0x0e:
3439                 wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
3440                 wval &= 0xE0F0;
3441                 wval |= (u16) 0x09 << 8 | (u16) 0x05;
3442                 outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
3443
3444                 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
3445                 outb(bval | 0x02, TRID_REG(card, ALI_SPDIF_CS + 3));
3446                 break;
3447
3448         case 0x12:
3449                 wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
3450                 wval &= 0xE0F0;
3451                 wval |= (u16) 0x0E << 8 | (u16) 0x08;
3452                 outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
3453
3454                 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
3455                 outb(bval | 0x03, TRID_REG(card, ALI_SPDIF_CS + 3));
3456                 break;
3457
3458         default:
3459                 break;
3460         }
3461
3462 }
3463
3464 static unsigned int
3465 ali_get_spdif_in_rate(struct trident_card *card)
3466 {
3467         u32 dwRate = 0;
3468         u8 bval = 0;
3469
3470         ali_detect_spdif_rate(card);
3471
3472         bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3473         bval &= 0x7F;
3474         bval |= 0x40;
3475         outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
3476
3477         bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3));
3478         bval &= 0x0F;
3479
3480         switch (bval) {
3481         case 0:
3482                 dwRate = 44100;
3483                 break;
3484         case 1:
3485                 dwRate = 48000;
3486                 break;
3487         case 2:
3488                 dwRate = 32000;
3489                 break;
3490         default:
3491                 // Error occurs
3492                 break;
3493         }
3494
3495         return dwRate;
3496
3497 }
3498
3499 static int
3500 ali_close_multi_channels(void)
3501 {
3502         char temp = 0;
3503         struct pci_dev *pci_dev = NULL;
3504
3505         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3506                                   pci_dev);
3507         if (pci_dev == NULL)
3508                 return -1;
3509         pci_read_config_byte(pci_dev, 0x59, &temp);
3510         temp &= ~0x80;
3511         pci_write_config_byte(pci_dev, 0x59, temp);
3512
3513         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
3514                                   pci_dev);
3515         if (pci_dev == NULL)
3516                 return -1;
3517
3518         pci_read_config_byte(pci_dev, 0xB8, &temp);
3519         temp &= ~0x20;
3520         pci_write_config_byte(pci_dev, 0xB8, temp);
3521
3522         return 0;
3523 }
3524
3525 static int
3526 ali_setup_multi_channels(struct trident_card *card, int chan_nums)
3527 {
3528         unsigned long dwValue;
3529         char temp = 0;
3530         struct pci_dev *pci_dev = NULL;
3531
3532         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3533                                   pci_dev);
3534         if (pci_dev == NULL)
3535                 return -1;
3536         pci_read_config_byte(pci_dev, 0x59, &temp);
3537         temp |= 0x80;
3538         pci_write_config_byte(pci_dev, 0x59, temp);
3539
3540         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
3541                                   pci_dev);
3542         if (pci_dev == NULL)
3543                 return -1;
3544         pci_read_config_byte(pci_dev, (int) 0xB8, &temp);
3545         temp |= 0x20;
3546         pci_write_config_byte(pci_dev, (int) 0xB8, (u8) temp);
3547         if (chan_nums == 6) {
3548                 dwValue = inl(TRID_REG(card, ALI_SCTRL)) | 0x000f0000;
3549                 outl(dwValue, TRID_REG(card, ALI_SCTRL));
3550                 mdelay(4);
3551                 dwValue = inl(TRID_REG(card, ALI_SCTRL));
3552                 if (dwValue & 0x2000000) {
3553                         ali_ac97_write(card->ac97_codec[0], 0x02, 8080);
3554                         ali_ac97_write(card->ac97_codec[0], 0x36, 0);
3555                         ali_ac97_write(card->ac97_codec[0], 0x38, 0);
3556                         /*
3557                          *      On a board with a single codec you won't get the
3558                          *      surround. On other boards configure it.
3559                          */
3560                         if (card->ac97_codec[1] != NULL) {
3561                                 ali_ac97_write(card->ac97_codec[1], 0x36, 0);
3562                                 ali_ac97_write(card->ac97_codec[1], 0x38, 0);
3563                                 ali_ac97_write(card->ac97_codec[1], 0x02, 0x0606);
3564                                 ali_ac97_write(card->ac97_codec[1], 0x18, 0x0303);
3565                                 ali_ac97_write(card->ac97_codec[1], 0x74, 0x3);
3566                         }
3567                         return 1;
3568                 }
3569         }
3570         return -EINVAL;
3571 }
3572
3573 static void
3574 ali_free_pcm_channel(struct trident_card *card, unsigned int channel)
3575 {
3576         int bank;
3577
3578         if (channel > 31)
3579                 return;
3580
3581         bank = channel >> 5;
3582         channel = channel & 0x1f;
3583
3584         card->banks[bank].bitmap &= ~(1 << (channel));
3585 }
3586
3587 static int
3588 ali_allocate_other_states_resources(struct trident_state *state, int chan_nums)
3589 {
3590         struct trident_card *card = state->card;
3591         struct trident_state *s;
3592         int i, state_count = 0;
3593         struct trident_pcm_bank *bank;
3594         struct trident_channel *channel;
3595         unsigned long num;
3596
3597         bank = &card->banks[BANK_A];
3598
3599         if (chan_nums != 6)
3600                 return 0;
3601
3602         for (i = 0; (i < ALI_CHANNELS) && (state_count != 4); i++) {
3603                 if (card->states[i])
3604                         continue;
3605
3606                 num = ali_multi_channels_5_1[state_count];
3607                 if (!(bank->bitmap & (1 << num))) {
3608                         bank->bitmap |= 1 << num;
3609                         channel = &bank->channels[num];
3610                         channel->num = num;
3611                 } else {
3612                         state_count--;
3613                         for (; state_count >= 0; state_count--) {
3614                                 kfree(state->other_states[state_count]);
3615                                 num = ali_multi_channels_5_1[state_count];
3616                                         ali_free_pcm_channel(card, num);
3617                         }
3618                         return -EBUSY;
3619                 }
3620                 s = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
3621                 if (!s) {
3622                         num = ali_multi_channels_5_1[state_count];
3623                         ali_free_pcm_channel(card, num);
3624                         state_count--;
3625                         for (; state_count >= 0; state_count--) {
3626                                 num = ali_multi_channels_5_1[state_count];
3627                                 ali_free_pcm_channel(card, num);
3628                                 kfree(state->other_states[state_count]);
3629                         }
3630                         return -ENOMEM;
3631                 }
3632                 memset(s, 0, sizeof(*state));
3633
3634                 s->dmabuf.channel = channel;
3635                 s->dmabuf.ossfragshift = s->dmabuf.ossmaxfrags =
3636                         s->dmabuf.subdivision = 0;
3637                 init_waitqueue_head(&s->dmabuf.wait);
3638                 s->magic = card->magic;
3639                 s->card = card;
3640                 s->virt = i;
3641                 ali_enable_special_channel(s);
3642                 state->other_states[state_count++] = s;
3643         }
3644
3645         if (state_count != 4) {
3646                 state_count--;
3647                 for (; state_count >= 0; state_count--) {
3648                         kfree(state->other_states[state_count]);
3649                         num = ali_multi_channels_5_1[state_count];
3650                         ali_free_pcm_channel(card, num);
3651                 }
3652                 return -EBUSY;
3653         }
3654         return 0;
3655 }
3656
3657 static void
3658 ali_save_regs(struct trident_card *card)
3659 {
3660         unsigned long flags;
3661         int i, j;
3662
3663         spin_lock_irqsave(&card->lock, flags);
3664
3665         ali_registers.global_regs[0x2c] = inl(TRID_REG(card, T4D_MISCINT));
3666         //ali_registers.global_regs[0x20] = inl(TRID_REG(card,T4D_START_A));
3667         ali_registers.global_regs[0x21] = inl(TRID_REG(card, T4D_STOP_A));
3668
3669         //disable all IRQ bits
3670         outl(ALI_DISABLE_ALL_IRQ, TRID_REG(card, T4D_MISCINT));
3671
3672         for (i = 1; i < ALI_MIXER_REGS; i++)
3673                 ali_registers.mixer_regs[i] = ali_ac97_read(card->ac97_codec[0],
3674                                                             i * 2);
3675
3676         for (i = 0; i < ALI_GLOBAL_REGS; i++) {
3677                 if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A))
3678                         continue;
3679                 ali_registers.global_regs[i] = inl(TRID_REG(card, i * 4));
3680         }
3681
3682         for (i = 0; i < ALI_CHANNELS; i++) {
3683                 outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
3684                 for (j = 0; j < ALI_CHANNEL_REGS; j++)
3685                         ali_registers.channel_regs[i][j] = inl(TRID_REG(card,
3686                                                                         j * 4 + 0xe0));
3687         }
3688
3689         //Stop all HW channel
3690         outl(ALI_STOP_ALL_CHANNELS, TRID_REG(card, T4D_STOP_A));
3691
3692         spin_unlock_irqrestore(&card->lock, flags);
3693 }
3694
3695 static void
3696 ali_restore_regs(struct trident_card *card)
3697 {
3698         unsigned long flags;
3699         int i, j;
3700
3701         spin_lock_irqsave(&card->lock, flags);
3702
3703         for (i = 1; i < ALI_MIXER_REGS; i++)
3704                 ali_ac97_write(card->ac97_codec[0], i * 2,
3705                                ali_registers.mixer_regs[i]);
3706
3707         for (i = 0; i < ALI_CHANNELS; i++) {
3708                 outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
3709                 for (j = 0; j < ALI_CHANNEL_REGS; j++)
3710                         outl(ali_registers.channel_regs[i][j],
3711                              TRID_REG(card, j * 4 + 0xe0));
3712         }
3713
3714         for (i = 0; i < ALI_GLOBAL_REGS; i++) {
3715                 if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A) ||
3716                     (i * 4 == T4D_START_A))
3717                         continue;
3718                 outl(ali_registers.global_regs[i], TRID_REG(card, i * 4));
3719         }
3720
3721         //start HW channel
3722         outl(ali_registers.global_regs[0x20], TRID_REG(card, T4D_START_A));
3723         //restore IRQ enable bits
3724         outl(ali_registers.global_regs[0x2c], TRID_REG(card, T4D_MISCINT));
3725
3726         spin_unlock_irqrestore(&card->lock, flags);
3727 }
3728
3729 static int
3730 trident_suspend(struct pci_dev *dev, u32 unused)
3731 {
3732         struct trident_card *card = pci_get_drvdata(dev);
3733
3734         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
3735                 ali_save_regs(card);
3736         }
3737         return 0;
3738 }
3739
3740 static int
3741 trident_resume(struct pci_dev *dev)
3742 {
3743         struct trident_card *card = pci_get_drvdata(dev);
3744
3745         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
3746                 ali_restore_regs(card);
3747         }
3748         return 0;
3749 }
3750
3751 static struct trident_channel *
3752 ali_alloc_pcm_channel(struct trident_card *card)
3753 {
3754         struct trident_pcm_bank *bank;
3755         int idx;
3756
3757         bank = &card->banks[BANK_A];
3758
3759         if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) &
3760             (ALI_SPDIF_OUT_CH_ENABLE)) {
3761                 idx = ALI_SPDIF_OUT_CHANNEL;
3762                 if (!(bank->bitmap & (1 << idx))) {
3763                         struct trident_channel *channel = &bank->channels[idx];
3764                         bank->bitmap |= 1 << idx;
3765                         channel->num = idx;
3766                         return channel;
3767                 }
3768         }
3769
3770         for (idx = ALI_PCM_OUT_CHANNEL_FIRST; idx <= ALI_PCM_OUT_CHANNEL_LAST;
3771              idx++) {
3772                 if (!(bank->bitmap & (1 << idx))) {
3773                         struct trident_channel *channel = &bank->channels[idx];
3774                         bank->bitmap |= 1 << idx;
3775                         channel->num = idx;
3776                         return channel;
3777                 }
3778         }
3779
3780         /* no more free channels avaliable */
3781 #if 0
3782         printk(KERN_ERR "ali: no more channels available on Bank A.\n");
3783 #endif /* 0 */
3784         return NULL;
3785 }
3786
3787 static struct trident_channel *
3788 ali_alloc_rec_pcm_channel(struct trident_card *card)
3789 {
3790         struct trident_pcm_bank *bank;
3791         int idx;
3792
3793         if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) & ALI_SPDIF_IN_SUPPORT)
3794                 idx = ALI_SPDIF_IN_CHANNEL;
3795         else
3796                 idx = ALI_PCM_IN_CHANNEL;
3797
3798         bank = &card->banks[BANK_A];
3799
3800         if (!(bank->bitmap & (1 << idx))) {
3801                 struct trident_channel *channel = &bank->channels[idx];
3802                 bank->bitmap |= 1 << idx;
3803                 channel->num = idx;
3804                 return channel;
3805         }
3806
3807         /* no free recordable channels avaliable */
3808 #if 0
3809         printk(KERN_ERR "ali: no recordable channels available on Bank A.\n");
3810 #endif /* 0 */
3811         return NULL;
3812 }
3813
3814 static void
3815 ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate)
3816 {
3817         unsigned char ch_st_sel;
3818         unsigned short status_rate;
3819
3820         switch (rate) {
3821         case 44100:
3822                 status_rate = 0;
3823                 break;
3824         case 32000:
3825                 status_rate = 0x300;
3826                 break;
3827         case 48000:
3828         default:
3829                 status_rate = 0x200;
3830                 break;
3831         }
3832
3833         /* select spdif_out */
3834         ch_st_sel = inb(TRID_REG(card, ALI_SPDIF_CTRL)) & ALI_SPDIF_OUT_CH_STATUS;
3835
3836         ch_st_sel |= 0x80;      /* select right */
3837         outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
3838         outb(status_rate | 0x20, TRID_REG(card, ALI_SPDIF_CS + 2));
3839
3840         ch_st_sel &= (~0x80);   /* select left */
3841         outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
3842         outw(status_rate | 0x10, TRID_REG(card, ALI_SPDIF_CS + 2));
3843 }
3844
3845 static void
3846 ali_address_interrupt(struct trident_card *card)
3847 {
3848         int i, channel;
3849         struct trident_state *state;
3850         u32 mask, channel_mask;
3851
3852         mask = trident_get_interrupt_mask(card, 0);
3853         for (i = 0; i < NR_HW_CH; i++) {
3854                 if ((state = card->states[i]) == NULL)
3855                         continue;
3856                 channel = state->dmabuf.channel->num;
3857                 if ((channel_mask = 1 << channel) & mask) {
3858                         mask &= ~channel_mask;
3859                         trident_ack_channel_interrupt(card, channel);
3860                         udelay(100);
3861                         state->dmabuf.update_flag |= ALI_ADDRESS_INT_UPDATE;
3862                         trident_update_ptr(state);
3863                 }
3864         }
3865         if (mask) {
3866                 for (i = 0; i < NR_HW_CH; i++) {
3867                         if (mask & (1 << i)) {
3868                                 printk("ali: spurious channel irq %d.\n", i);
3869                                 trident_ack_channel_interrupt(card, i);
3870                                 trident_stop_voice(card, i);
3871                                 trident_disable_voice_irq(card, i);
3872                         }
3873                 }
3874         }
3875 }
3876
3877 /* Updating the values of counters of other_states' DMAs without lock
3878 protection is no harm because all DMAs of multi-channels and interrupt
3879 depend on a master state's DMA, and changing the counters of the master
3880 state DMA is protected by a spinlock.
3881 */
3882 static int
3883 ali_write_5_1(struct trident_state *state, const char __user *buf,
3884               int cnt_for_multi_channel, unsigned int *copy_count,
3885               unsigned int *state_cnt)
3886 {
3887
3888         struct dmabuf *dmabuf = &state->dmabuf;
3889         struct dmabuf *dmabuf_temp;
3890         const char __user *buffer = buf;
3891         unsigned swptr, other_dma_nums, sample_s;
3892         unsigned int i, loop;
3893
3894         other_dma_nums = 4;
3895         sample_s = sample_size[dmabuf->fmt] >> 1;
3896         swptr = dmabuf->swptr;
3897
3898         if ((i = state->multi_channels_adjust_count) > 0) {
3899                 if (i == 1) {
3900                         if (copy_from_user(dmabuf->rawbuf + swptr,
3901                                            buffer, sample_s))
3902                                 return -EFAULT;
3903                         seek_offset(swptr, buffer, cnt_for_multi_channel,
3904                                     sample_s, *copy_count);
3905                         i--;
3906                         (*state_cnt) += sample_s;
3907                         state->multi_channels_adjust_count++;
3908                 } else
3909                         i = i - (state->chans_num - other_dma_nums);
3910                 for (; (i < other_dma_nums) && (cnt_for_multi_channel > 0); i++) {
3911                         dmabuf_temp = &state->other_states[i]->dmabuf;
3912                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3913                                            buffer, sample_s))
3914                                 return -EFAULT;
3915                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3916                                     sample_s, *copy_count);
3917                 }
3918                 if (cnt_for_multi_channel == 0)
3919                         state->multi_channels_adjust_count += i;
3920         }
3921         if (cnt_for_multi_channel > 0) {
3922                 loop = cnt_for_multi_channel / (state->chans_num * sample_s);
3923                 for (i = 0; i < loop; i++) {
3924                         if (copy_from_user(dmabuf->rawbuf + swptr, buffer,
3925                                            sample_s * 2))
3926                                 return -EFAULT;
3927                         seek_offset(swptr, buffer, cnt_for_multi_channel,
3928                                     sample_s * 2, *copy_count);
3929                         (*state_cnt) += (sample_s * 2);
3930
3931                         dmabuf_temp = &state->other_states[0]->dmabuf;
3932                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3933                                            buffer, sample_s))
3934                                 return -EFAULT;
3935                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3936                                     sample_s, *copy_count);
3937
3938                         dmabuf_temp = &state->other_states[1]->dmabuf;
3939                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3940                                            buffer, sample_s))
3941                                 return -EFAULT;
3942                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3943                                     sample_s, *copy_count);
3944
3945                         dmabuf_temp = &state->other_states[2]->dmabuf;
3946                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3947                                            buffer, sample_s))
3948                                 return -EFAULT;
3949                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3950                                     sample_s, *copy_count);
3951
3952                         dmabuf_temp = &state->other_states[3]->dmabuf;
3953                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3954                                            buffer, sample_s))
3955                                 return -EFAULT;
3956                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3957                                     sample_s, *copy_count);
3958                 }
3959
3960                 if (cnt_for_multi_channel > 0) {
3961                         state->multi_channels_adjust_count = cnt_for_multi_channel / sample_s;
3962
3963                         if (copy_from_user(dmabuf->rawbuf + swptr, buffer, sample_s))
3964                                 return -EFAULT;
3965                         seek_offset(swptr, buffer, cnt_for_multi_channel,
3966                                     sample_s, *copy_count);
3967                         (*state_cnt) += sample_s;
3968
3969                         if (cnt_for_multi_channel > 0) {
3970                                 if (copy_from_user(dmabuf->rawbuf + swptr,
3971                                                    buffer, sample_s))
3972                                         return -EFAULT;
3973                                 seek_offset(swptr, buffer, cnt_for_multi_channel,
3974                                             sample_s, *copy_count);
3975                                 (*state_cnt) += sample_s;
3976
3977                                 if (cnt_for_multi_channel > 0) {
3978                                         int diff = state->chans_num - other_dma_nums;
3979                                         loop = state->multi_channels_adjust_count - diff;
3980                                         for (i = 0; i < loop; i++) {
3981                                                 dmabuf_temp = &state->other_states[i]->dmabuf;
3982                                                 if (copy_from_user(dmabuf_temp->rawbuf +
3983                                                                    dmabuf_temp->swptr,
3984                                                                    buffer, sample_s))
3985                                                         return -EFAULT;
3986                                                 seek_offset(dmabuf_temp->swptr, buffer,
3987                                                             cnt_for_multi_channel,
3988                                                             sample_s, *copy_count);
3989                                         }
3990                                 }
3991                         }
3992                 } else
3993                         state->multi_channels_adjust_count = 0;
3994         }
3995         for (i = 0; i < other_dma_nums; i++) {
3996                 dmabuf_temp = &state->other_states[i]->dmabuf;
3997                 dmabuf_temp->swptr = dmabuf_temp->swptr % dmabuf_temp->dmasize;
3998         }
3999         return *state_cnt;
4000 }
4001
4002 static void
4003 ali_free_other_states_resources(struct trident_state *state)
4004 {
4005         int i;
4006         struct trident_card *card = state->card;
4007         struct trident_state *s;
4008         unsigned other_states_count;
4009
4010         other_states_count = state->chans_num - 2; /* except PCM L/R channels */
4011         for (i = 0; i < other_states_count; i++) {
4012                 s = state->other_states[i];
4013                 dealloc_dmabuf(&s->dmabuf, card->pci_dev);
4014                 ali_disable_special_channel(s->card, s->dmabuf.channel->num);
4015                 state->card->free_pcm_channel(s->card, s->dmabuf.channel->num);
4016                 card->states[s->virt] = NULL;
4017                 kfree(s);
4018         }
4019 }
4020
4021 struct proc_dir_entry *res;
4022 static int
4023 ali_write_proc(struct file *file, const char __user *buffer, unsigned long count, void *data)
4024 {
4025         struct trident_card *card = (struct trident_card *) data;
4026         unsigned long flags;
4027         char c;
4028
4029         if (count < 0)
4030                 return -EINVAL;
4031         if (count == 0)
4032                 return 0;
4033         if (get_user(c, buffer))
4034                 return -EFAULT;
4035
4036         spin_lock_irqsave(&card->lock, flags);
4037         switch (c) {
4038         case '0':
4039                 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4040                 ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
4041                 break;
4042         case '1':
4043                 ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
4044                                     ALI_SPDIF_OUT_PCM);
4045                 break;
4046         case '2':
4047                 ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
4048                                     ALI_SPDIF_OUT_NON_PCM);
4049                 break;
4050         case '3':
4051                 ali_disable_spdif_in(card);     //default
4052                 break;
4053         case '4':
4054                 ali_setup_spdif_in(card);
4055                 break;
4056         }
4057         spin_unlock_irqrestore(&card->lock, flags);
4058
4059         return count;
4060 }
4061
4062 /* OSS /dev/mixer file operation methods */
4063 static int
4064 trident_open_mixdev(struct inode *inode, struct file *file)
4065 {
4066         int i = 0;
4067         int minor = iminor(inode);
4068         struct trident_card *card = devs;
4069
4070         for (card = devs; card != NULL; card = card->next)
4071                 for (i = 0; i < NR_AC97; i++)
4072                         if (card->ac97_codec[i] != NULL &&
4073                             card->ac97_codec[i]->dev_mixer == minor)
4074                                 goto match;
4075
4076         if (!card) {
4077                 return -ENODEV;
4078         }
4079       match:
4080         file->private_data = card->ac97_codec[i];
4081
4082         return 0;
4083 }
4084
4085 static int
4086 trident_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4087                      unsigned long arg)
4088 {
4089         struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
4090
4091         return codec->mixer_ioctl(codec, cmd, arg);
4092 }
4093
4094 static /*const */ struct file_operations trident_mixer_fops = {
4095         .owner = THIS_MODULE,
4096         .llseek = no_llseek,
4097         .ioctl = trident_ioctl_mixdev,
4098         .open = trident_open_mixdev,
4099 };
4100
4101 static int
4102 ali_reset_5451(struct trident_card *card)
4103 {
4104         struct pci_dev *pci_dev = NULL;
4105         unsigned int dwVal;
4106         unsigned short wCount, wReg;
4107
4108         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
4109                                   pci_dev);
4110         if (pci_dev == NULL)
4111                 return -1;
4112
4113         pci_read_config_dword(pci_dev, 0x7c, &dwVal);
4114         pci_write_config_dword(pci_dev, 0x7c, dwVal | 0x08000000);
4115         udelay(5000);
4116         pci_read_config_dword(pci_dev, 0x7c, &dwVal);
4117         pci_write_config_dword(pci_dev, 0x7c, dwVal & 0xf7ffffff);
4118         udelay(5000);
4119
4120         pci_dev = card->pci_dev;
4121         if (pci_dev == NULL)
4122                 return -1;
4123
4124         pci_read_config_dword(pci_dev, 0x44, &dwVal);
4125         pci_write_config_dword(pci_dev, 0x44, dwVal | 0x000c0000);
4126         udelay(500);
4127         pci_read_config_dword(pci_dev, 0x44, &dwVal);
4128         pci_write_config_dword(pci_dev, 0x44, dwVal & 0xfffbffff);
4129         udelay(5000);
4130
4131         /* TODO: recognize if we have a PM capable codec and only do this */
4132         /* if the codec is PM capable */
4133         wCount = 2000;
4134         while (wCount--) {
4135                 wReg = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
4136                 if ((wReg & 0x000f) == 0x000f)
4137                         return 0;
4138                 udelay(5000);
4139         }
4140         /* This is non fatal if you have a non PM capable codec.. */
4141         return 0;
4142 }
4143
4144 /* AC97 codec initialisation. */
4145 static int __devinit
4146 trident_ac97_init(struct trident_card *card)
4147 {
4148         int num_ac97 = 0;
4149         unsigned long ready_2nd = 0;
4150         struct ac97_codec *codec;
4151         int i = 0;
4152
4153         /* initialize controller side of AC link, and find out if secondary codes
4154            really exist */
4155         switch (card->pci_id) {
4156         case PCI_DEVICE_ID_ALI_5451:
4157                 if (ali_reset_5451(card)) {
4158                         printk(KERN_ERR "trident_ac97_init: error "
4159                                "resetting 5451.\n");
4160                         return -1;
4161                 }
4162                 outl(0x80000001, TRID_REG(card, ALI_GLOBAL_CONTROL));
4163                 outl(0x00000000, TRID_REG(card, T4D_AINTEN_A));
4164                 outl(0xffffffff, TRID_REG(card, T4D_AINT_A));
4165                 outl(0x00000000, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
4166                 outb(0x10, TRID_REG(card, ALI_MPUR2));
4167                 ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
4168                 ready_2nd &= 0x3fff;
4169                 outl(ready_2nd | PCMOUT | 0x8000, TRID_REG(card, ALI_SCTRL));
4170                 ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
4171                 ready_2nd &= SI_AC97_SECONDARY_READY;
4172                 if (card->revision < ALI_5451_V02)
4173                         ready_2nd = 0;
4174                 break;
4175         case PCI_DEVICE_ID_SI_7018:
4176                 /* disable AC97 GPIO interrupt */
4177                 outl(0x00, TRID_REG(card, SI_AC97_GPIO));
4178                 /* when power up the AC link is in cold reset mode so stop it */
4179                 outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT | SECONDARY_ID,
4180                      TRID_REG(card, SI_SERIAL_INTF_CTRL));
4181                 /* it take a long time to recover from a cold reset */
4182                 /* (especially when you have more than one codec) */
4183                 udelay(2000);
4184                 ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
4185                 ready_2nd &= SI_AC97_SECONDARY_READY;
4186                 break;
4187         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
4188                 /* playback on */
4189                 outl(DX_AC97_PLAYBACK, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
4190                 break;
4191         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
4192                 /* enable AC97 Output Slot 3,4 (PCM Left/Right Playback) */
4193                 outl(NX_AC97_PCM_OUTPUT, TRID_REG(card, NX_ACR0_AC97_COM_STAT));
4194                 ready_2nd = inl(TRID_REG(card, NX_ACR0_AC97_COM_STAT));
4195                 ready_2nd &= NX_AC97_SECONDARY_READY;
4196                 break;
4197         case PCI_DEVICE_ID_INTERG_5050:
4198                 /* disable AC97 GPIO interrupt */
4199                 outl(0x00, TRID_REG(card, SI_AC97_GPIO));
4200                 /* when power up, the AC link is in cold reset mode, so stop it */
4201                 outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT,
4202                      TRID_REG(card, SI_SERIAL_INTF_CTRL));
4203                 /* it take a long time to recover from a cold reset (especially */
4204                 /* when you have more than one codec) */
4205                 udelay(2000);
4206                 ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
4207                 ready_2nd &= SI_AC97_SECONDARY_READY;
4208                 break;
4209         }
4210
4211         for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4212                 if ((codec = ac97_alloc_codec()) == NULL)
4213                         return -ENOMEM;
4214
4215                 /* initialize some basic codec information, other fields */
4216                 /* will be filled in ac97_probe_codec */
4217                 codec->private_data = card;
4218                 codec->id = num_ac97;
4219
4220                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4221                         codec->codec_read = ali_ac97_read;
4222                         codec->codec_write = ali_ac97_write;
4223                 } else {
4224                         codec->codec_read = trident_ac97_get;
4225                         codec->codec_write = trident_ac97_set;
4226                 }
4227
4228                 if (ac97_probe_codec(codec) == 0)
4229                         break;
4230
4231                 codec->dev_mixer = register_sound_mixer(&trident_mixer_fops, -1);
4232                 if (codec->dev_mixer < 0) {
4233                         printk(KERN_ERR "trident: couldn't register mixer!\n");
4234                         ac97_release_codec(codec);
4235                         break;
4236                 }
4237
4238                 card->ac97_codec[num_ac97] = codec;
4239
4240                 /* if there is no secondary codec at all, don't probe any more */
4241                 if (!ready_2nd)
4242                         break;
4243         }
4244
4245         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4246                 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4247                         if (card->ac97_codec[num_ac97] == NULL)
4248                                 break;
4249                         for (i = 0; i < 64; i++) {
4250                                 u16 reg = ali_ac97_get(card, num_ac97, i * 2);
4251                                 card->mixer_regs[i][num_ac97] = reg;
4252                         }
4253                 }
4254         }
4255         return num_ac97 + 1;
4256 }
4257
4258 /* Gameport functions for the cards ADC gameport */
4259
4260 static unsigned char
4261 trident_game_read(struct gameport *gameport)
4262 {
4263         struct trident_card *card = gameport->driver;
4264         return inb(TRID_REG(card, T4D_GAME_LEG));
4265 }
4266
4267 static void
4268 trident_game_trigger(struct gameport *gameport)
4269 {
4270         struct trident_card *card = gameport->driver;
4271         outb(0xff, TRID_REG(card, T4D_GAME_LEG));
4272 }
4273
4274 static int
4275 trident_game_cooked_read(struct gameport *gameport, int *axes, int *buttons)
4276 {
4277         struct trident_card *card = gameport->driver;
4278         int i;
4279
4280         *buttons = (~inb(TRID_REG(card, T4D_GAME_LEG)) >> 4) & 0xf;
4281
4282         for (i = 0; i < 4; i++) {
4283                 axes[i] = inw(TRID_REG(card, T4D_GAME_AXD) + i * sizeof (u16));
4284                 if (axes[i] == 0xffff)
4285                         axes[i] = -1;
4286         }
4287
4288         return 0;
4289 }
4290
4291 static int
4292 trident_game_open(struct gameport *gameport, int mode)
4293 {
4294         struct trident_card *card = gameport->driver;
4295
4296         switch (mode) {
4297         case GAMEPORT_MODE_COOKED:
4298                 outb(0x80, TRID_REG(card, T4D_GAME_CR));
4299                 msleep(20);
4300                 return 0;
4301         case GAMEPORT_MODE_RAW:
4302                 outb(0x00, TRID_REG(card, T4D_GAME_CR));
4303                 return 0;
4304         default:
4305                 return -1;
4306         }
4307
4308         return 0;
4309 }
4310
4311 /* install the driver, we do not allocate hardware channel nor DMA buffer */
4312 /* now, they are defered until "ACCESS" time (in prog_dmabuf called by */
4313 /* open/read/write/ioctl/mmap) */
4314 static int __devinit
4315 trident_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
4316 {
4317         unsigned long iobase;
4318         struct trident_card *card;
4319         u8 bits;
4320         u8 revision;
4321         int i = 0;
4322         u16 temp;
4323         struct pci_dev *pci_dev_m1533 = NULL;
4324         int rc = -ENODEV;
4325         u64 dma_mask;
4326
4327         if (pci_enable_device(pci_dev))
4328                 goto out;
4329
4330         if (pci_dev->device == PCI_DEVICE_ID_ALI_5451)
4331                 dma_mask = ALI_DMA_MASK;
4332         else
4333                 dma_mask = TRIDENT_DMA_MASK;
4334         if (pci_set_dma_mask(pci_dev, dma_mask)) {
4335                 printk(KERN_ERR "trident: architecture does not support"
4336                        " %s PCI busmaster DMA\n",
4337                        pci_dev->device == PCI_DEVICE_ID_ALI_5451 ?
4338                        "32-bit" : "30-bit");
4339                 goto out;
4340         }
4341         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
4342
4343         if (pci_id->device == PCI_DEVICE_ID_INTERG_5050)
4344                 iobase = pci_resource_start(pci_dev, 1);
4345         else
4346                 iobase = pci_resource_start(pci_dev, 0);
4347
4348         if (!request_region(iobase, 256, card_names[pci_id->driver_data])) {
4349                 printk(KERN_ERR "trident: can't allocate I/O space at "
4350                        "0x%4.4lx\n", iobase);
4351                 goto out;
4352         }
4353
4354         rc = -ENOMEM;
4355         if ((card = kmalloc(sizeof(*card), GFP_KERNEL)) == NULL) {
4356                 printk(KERN_ERR "trident: out of memory\n");
4357                 goto out_release_region;
4358         }
4359         memset(card, 0, sizeof (*card));
4360
4361         init_timer(&card->timer);
4362         card->iobase = iobase;
4363         card->pci_dev = pci_dev;
4364         card->pci_id = pci_id->device;
4365         card->revision = revision;
4366         card->irq = pci_dev->irq;
4367         card->next = devs;
4368         card->magic = TRIDENT_CARD_MAGIC;
4369         card->banks[BANK_A].addresses = &bank_a_addrs;
4370         card->banks[BANK_A].bitmap = 0UL;
4371         card->banks[BANK_B].addresses = &bank_b_addrs;
4372         card->banks[BANK_B].bitmap = 0UL;
4373
4374         card->gameport.driver = card;
4375         card->gameport.fuzz = 64;
4376         card->gameport.read = trident_game_read;
4377         card->gameport.trigger = trident_game_trigger;
4378         card->gameport.cooked_read = trident_game_cooked_read;
4379         card->gameport.open = trident_game_open;
4380
4381         init_MUTEX(&card->open_sem);
4382         spin_lock_init(&card->lock);
4383         init_timer(&card->timer);
4384
4385         devs = card;
4386
4387         pci_set_master(pci_dev);
4388
4389         printk(KERN_INFO "trident: %s found at IO 0x%04lx, IRQ %d\n",
4390                card_names[pci_id->driver_data], card->iobase, card->irq);
4391
4392         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4393                 /* ALi channel Management */
4394                 card->alloc_pcm_channel = ali_alloc_pcm_channel;
4395                 card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
4396                 card->free_pcm_channel = ali_free_pcm_channel;
4397
4398                 card->address_interrupt = ali_address_interrupt;
4399
4400                 /* Added by Matt Wu 01-05-2001 for spdif in */
4401                 card->multi_channel_use_count = 0;
4402                 card->rec_channel_use_count = 0;
4403
4404                 /* ALi SPDIF OUT function */
4405                 if (card->revision == ALI_5451_V02) {
4406                         ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4407                         res = create_proc_entry("ALi5451", 0, NULL);
4408                         if (res) {
4409                                 res->write_proc = ali_write_proc;
4410                                 res->data = card;
4411                         }
4412                 }
4413
4414                 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4415                 card->hwvolctl = 0;
4416                 pci_dev_m1533 = pci_find_device(PCI_VENDOR_ID_AL,
4417                                                 PCI_DEVICE_ID_AL_M1533,
4418                                                 pci_dev_m1533);
4419                 rc = -ENODEV;
4420                 if (pci_dev_m1533 == NULL)
4421                         goto out_proc_fs;
4422                 pci_read_config_byte(pci_dev_m1533, 0x63, &bits);
4423                 if (bits & (1 << 5))
4424                         card->hwvolctl = 1;
4425                 if (card->hwvolctl) {
4426                         /* Clear m1533 pci cfg 78h bit 30 to zero, which makes
4427                            GPIO11/12/13 work as ACGP_UP/DOWN/MUTE. */
4428                         pci_read_config_byte(pci_dev_m1533, 0x7b, &bits);
4429                         bits &= 0xbf;   /*clear bit 6 */
4430                         pci_write_config_byte(pci_dev_m1533, 0x7b, bits);
4431                 }
4432         } else if (card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
4433                 card->alloc_pcm_channel = cyber_alloc_pcm_channel;
4434                 card->alloc_rec_pcm_channel = cyber_alloc_pcm_channel;
4435                 card->free_pcm_channel = cyber_free_pcm_channel;
4436                 card->address_interrupt = cyber_address_interrupt;
4437                 cyber_init_ritual(card);
4438         } else {
4439                 card->alloc_pcm_channel = trident_alloc_pcm_channel;
4440                 card->alloc_rec_pcm_channel = trident_alloc_pcm_channel;
4441                 card->free_pcm_channel = trident_free_pcm_channel;
4442                 card->address_interrupt = trident_address_interrupt;
4443         }
4444
4445         /* claim our irq */
4446         rc = -ENODEV;
4447         if (request_irq(card->irq, &trident_interrupt, SA_SHIRQ,
4448                         card_names[pci_id->driver_data], card)) {
4449                 printk(KERN_ERR "trident: unable to allocate irq %d\n",
4450                        card->irq);
4451                 goto out_proc_fs;
4452         }
4453         /* register /dev/dsp */
4454         if ((card->dev_audio = register_sound_dsp(&trident_audio_fops, -1)) < 0) {
4455                 printk(KERN_ERR "trident: couldn't register DSP device!\n");
4456                 goto out_free_irq;
4457         }
4458         card->mixer_regs_ready = 0;
4459         /* initialize AC97 codec and register /dev/mixer */
4460         if (trident_ac97_init(card) <= 0) {
4461                 /* unregister audio devices */
4462                 for (i = 0; i < NR_AC97; i++) {
4463                         if (card->ac97_codec[i] != NULL) {
4464                                 struct ac97_codec* codec = card->ac97_codec[i];
4465                                 unregister_sound_mixer(codec->dev_mixer);
4466                                 ac97_release_codec(codec);
4467                         }
4468                 }
4469                 goto out_unregister_sound_dsp;
4470         }
4471         card->mixer_regs_ready = 1;
4472         outl(0x00, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
4473
4474         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4475                 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4476                 if (card->hwvolctl) {
4477                         /* Enable GPIO IRQ (MISCINT bit 18h) */
4478                         temp = inw(TRID_REG(card, T4D_MISCINT + 2));
4479                         temp |= 0x0004;
4480                         outw(temp, TRID_REG(card, T4D_MISCINT + 2));
4481
4482                         /* Enable H/W Volume Control GLOVAL CONTROL bit 0 */
4483                         temp = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
4484                         temp |= 0x0001;
4485                         outw(temp, TRID_REG(card, ALI_GLOBAL_CONTROL));
4486
4487                 }
4488                 if (card->revision == ALI_5451_V02)
4489                         ali_close_multi_channels();
4490                 /* edited by HMSEO for GT sound */
4491 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
4492                 {
4493                         u16 ac97_data;
4494                         extern struct hwrpb_struct *hwrpb;
4495
4496                         if ((hwrpb->sys_type) == 201) {
4497                                 printk(KERN_INFO "trident: Running on Alpha system "
4498                                        "type Nautilus\n");
4499                                 ac97_data = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
4500                                 ali_ac97_set(card, 0, AC97_POWER_CONTROL,
4501                                              ac97_data | ALI_EAPD_POWER_DOWN);
4502                         }
4503                 }
4504 #endif                          /* CONFIG_ALPHA_NAUTILUS || CONFIG_ALPHA_GENERIC */
4505                 /* edited by HMSEO for GT sound */
4506         }
4507         rc = 0;
4508         pci_set_drvdata(pci_dev, card);
4509
4510         /* Enable Address Engine Interrupts */
4511         trident_enable_loop_interrupts(card);
4512
4513         /* Register gameport */
4514         gameport_register_port(&card->gameport);
4515
4516 out:
4517         return rc;
4518
4519 out_unregister_sound_dsp:
4520         unregister_sound_dsp(card->dev_audio);
4521 out_free_irq:
4522         free_irq(card->irq, card);
4523 out_proc_fs:
4524         if (res) {
4525                 remove_proc_entry("ALi5451", NULL);
4526                 res = NULL;
4527         }
4528         kfree(card);
4529         devs = NULL;
4530 out_release_region:
4531         release_region(iobase, 256);
4532         return rc;
4533 }
4534
4535 static void __devexit
4536 trident_remove(struct pci_dev *pci_dev)
4537 {
4538         int i;
4539         struct trident_card *card = pci_get_drvdata(pci_dev);
4540
4541         /*
4542          *      Kill running timers before unload. We can't have them
4543          *      going off after rmmod!
4544          */
4545         if (card->hwvolctl)
4546                 del_timer_sync(&card->timer);
4547
4548         /* ALi S/PDIF and Power Management */
4549         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4550                 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4551                 ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
4552                 ali_disable_spdif_in(card);
4553                 remove_proc_entry("ALi5451", NULL);
4554         }
4555
4556         /* Unregister gameport */
4557         gameport_unregister_port(&card->gameport);
4558
4559         /* Kill interrupts, and SP/DIF */
4560         trident_disable_loop_interrupts(card);
4561
4562         /* free hardware resources */
4563         free_irq(card->irq, card);
4564         release_region(card->iobase, 256);
4565
4566         /* unregister audio devices */
4567         for (i = 0; i < NR_AC97; i++)
4568                 if (card->ac97_codec[i] != NULL) {
4569                         unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
4570                         ac97_release_codec(card->ac97_codec[i]);
4571                 }
4572         unregister_sound_dsp(card->dev_audio);
4573
4574         kfree(card);
4575
4576         pci_set_drvdata(pci_dev, NULL);
4577 }
4578
4579 MODULE_AUTHOR("Alan Cox, Aaron Holtzman, Ollie Lho, Ching Ling Lee, Muli Ben-Yehuda");
4580 MODULE_DESCRIPTION("Trident 4DWave/SiS 7018/ALi 5451 and Tvia/IGST CyberPro5050 PCI "
4581                    "Audio Driver");
4582 MODULE_LICENSE("GPL");
4583
4584 #define TRIDENT_MODULE_NAME "trident"
4585
4586 static struct pci_driver trident_pci_driver = {
4587         .name = TRIDENT_MODULE_NAME,
4588         .id_table = trident_pci_tbl,
4589         .probe = trident_probe,
4590         .remove = __devexit_p(trident_remove),
4591         .suspend = trident_suspend,
4592         .resume = trident_resume
4593 };
4594
4595 static int __init
4596 trident_init_module(void)
4597 {
4598         printk(KERN_INFO "Trident 4DWave/SiS 7018/ALi 5451,Tvia CyberPro "
4599                "5050 PCI Audio, version " DRIVER_VERSION ", " __TIME__ " "
4600                __DATE__ "\n");
4601
4602         if (!pci_register_driver(&trident_pci_driver)) {
4603                 pci_unregister_driver(&trident_pci_driver);
4604                 return -ENODEV;
4605         }
4606         return 0;
4607 }
4608
4609 static void __exit
4610 trident_cleanup_module(void)
4611 {
4612         pci_unregister_driver(&trident_pci_driver);
4613 }
4614
4615 module_init(trident_init_module);
4616 module_exit(trident_cleanup_module);