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