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/smp_lock.h>
 211 #include <linux/ac97_codec.h>
 212 #include <linux/bitops.h>
 213 #include <linux/proc_fs.h>
 214 #include <linux/interrupt.h>
 215 #include <linux/pm.h>
 216 #include <linux/gameport.h>
 217 #include <linux/kernel.h>
 218 #include <linux/mutex.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, struct pt_regs *regs)
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 = %d\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 = %d\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
2706         /* Added by Matt Wu 01-05-2001 */
2707         /* TODO: there's some redundacy here wrt the check below */
2708         /* for multi_use_count > 0. Should we return -EBUSY or find */
2709         /* a different card? for now, don't break current behaviour */
2710         /* -- mulix */
2711         if (file->f_mode & FMODE_READ) {
2712                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2713                         if (card->multi_channel_use_count > 0)
2714                                 return -EBUSY;
2715                 }
2716         }
2717
2718         /* find an available virtual channel (instance of /dev/dsp) */
2719         while (card != NULL) {
2720                 mutex_lock(&card->open_mutex);
2721                 if (file->f_mode & FMODE_READ) {
2722                         /* Skip opens on cards that are in 6 channel mode */
2723                         if (card->multi_channel_use_count > 0) {
2724                                 mutex_unlock(&card->open_mutex);
2725                                 card = card->next;
2726                                 continue;
2727                         }
2728                 }
2729                 for (i = 0; i < NR_HW_CH; i++) {
2730                         if (card->states[i] == NULL) {
2731                                 state = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
2732                                 if (state == NULL) {
2733                                         mutex_unlock(&card->open_mutex);
2734                                         return -ENOMEM;
2735                                 }
2736                                 memset(state, 0, sizeof(*state));
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                 trident_set_dac_rate(state, 8000);
2784         }
2785
2786         if (file->f_mode & FMODE_READ) {
2787                 /* FIXME: Trident 4d can only record in signed 16-bits stereo, */
2788                 /* 48kHz sample, to be dealed with in trident_set_adc_rate() ?? */
2789                 dmabuf->fmt &= ~TRIDENT_FMT_MASK;
2790                 if ((minor & 0x0f) == SND_DEV_DSP16)
2791                         dmabuf->fmt |= TRIDENT_FMT_16BIT;
2792                 dmabuf->ossfragshift = 0;
2793                 dmabuf->ossmaxfrags = 0;
2794                 dmabuf->subdivision = 0;
2795                 if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
2796                         /* set default channel attribute to 0x8a80, record from
2797                            PCM L/R FIFO and mono = (left + right + 1)/2 */
2798                         dmabuf->channel->attribute = (CHANNEL_REC | PCM_LR |
2799                                                       MONO_MIX);
2800                 }
2801                 trident_set_adc_rate(state, 8000);
2802
2803                 /* Added by Matt Wu 01-05-2001 */
2804                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451)
2805                         card->rec_channel_use_count++;
2806         }
2807
2808         state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2809         mutex_unlock(&card->open_mutex);
2810
2811         pr_debug("trident: open virtual channel %d, hard channel %d\n",
2812                  state->virt, dmabuf->channel->num);
2813
2814         return nonseekable_open(inode, file);
2815 }
2816
2817 static int
2818 trident_release(struct inode *inode, struct file *file)
2819 {
2820         struct trident_state *state = (struct trident_state *)file->private_data;
2821         struct trident_card *card;
2822         struct dmabuf *dmabuf;
2823
2824         VALIDATE_STATE(state);
2825
2826         card = state->card;
2827         dmabuf = &state->dmabuf;
2828
2829         if (file->f_mode & FMODE_WRITE) {
2830                 trident_clear_tail(state);
2831                 drain_dac(state, file->f_flags & O_NONBLOCK);
2832         }
2833
2834         pr_debug("trident: closing virtual channel %d, hard channel %d\n",
2835                  state->virt, dmabuf->channel->num);
2836
2837         /* stop DMA state machine and free DMA buffers/channels */
2838         mutex_lock(&card->open_mutex);
2839
2840         if (file->f_mode & FMODE_WRITE) {
2841                 stop_dac(state);
2842                 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
2843                 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
2844
2845                 /* Added by Matt Wu */
2846                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2847                         if (state->chans_num > 2) {
2848                                 if (card->multi_channel_use_count-- < 0)
2849                                         card->multi_channel_use_count = 0;
2850                                 if (card->multi_channel_use_count == 0)
2851                                         ali_close_multi_channels();
2852                                 ali_free_other_states_resources(state);
2853                         }
2854                 }
2855         }
2856         if (file->f_mode & FMODE_READ) {
2857                 stop_adc(state);
2858                 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
2859                 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
2860
2861                 /* Added by Matt Wu */
2862                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2863                         if (card->rec_channel_use_count-- < 0)
2864                                 card->rec_channel_use_count = 0;
2865                 }
2866         }
2867
2868         card->states[state->virt] = NULL;
2869         kfree(state);
2870
2871         /* we're covered by the open_mutex */
2872         mutex_unlock(&card->open_mutex);
2873
2874         return 0;
2875 }
2876
2877 static /*const */ struct file_operations trident_audio_fops = {
2878         .owner = THIS_MODULE,
2879         .llseek = no_llseek,
2880         .read = trident_read,
2881         .write = trident_write,
2882         .poll = trident_poll,
2883         .ioctl = trident_ioctl,
2884         .mmap = trident_mmap,
2885         .open = trident_open,
2886         .release = trident_release,
2887 };
2888
2889 /* trident specific AC97 functions */
2890 /* Write AC97 codec registers */
2891 static void
2892 trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val)
2893 {
2894         struct trident_card *card = (struct trident_card *)codec->private_data;
2895         unsigned int address, mask, busy;
2896         unsigned short count = 0xffff;
2897         unsigned long flags;
2898         u32 data;
2899
2900         data = ((u32) val) << 16;
2901
2902         switch (card->pci_id) {
2903         default:
2904         case PCI_DEVICE_ID_SI_7018:
2905                 address = SI_AC97_WRITE;
2906                 mask = SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY;
2907                 if (codec->id)
2908                         mask |= SI_AC97_SECONDARY;
2909                 busy = SI_AC97_BUSY_WRITE;
2910                 break;
2911         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
2912                 address = DX_ACR0_AC97_W;
2913                 mask = busy = DX_AC97_BUSY_WRITE;
2914                 break;
2915         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
2916                 address = NX_ACR1_AC97_W;
2917                 mask = NX_AC97_BUSY_WRITE;
2918                 if (codec->id)
2919                         mask |= NX_AC97_WRITE_SECONDARY;
2920                 busy = NX_AC97_BUSY_WRITE;
2921                 break;
2922         case PCI_DEVICE_ID_INTERG_5050:
2923                 address = SI_AC97_WRITE;
2924                 mask = busy = SI_AC97_BUSY_WRITE;
2925                 if (codec->id)
2926                         mask |= SI_AC97_SECONDARY;
2927                 break;
2928         }
2929
2930         spin_lock_irqsave(&card->lock, flags);
2931         do {
2932                 if ((inw(TRID_REG(card, address)) & busy) == 0)
2933                         break;
2934         } while (count--);
2935
2936         data |= (mask | (reg & AC97_REG_ADDR));
2937
2938         if (count == 0) {
2939                 printk(KERN_ERR "trident: AC97 CODEC write timed out.\n");
2940                 spin_unlock_irqrestore(&card->lock, flags);
2941                 return;
2942         }
2943
2944         outl(data, TRID_REG(card, address));
2945         spin_unlock_irqrestore(&card->lock, flags);
2946 }
2947
2948 /* Read AC97 codec registers */
2949 static u16
2950 trident_ac97_get(struct ac97_codec *codec, u8 reg)
2951 {
2952         struct trident_card *card = (struct trident_card *)codec->private_data;
2953         unsigned int address, mask, busy;
2954         unsigned short count = 0xffff;
2955         unsigned long flags;
2956         u32 data;
2957
2958         switch (card->pci_id) {
2959         default:
2960         case PCI_DEVICE_ID_SI_7018:
2961                 address = SI_AC97_READ;
2962                 mask = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY;
2963                 if (codec->id)
2964                         mask |= SI_AC97_SECONDARY;
2965                 busy = SI_AC97_BUSY_READ;
2966                 break;
2967         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
2968                 address = DX_ACR1_AC97_R;
2969                 mask = busy = DX_AC97_BUSY_READ;
2970                 break;
2971         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
2972                 if (codec->id)
2973                         address = NX_ACR3_AC97_R_SECONDARY;
2974                 else
2975                         address = NX_ACR2_AC97_R_PRIMARY;
2976                 mask = NX_AC97_BUSY_READ;
2977                 busy = NX_AC97_BUSY_READ | NX_AC97_BUSY_DATA;
2978                 break;
2979         case PCI_DEVICE_ID_INTERG_5050:
2980                 address = SI_AC97_READ;
2981                 mask = busy = SI_AC97_BUSY_READ;
2982                 if (codec->id)
2983                         mask |= SI_AC97_SECONDARY;
2984                 break;
2985         }
2986
2987         data = (mask | (reg & AC97_REG_ADDR));
2988
2989         spin_lock_irqsave(&card->lock, flags);
2990         outl(data, TRID_REG(card, address));
2991         do {
2992                 data = inl(TRID_REG(card, address));
2993                 if ((data & busy) == 0)
2994                         break;
2995         } while (count--);
2996         spin_unlock_irqrestore(&card->lock, flags);
2997
2998         if (count == 0) {
2999                 printk(KERN_ERR "trident: AC97 CODEC read timed out.\n");
3000                 data = 0;
3001         }
3002         return ((u16) (data >> 16));
3003 }
3004
3005 /* rewrite ac97 read and write mixer register by hulei for ALI*/
3006 static int
3007 acquirecodecaccess(struct trident_card *card)
3008 {
3009         u16 wsemamask = 0x6000; /* bit 14..13 */
3010         u16 wsemabits;
3011         u16 wcontrol;
3012         int block = 0;
3013         int ncount = 25;
3014         while (1) {
3015                 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3016                 wsemabits = wcontrol & wsemamask;
3017
3018                 if (wsemabits == 0x4000)
3019                         return 1;       /* 0x4000 is audio ,then success */
3020                 if (ncount-- < 0)
3021                         break;
3022                 if (wsemabits == 0) {
3023                       unlock:
3024                         outl(((u32) (wcontrol & 0x1eff) | 0x00004000),
3025                              TRID_REG(card, ALI_AC97_WRITE));
3026                         continue;
3027                 }
3028                 udelay(20);
3029         }
3030         if (!block) {
3031                 pr_debug("accesscodecsemaphore: try unlock\n");
3032                 block = 1;
3033                 goto unlock;
3034         }
3035         return 0;
3036 }
3037
3038 static void
3039 releasecodecaccess(struct trident_card *card)
3040 {
3041         unsigned long wcontrol;
3042         wcontrol = inl(TRID_REG(card, ALI_AC97_WRITE));
3043         outl((wcontrol & 0xffff1eff), TRID_REG(card, ALI_AC97_WRITE));
3044 }
3045
3046 static int
3047 waitforstimertick(struct trident_card *card)
3048 {
3049         unsigned long chk1, chk2;
3050         unsigned int wcount = 0xffff;
3051         chk1 = inl(TRID_REG(card, ALI_STIMER));
3052
3053         while (1) {
3054                 chk2 = inl(TRID_REG(card, ALI_STIMER));
3055                 if ((wcount > 0) && chk1 != chk2)
3056                         return 1;
3057                 if (wcount <= 0)
3058                         break;
3059                 udelay(50);
3060         }
3061         return 0;
3062 }
3063
3064 /* Read AC97 codec registers for ALi*/
3065 static u16
3066 ali_ac97_get(struct trident_card *card, int secondary, u8 reg)
3067 {
3068         unsigned int address, mask;
3069         unsigned int ncount;
3070         unsigned long aud_reg;
3071         u32 data;
3072         u16 wcontrol;
3073         unsigned long flags;
3074
3075         if (!card)
3076                 BUG();
3077
3078         address = ALI_AC97_READ;
3079         if (card->revision == ALI_5451_V02) {
3080                 address = ALI_AC97_WRITE;
3081         }
3082         mask = ALI_AC97_READ_ACTION | ALI_AC97_AUDIO_BUSY;
3083         if (secondary)
3084                 mask |= ALI_AC97_SECONDARY;
3085
3086         spin_lock_irqsave(&card->lock, flags);
3087
3088         if (!acquirecodecaccess(card))
3089                 printk(KERN_ERR "access codec fail\n");
3090
3091         wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3092         wcontrol &= 0xfe00;
3093         wcontrol |= (0x8000 | reg);
3094         outw(wcontrol, TRID_REG(card, ALI_AC97_WRITE));
3095
3096         data = (mask | (reg & AC97_REG_ADDR));
3097
3098         if (!waitforstimertick(card)) {
3099                 printk(KERN_ERR "ali_ac97_read: BIT_CLOCK is dead\n");
3100                 goto releasecodec;
3101         }
3102
3103         udelay(20);
3104
3105         ncount = 10;
3106
3107         while (1) {
3108                 if ((inw(TRID_REG(card, ALI_AC97_WRITE)) & ALI_AC97_BUSY_READ)
3109                     != 0)
3110                         break;
3111                 if (ncount <= 0)
3112                         break;
3113                 if (ncount-- == 1) {
3114                         pr_debug("ali_ac97_read :try clear busy flag\n");
3115                         aud_reg = inl(TRID_REG(card, ALI_AC97_WRITE));
3116                         outl((aud_reg & 0xffff7fff),
3117                              TRID_REG(card, ALI_AC97_WRITE));
3118                 }
3119                 udelay(10);
3120         }
3121
3122         data = inl(TRID_REG(card, address));
3123
3124         spin_unlock_irqrestore(&card->lock, flags);
3125
3126         return ((u16) (data >> 16));
3127
3128       releasecodec:
3129         releasecodecaccess(card);
3130         spin_unlock_irqrestore(&card->lock, flags);
3131         printk(KERN_ERR "ali_ac97_read: AC97 CODEC read timed out.\n");
3132         return 0;
3133 }
3134
3135 /* Write AC97 codec registers for hulei*/
3136 static void
3137 ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val)
3138 {
3139         unsigned int address, mask;
3140         unsigned int ncount;
3141         u32 data;
3142         u16 wcontrol;
3143         unsigned long flags;
3144
3145         data = ((u32) val) << 16;
3146
3147         if (!card)
3148                 BUG();
3149
3150         address = ALI_AC97_WRITE;
3151         mask = ALI_AC97_WRITE_ACTION | ALI_AC97_AUDIO_BUSY;
3152         if (secondary)
3153                 mask |= ALI_AC97_SECONDARY;
3154         if (card->revision == ALI_5451_V02)
3155                 mask |= ALI_AC97_WRITE_MIXER_REGISTER;
3156
3157         spin_lock_irqsave(&card->lock, flags);
3158         if (!acquirecodecaccess(card))
3159                 printk(KERN_ERR "ali_ac97_write: access codec fail\n");
3160
3161         wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3162         wcontrol &= 0xff00;
3163         wcontrol |= (0x8100 | reg); /* bit 8=1: (ali1535 )reserved/ */
3164                                     /* ali1535+ write */
3165         outl((data | wcontrol), TRID_REG(card, ALI_AC97_WRITE));
3166
3167         if (!waitforstimertick(card)) {
3168                 printk(KERN_ERR "BIT_CLOCK is dead\n");
3169                 goto releasecodec;
3170         }
3171
3172         ncount = 10;
3173         while (1) {
3174                 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3175                 if (!(wcontrol & 0x8000))
3176                         break;
3177                 if (ncount <= 0)
3178                         break;
3179                 if (ncount-- == 1) {
3180                         pr_debug("ali_ac97_set :try clear busy flag!!\n");
3181                         outw(wcontrol & 0x7fff,
3182                              TRID_REG(card, ALI_AC97_WRITE));
3183                 }
3184                 udelay(10);
3185         }
3186
3187       releasecodec:
3188         releasecodecaccess(card);
3189         spin_unlock_irqrestore(&card->lock, flags);
3190         return;
3191 }
3192
3193 static void
3194 ali_enable_special_channel(struct trident_state *stat)
3195 {
3196         struct trident_card *card = stat->card;
3197         unsigned long s_channels;
3198
3199         s_channels = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3200         s_channels |= (1 << stat->dmabuf.channel->num);
3201         outl(s_channels, TRID_REG(card, ALI_GLOBAL_CONTROL));
3202 }
3203
3204 static u16
3205 ali_ac97_read(struct ac97_codec *codec, u8 reg)
3206 {
3207         int id;
3208         u16 data;
3209         struct trident_card *card = NULL;
3210
3211         /* Added by Matt Wu */
3212         if (!codec)
3213                 BUG();
3214
3215         card = (struct trident_card *) codec->private_data;
3216
3217         if (!card->mixer_regs_ready)
3218                 return ali_ac97_get(card, codec->id, reg);
3219
3220         /*
3221          *      FIXME: need to stop this caching some registers
3222          */
3223         if (codec->id)
3224                 id = 1;
3225         else
3226                 id = 0;
3227
3228         data = card->mixer_regs[reg / 2][id];
3229         return data;
3230 }
3231
3232 static void
3233 ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val)
3234 {
3235         int id;
3236         struct trident_card *card;
3237
3238         /*  Added by Matt Wu */
3239         if (!codec)
3240                 BUG();
3241
3242         card = (struct trident_card *) codec->private_data;
3243
3244         if (!card->mixer_regs_ready) {
3245                 ali_ac97_set(card, codec->id, reg, val);
3246                 return;
3247         }
3248
3249         if (codec->id)
3250                 id = 1;
3251         else
3252                 id = 0;
3253
3254         card->mixer_regs[reg / 2][id] = val;
3255         ali_ac97_set(card, codec->id, reg, val);
3256 }
3257
3258 /*
3259 flag:   ALI_SPDIF_OUT_TO_SPDIF_OUT
3260         ALI_PCM_TO_SPDIF_OUT
3261 */
3262
3263 static void
3264 ali_setup_spdif_out(struct trident_card *card, int flag)
3265 {
3266         unsigned long spdif;
3267         unsigned char ch;
3268
3269         char temp;
3270         struct pci_dev *pci_dev = NULL;
3271
3272         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3273                                   pci_dev);
3274         if (pci_dev == NULL)
3275                 return;
3276         pci_read_config_byte(pci_dev, 0x61, &temp);
3277         temp |= 0x40;
3278         pci_write_config_byte(pci_dev, 0x61, temp);
3279         pci_read_config_byte(pci_dev, 0x7d, &temp);
3280         temp |= 0x01;
3281         pci_write_config_byte(pci_dev, 0x7d, temp);
3282         pci_read_config_byte(pci_dev, 0x7e, &temp);
3283         temp &= (~0x20);
3284         temp |= 0x10;
3285         pci_write_config_byte(pci_dev, 0x7e, temp);
3286
3287         ch = inb(TRID_REG(card, ALI_SCTRL));
3288         outb(ch | ALI_SPDIF_OUT_ENABLE, TRID_REG(card, ALI_SCTRL));
3289         ch = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3290         outb(ch & ALI_SPDIF_OUT_CH_STATUS, TRID_REG(card, ALI_SPDIF_CTRL));
3291
3292         if (flag & ALI_SPDIF_OUT_TO_SPDIF_OUT) {
3293                 spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
3294                 spdif |= ALI_SPDIF_OUT_CH_ENABLE;
3295                 spdif &= ALI_SPDIF_OUT_SEL_SPDIF;
3296                 outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3297                 spdif = inw(TRID_REG(card, ALI_SPDIF_CS));
3298                 if (flag & ALI_SPDIF_OUT_NON_PCM)
3299                         spdif |= 0x0002;
3300                 else
3301                         spdif &= (~0x0002);
3302                 outw(spdif, TRID_REG(card, ALI_SPDIF_CS));
3303         } else {
3304                 spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
3305                 spdif |= ALI_SPDIF_OUT_SEL_PCM;
3306                 outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3307         }
3308 }
3309
3310 static void
3311 ali_disable_special_channel(struct trident_card *card, int ch)
3312 {
3313         unsigned long sc;
3314
3315         sc = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3316         sc &= ~(1 << ch);
3317         outl(sc, TRID_REG(card, ALI_GLOBAL_CONTROL));
3318 }
3319
3320 static void
3321 ali_disable_spdif_in(struct trident_card *card)
3322 {
3323         unsigned long spdif;
3324
3325         spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3326         spdif &= (~ALI_SPDIF_IN_SUPPORT);
3327         outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3328
3329         ali_disable_special_channel(card, ALI_SPDIF_IN_CHANNEL);
3330 }
3331
3332 static void
3333 ali_setup_spdif_in(struct trident_card *card)
3334 {
3335         unsigned long spdif;
3336
3337         //Set SPDIF IN Supported
3338         spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3339         spdif |= ALI_SPDIF_IN_SUPPORT;
3340         outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3341
3342         //Set SPDIF IN Rec
3343         spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3344         spdif |= ALI_SPDIF_IN_CH_ENABLE;
3345         outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3346
3347         spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3348         spdif |= ALI_SPDIF_IN_CH_STATUS;
3349         outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3350 /*
3351         spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3352         spdif |= ALI_SPDIF_IN_FUNC_ENABLE;
3353         outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3354 */
3355 }
3356
3357 static void
3358 ali_delay(struct trident_card *card, int interval)
3359 {
3360         unsigned long begintimer, currenttimer;
3361
3362         begintimer = inl(TRID_REG(card, ALI_STIMER));
3363         currenttimer = inl(TRID_REG(card, ALI_STIMER));
3364
3365         while (currenttimer < begintimer + interval)
3366                 currenttimer = inl(TRID_REG(card, ALI_STIMER));
3367 }
3368
3369 static void
3370 ali_detect_spdif_rate(struct trident_card *card)
3371 {
3372         u16 wval = 0;
3373         u16 count = 0;
3374         u8 bval = 0, R1 = 0, R2 = 0;
3375
3376         bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3377         bval |= 0x02;
3378         outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
3379
3380         bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3381         bval |= 0x1F;
3382         outb(bval, TRID_REG(card, ALI_SPDIF_CTRL + 1));
3383
3384         while (((R1 < 0x0B) || (R1 > 0x0E)) && (R1 != 0x12) &&
3385                count <= 50000) {
3386                 count++;
3387
3388                 ali_delay(card, 6);
3389
3390                 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3391                 R1 = bval & 0x1F;
3392         }
3393
3394         if (count > 50000) {
3395                 printk(KERN_WARNING "trident: Error in "
3396                        "ali_detect_spdif_rate!\n");
3397                 return;
3398         }
3399
3400         count = 0;
3401
3402         while (count <= 50000) {
3403                 count++;
3404
3405                 ali_delay(card, 6);
3406
3407                 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3408                 R2 = bval & 0x1F;
3409
3410                 if (R2 != R1)
3411                         R1 = R2;
3412                 else
3413                         break;
3414         }
3415
3416         if (count > 50000) {
3417                 printk(KERN_WARNING "trident: Error in "
3418                        "ali_detect_spdif_rate!\n");
3419                 return;
3420         }
3421
3422         switch (R2) {
3423         case 0x0b:
3424         case 0x0c:
3425         case 0x0d:
3426         case 0x0e:
3427                 wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
3428                 wval &= 0xE0F0;
3429                 wval |= (u16) 0x09 << 8 | (u16) 0x05;
3430                 outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
3431
3432                 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
3433                 outb(bval | 0x02, TRID_REG(card, ALI_SPDIF_CS + 3));
3434                 break;
3435
3436         case 0x12:
3437                 wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
3438                 wval &= 0xE0F0;
3439                 wval |= (u16) 0x0E << 8 | (u16) 0x08;
3440                 outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
3441
3442                 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
3443                 outb(bval | 0x03, TRID_REG(card, ALI_SPDIF_CS + 3));
3444                 break;
3445
3446         default:
3447                 break;
3448         }
3449
3450 }
3451
3452 static unsigned int
3453 ali_get_spdif_in_rate(struct trident_card *card)
3454 {
3455         u32 dwRate = 0;
3456         u8 bval = 0;
3457
3458         ali_detect_spdif_rate(card);
3459
3460         bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3461         bval &= 0x7F;
3462         bval |= 0x40;
3463         outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
3464
3465         bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3));
3466         bval &= 0x0F;
3467
3468         switch (bval) {
3469         case 0:
3470                 dwRate = 44100;
3471                 break;
3472         case 1:
3473                 dwRate = 48000;
3474                 break;
3475         case 2:
3476                 dwRate = 32000;
3477                 break;
3478         default:
3479                 // Error occurs
3480                 break;
3481         }
3482
3483         return dwRate;
3484
3485 }
3486
3487 static int
3488 ali_close_multi_channels(void)
3489 {
3490         char temp = 0;
3491         struct pci_dev *pci_dev = NULL;
3492
3493         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3494                                   pci_dev);
3495         if (pci_dev == NULL)
3496                 return -1;
3497         pci_read_config_byte(pci_dev, 0x59, &temp);
3498         temp &= ~0x80;
3499         pci_write_config_byte(pci_dev, 0x59, temp);
3500
3501         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
3502                                   pci_dev);
3503         if (pci_dev == NULL)
3504                 return -1;
3505
3506         pci_read_config_byte(pci_dev, 0xB8, &temp);
3507         temp &= ~0x20;
3508         pci_write_config_byte(pci_dev, 0xB8, temp);
3509
3510         return 0;
3511 }
3512
3513 static int
3514 ali_setup_multi_channels(struct trident_card *card, int chan_nums)
3515 {
3516         unsigned long dwValue;
3517         char temp = 0;
3518         struct pci_dev *pci_dev = NULL;
3519
3520         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3521                                   pci_dev);
3522         if (pci_dev == NULL)
3523                 return -1;
3524         pci_read_config_byte(pci_dev, 0x59, &temp);
3525         temp |= 0x80;
3526         pci_write_config_byte(pci_dev, 0x59, temp);
3527
3528         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
3529                                   pci_dev);
3530         if (pci_dev == NULL)
3531                 return -1;
3532         pci_read_config_byte(pci_dev, (int) 0xB8, &temp);
3533         temp |= 0x20;
3534         pci_write_config_byte(pci_dev, (int) 0xB8, (u8) temp);
3535         if (chan_nums == 6) {
3536                 dwValue = inl(TRID_REG(card, ALI_SCTRL)) | 0x000f0000;
3537                 outl(dwValue, TRID_REG(card, ALI_SCTRL));
3538                 mdelay(4);
3539                 dwValue = inl(TRID_REG(card, ALI_SCTRL));
3540                 if (dwValue & 0x2000000) {
3541                         ali_ac97_write(card->ac97_codec[0], 0x02, 8080);
3542                         ali_ac97_write(card->ac97_codec[0], 0x36, 0);
3543                         ali_ac97_write(card->ac97_codec[0], 0x38, 0);
3544                         /*
3545                          *      On a board with a single codec you won't get the
3546                          *      surround. On other boards configure it.
3547                          */
3548                         if (card->ac97_codec[1] != NULL) {
3549                                 ali_ac97_write(card->ac97_codec[1], 0x36, 0);
3550                                 ali_ac97_write(card->ac97_codec[1], 0x38, 0);
3551                                 ali_ac97_write(card->ac97_codec[1], 0x02, 0x0606);
3552                                 ali_ac97_write(card->ac97_codec[1], 0x18, 0x0303);
3553                                 ali_ac97_write(card->ac97_codec[1], 0x74, 0x3);
3554                         }
3555                         return 1;
3556                 }
3557         }
3558         return -EINVAL;
3559 }
3560
3561 static void
3562 ali_free_pcm_channel(struct trident_card *card, unsigned int channel)
3563 {
3564         int bank;
3565
3566         if (channel > 31)
3567                 return;
3568
3569         bank = channel >> 5;
3570         channel = channel & 0x1f;
3571
3572         card->banks[bank].bitmap &= ~(1 << (channel));
3573 }
3574
3575 static int
3576 ali_allocate_other_states_resources(struct trident_state *state, int chan_nums)
3577 {
3578         struct trident_card *card = state->card;
3579         struct trident_state *s;
3580         int i, state_count = 0;
3581         struct trident_pcm_bank *bank;
3582         struct trident_channel *channel;
3583         unsigned long num;
3584
3585         bank = &card->banks[BANK_A];
3586
3587         if (chan_nums != 6)
3588                 return 0;
3589
3590         for (i = 0; (i < ALI_CHANNELS) && (state_count != 4); i++) {
3591                 if (card->states[i])
3592                         continue;
3593
3594                 num = ali_multi_channels_5_1[state_count];
3595                 if (!(bank->bitmap & (1 << num))) {
3596                         bank->bitmap |= 1 << num;
3597                         channel = &bank->channels[num];
3598                         channel->num = num;
3599                 } else {
3600                         state_count--;
3601                         for (; state_count >= 0; state_count--) {
3602                                 kfree(state->other_states[state_count]);
3603                                 num = ali_multi_channels_5_1[state_count];
3604                                         ali_free_pcm_channel(card, num);
3605                         }
3606                         return -EBUSY;
3607                 }
3608                 s = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
3609                 if (!s) {
3610                         num = ali_multi_channels_5_1[state_count];
3611                         ali_free_pcm_channel(card, num);
3612                         state_count--;
3613                         for (; state_count >= 0; state_count--) {
3614                                 num = ali_multi_channels_5_1[state_count];
3615                                 ali_free_pcm_channel(card, num);
3616                                 kfree(state->other_states[state_count]);
3617                         }
3618                         return -ENOMEM;
3619                 }
3620                 memset(s, 0, sizeof(*state));
3621
3622                 s->dmabuf.channel = channel;
3623                 s->dmabuf.ossfragshift = s->dmabuf.ossmaxfrags =
3624                         s->dmabuf.subdivision = 0;
3625                 init_waitqueue_head(&s->dmabuf.wait);
3626                 s->magic = card->magic;
3627                 s->card = card;
3628                 s->virt = i;
3629                 ali_enable_special_channel(s);
3630                 state->other_states[state_count++] = s;
3631         }
3632
3633         if (state_count != 4) {
3634                 state_count--;
3635                 for (; state_count >= 0; state_count--) {
3636                         kfree(state->other_states[state_count]);
3637                         num = ali_multi_channels_5_1[state_count];
3638                         ali_free_pcm_channel(card, num);
3639                 }
3640                 return -EBUSY;
3641         }
3642         return 0;
3643 }
3644
3645 #ifdef CONFIG_PM
3646 /* save registers for ALi Power Management */
3647 static struct ali_saved_registers {
3648         unsigned long global_regs[ALI_GLOBAL_REGS];
3649         unsigned long channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS];
3650         unsigned mixer_regs[ALI_MIXER_REGS];
3651 } ali_registers;
3652
3653 static void
3654 ali_save_regs(struct trident_card *card)
3655 {
3656         unsigned long flags;
3657         int i, j;
3658
3659         spin_lock_irqsave(&card->lock, flags);
3660
3661         ali_registers.global_regs[0x2c] = inl(TRID_REG(card, T4D_MISCINT));
3662         //ali_registers.global_regs[0x20] = inl(TRID_REG(card,T4D_START_A));
3663         ali_registers.global_regs[0x21] = inl(TRID_REG(card, T4D_STOP_A));
3664
3665         //disable all IRQ bits
3666         outl(ALI_DISABLE_ALL_IRQ, TRID_REG(card, T4D_MISCINT));
3667
3668         for (i = 1; i < ALI_MIXER_REGS; i++)
3669                 ali_registers.mixer_regs[i] = ali_ac97_read(card->ac97_codec[0],
3670                                                             i * 2);
3671
3672         for (i = 0; i < ALI_GLOBAL_REGS; i++) {
3673                 if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A))
3674                         continue;
3675                 ali_registers.global_regs[i] = inl(TRID_REG(card, i * 4));
3676         }
3677
3678         for (i = 0; i < ALI_CHANNELS; i++) {
3679                 outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
3680                 for (j = 0; j < ALI_CHANNEL_REGS; j++)
3681                         ali_registers.channel_regs[i][j] = inl(TRID_REG(card,
3682                                                                         j * 4 + 0xe0));
3683         }
3684
3685         //Stop all HW channel
3686         outl(ALI_STOP_ALL_CHANNELS, TRID_REG(card, T4D_STOP_A));
3687
3688         spin_unlock_irqrestore(&card->lock, flags);
3689 }
3690
3691 static void
3692 ali_restore_regs(struct trident_card *card)
3693 {
3694         unsigned long flags;
3695         int i, j;
3696
3697         spin_lock_irqsave(&card->lock, flags);
3698
3699         for (i = 1; i < ALI_MIXER_REGS; i++)
3700                 ali_ac97_write(card->ac97_codec[0], i * 2,
3701                                ali_registers.mixer_regs[i]);
3702
3703         for (i = 0; i < ALI_CHANNELS; i++) {
3704                 outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
3705                 for (j = 0; j < ALI_CHANNEL_REGS; j++)
3706                         outl(ali_registers.channel_regs[i][j],
3707                              TRID_REG(card, j * 4 + 0xe0));
3708         }
3709
3710         for (i = 0; i < ALI_GLOBAL_REGS; i++) {
3711                 if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A) ||
3712                     (i * 4 == T4D_START_A))
3713                         continue;
3714                 outl(ali_registers.global_regs[i], TRID_REG(card, i * 4));
3715         }
3716
3717         //start HW channel
3718         outl(ali_registers.global_regs[0x20], TRID_REG(card, T4D_START_A));
3719         //restore IRQ enable bits
3720         outl(ali_registers.global_regs[0x2c], TRID_REG(card, T4D_MISCINT));
3721
3722         spin_unlock_irqrestore(&card->lock, flags);
3723 }
3724
3725 static int
3726 trident_suspend(struct pci_dev *dev, pm_message_t unused)
3727 {
3728         struct trident_card *card = pci_get_drvdata(dev);
3729
3730         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
3731                 ali_save_regs(card);
3732         }
3733         return 0;
3734 }
3735
3736 static int
3737 trident_resume(struct pci_dev *dev)
3738 {
3739         struct trident_card *card = pci_get_drvdata(dev);
3740
3741         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
3742                 ali_restore_regs(card);
3743         }
3744         return 0;
3745 }
3746 #endif
3747
3748 static struct trident_channel *
3749 ali_alloc_pcm_channel(struct trident_card *card)
3750 {
3751         struct trident_pcm_bank *bank;
3752         int idx;
3753
3754         bank = &card->banks[BANK_A];
3755
3756         if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) &
3757             (ALI_SPDIF_OUT_CH_ENABLE)) {
3758                 idx = ALI_SPDIF_OUT_CHANNEL;
3759                 if (!(bank->bitmap & (1 << idx))) {
3760                         struct trident_channel *channel = &bank->channels[idx];
3761                         bank->bitmap |= 1 << idx;
3762                         channel->num = idx;
3763                         return channel;
3764                 }
3765         }
3766
3767         for (idx = ALI_PCM_OUT_CHANNEL_FIRST; idx <= ALI_PCM_OUT_CHANNEL_LAST;
3768              idx++) {
3769                 if (!(bank->bitmap & (1 << idx))) {
3770                         struct trident_channel *channel = &bank->channels[idx];
3771                         bank->bitmap |= 1 << idx;
3772                         channel->num = idx;
3773                         return channel;
3774                 }
3775         }
3776
3777         /* no more free channels avaliable */
3778 #if 0
3779         printk(KERN_ERR "ali: no more channels available on Bank A.\n");
3780 #endif /* 0 */
3781         return NULL;
3782 }
3783
3784 static struct trident_channel *
3785 ali_alloc_rec_pcm_channel(struct trident_card *card)
3786 {
3787         struct trident_pcm_bank *bank;
3788         int idx;
3789
3790         if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) & ALI_SPDIF_IN_SUPPORT)
3791                 idx = ALI_SPDIF_IN_CHANNEL;
3792         else
3793                 idx = ALI_PCM_IN_CHANNEL;
3794
3795         bank = &card->banks[BANK_A];
3796
3797         if (!(bank->bitmap & (1 << idx))) {
3798                 struct trident_channel *channel = &bank->channels[idx];
3799                 bank->bitmap |= 1 << idx;
3800                 channel->num = idx;
3801                 return channel;
3802         }
3803
3804         /* no free recordable channels avaliable */
3805 #if 0
3806         printk(KERN_ERR "ali: no recordable channels available on Bank A.\n");
3807 #endif /* 0 */
3808         return NULL;
3809 }
3810
3811 static void
3812 ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate)
3813 {
3814         unsigned char ch_st_sel;
3815         unsigned short status_rate;
3816
3817         switch (rate) {
3818         case 44100:
3819                 status_rate = 0;
3820                 break;
3821         case 32000:
3822                 status_rate = 0x300;
3823                 break;
3824         case 48000:
3825         default:
3826                 status_rate = 0x200;
3827                 break;
3828         }
3829
3830         /* select spdif_out */
3831         ch_st_sel = inb(TRID_REG(card, ALI_SPDIF_CTRL)) & ALI_SPDIF_OUT_CH_STATUS;
3832
3833         ch_st_sel |= 0x80;      /* select right */
3834         outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
3835         outb(status_rate | 0x20, TRID_REG(card, ALI_SPDIF_CS + 2));
3836
3837         ch_st_sel &= (~0x80);   /* select left */
3838         outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
3839         outw(status_rate | 0x10, TRID_REG(card, ALI_SPDIF_CS + 2));
3840 }
3841
3842 static void
3843 ali_address_interrupt(struct trident_card *card)
3844 {
3845         int i, channel;
3846         struct trident_state *state;
3847         u32 mask, channel_mask;
3848
3849         mask = trident_get_interrupt_mask(card, 0);
3850         for (i = 0; i < NR_HW_CH; i++) {
3851                 if ((state = card->states[i]) == NULL)
3852                         continue;
3853                 channel = state->dmabuf.channel->num;
3854                 if ((channel_mask = 1 << channel) & mask) {
3855                         mask &= ~channel_mask;
3856                         trident_ack_channel_interrupt(card, channel);
3857                         udelay(100);
3858                         state->dmabuf.update_flag |= ALI_ADDRESS_INT_UPDATE;
3859                         trident_update_ptr(state);
3860                 }
3861         }
3862         if (mask) {
3863                 for (i = 0; i < NR_HW_CH; i++) {
3864                         if (mask & (1 << i)) {
3865                                 printk("ali: spurious channel irq %d.\n", i);
3866                                 trident_ack_channel_interrupt(card, i);
3867                                 trident_stop_voice(card, i);
3868                                 trident_disable_voice_irq(card, i);
3869                         }
3870                 }
3871         }
3872 }
3873
3874 /* Updating the values of counters of other_states' DMAs without lock
3875 protection is no harm because all DMAs of multi-channels and interrupt
3876 depend on a master state's DMA, and changing the counters of the master
3877 state DMA is protected by a spinlock.
3878 */
3879 static int
3880 ali_write_5_1(struct trident_state *state, const char __user *buf,
3881               int cnt_for_multi_channel, unsigned int *copy_count,
3882               unsigned int *state_cnt)
3883 {
3884
3885         struct dmabuf *dmabuf = &state->dmabuf;
3886         struct dmabuf *dmabuf_temp;
3887         const char __user *buffer = buf;
3888         unsigned swptr, other_dma_nums, sample_s;
3889         unsigned int i, loop;
3890
3891         other_dma_nums = 4;
3892         sample_s = sample_size[dmabuf->fmt] >> 1;
3893         swptr = dmabuf->swptr;
3894
3895         if ((i = state->multi_channels_adjust_count) > 0) {
3896                 if (i == 1) {
3897                         if (copy_from_user(dmabuf->rawbuf + swptr,
3898                                            buffer, sample_s))
3899                                 return -EFAULT;
3900                         seek_offset(swptr, buffer, cnt_for_multi_channel,
3901                                     sample_s, *copy_count);
3902                         i--;
3903                         (*state_cnt) += sample_s;
3904                         state->multi_channels_adjust_count++;
3905                 } else
3906                         i = i - (state->chans_num - other_dma_nums);
3907                 for (; (i < other_dma_nums) && (cnt_for_multi_channel > 0); i++) {
3908                         dmabuf_temp = &state->other_states[i]->dmabuf;
3909                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3910                                            buffer, sample_s))
3911                                 return -EFAULT;
3912                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3913                                     sample_s, *copy_count);
3914                 }
3915                 if (cnt_for_multi_channel == 0)
3916                         state->multi_channels_adjust_count += i;
3917         }
3918         if (cnt_for_multi_channel > 0) {
3919                 loop = cnt_for_multi_channel / (state->chans_num * sample_s);
3920                 for (i = 0; i < loop; i++) {
3921                         if (copy_from_user(dmabuf->rawbuf + swptr, buffer,
3922                                            sample_s * 2))
3923                                 return -EFAULT;
3924                         seek_offset(swptr, buffer, cnt_for_multi_channel,
3925                                     sample_s * 2, *copy_count);
3926                         (*state_cnt) += (sample_s * 2);
3927
3928                         dmabuf_temp = &state->other_states[0]->dmabuf;
3929                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3930                                            buffer, sample_s))
3931                                 return -EFAULT;
3932                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3933                                     sample_s, *copy_count);
3934
3935                         dmabuf_temp = &state->other_states[1]->dmabuf;
3936                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3937                                            buffer, sample_s))
3938                                 return -EFAULT;
3939                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3940                                     sample_s, *copy_count);
3941
3942                         dmabuf_temp = &state->other_states[2]->dmabuf;
3943                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3944                                            buffer, sample_s))
3945                                 return -EFAULT;
3946                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3947                                     sample_s, *copy_count);
3948
3949                         dmabuf_temp = &state->other_states[3]->dmabuf;
3950                         if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3951                                            buffer, sample_s))
3952                                 return -EFAULT;
3953                         seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3954                                     sample_s, *copy_count);
3955                 }
3956
3957                 if (cnt_for_multi_channel > 0) {
3958                         state->multi_channels_adjust_count = cnt_for_multi_channel / sample_s;
3959
3960                         if (copy_from_user(dmabuf->rawbuf + swptr, buffer, sample_s))
3961                                 return -EFAULT;
3962                         seek_offset(swptr, buffer, cnt_for_multi_channel,
3963                                     sample_s, *copy_count);
3964                         (*state_cnt) += sample_s;
3965
3966                         if (cnt_for_multi_channel > 0) {
3967                                 if (copy_from_user(dmabuf->rawbuf + swptr,
3968                                                    buffer, sample_s))
3969                                         return -EFAULT;
3970                                 seek_offset(swptr, buffer, cnt_for_multi_channel,
3971                                             sample_s, *copy_count);
3972                                 (*state_cnt) += sample_s;
3973
3974                                 if (cnt_for_multi_channel > 0) {
3975                                         int diff = state->chans_num - other_dma_nums;
3976                                         loop = state->multi_channels_adjust_count - diff;
3977                                         for (i = 0; i < loop; i++) {
3978                                                 dmabuf_temp = &state->other_states[i]->dmabuf;
3979                                                 if (copy_from_user(dmabuf_temp->rawbuf +
3980                                                                    dmabuf_temp->swptr,
3981                                                                    buffer, sample_s))
3982                                                         return -EFAULT;
3983                                                 seek_offset(dmabuf_temp->swptr, buffer,
3984                                                             cnt_for_multi_channel,
3985                                                             sample_s, *copy_count);
3986                                         }
3987                                 }
3988                         }
3989                 } else
3990                         state->multi_channels_adjust_count = 0;
3991         }
3992         for (i = 0; i < other_dma_nums; i++) {
3993                 dmabuf_temp = &state->other_states[i]->dmabuf;
3994                 dmabuf_temp->swptr = dmabuf_temp->swptr % dmabuf_temp->dmasize;
3995         }
3996         return *state_cnt;
3997 }
3998
3999 static void
4000 ali_free_other_states_resources(struct trident_state *state)
4001 {
4002         int i;
4003         struct trident_card *card = state->card;
4004         struct trident_state *s;
4005         unsigned other_states_count;
4006
4007         other_states_count = state->chans_num - 2; /* except PCM L/R channels */
4008         for (i = 0; i < other_states_count; i++) {
4009                 s = state->other_states[i];
4010                 dealloc_dmabuf(&s->dmabuf, card->pci_dev);
4011                 ali_disable_special_channel(s->card, s->dmabuf.channel->num);
4012                 state->card->free_pcm_channel(s->card, s->dmabuf.channel->num);
4013                 card->states[s->virt] = NULL;
4014                 kfree(s);
4015         }
4016 }
4017
4018 static struct proc_dir_entry *res;
4019
4020 static int
4021 ali_write_proc(struct file *file, const char __user *buffer, unsigned long count, void *data)
4022 {
4023         struct trident_card *card = (struct trident_card *) data;
4024         unsigned long flags;
4025         char c;
4026
4027         if (count < 0)
4028                 return -EINVAL;
4029         if (count == 0)
4030                 return 0;
4031         if (get_user(c, buffer))
4032                 return -EFAULT;
4033
4034         spin_lock_irqsave(&card->lock, flags);
4035         switch (c) {
4036         case '0':
4037                 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4038                 ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
4039                 break;
4040         case '1':
4041                 ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
4042                                     ALI_SPDIF_OUT_PCM);
4043                 break;
4044         case '2':
4045                 ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
4046                                     ALI_SPDIF_OUT_NON_PCM);
4047                 break;
4048         case '3':
4049                 ali_disable_spdif_in(card);     //default
4050                 break;
4051         case '4':
4052                 ali_setup_spdif_in(card);
4053                 break;
4054         }
4055         spin_unlock_irqrestore(&card->lock, flags);
4056
4057         return count;
4058 }
4059
4060 /* OSS /dev/mixer file operation methods */
4061 static int
4062 trident_open_mixdev(struct inode *inode, struct file *file)
4063 {
4064         int i = 0;
4065         int minor = iminor(inode);
4066         struct trident_card *card = devs;
4067
4068         for (card = devs; card != NULL; card = card->next)
4069                 for (i = 0; i < NR_AC97; i++)
4070                         if (card->ac97_codec[i] != NULL &&
4071                             card->ac97_codec[i]->dev_mixer == minor)
4072                                 goto match;
4073
4074         if (!card) {
4075                 return -ENODEV;
4076         }
4077       match:
4078         file->private_data = card->ac97_codec[i];
4079
4080         return nonseekable_open(inode, file);
4081 }
4082
4083 static int
4084 trident_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4085                      unsigned long arg)
4086 {
4087         struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
4088
4089         return codec->mixer_ioctl(codec, cmd, arg);
4090 }
4091
4092 static /*const */ struct file_operations trident_mixer_fops = {
4093         .owner = THIS_MODULE,
4094         .llseek = no_llseek,
4095         .ioctl = trident_ioctl_mixdev,
4096         .open = trident_open_mixdev,
4097 };
4098
4099 static int
4100 ali_reset_5451(struct trident_card *card)
4101 {
4102         struct pci_dev *pci_dev = NULL;
4103         unsigned int dwVal;
4104         unsigned short wCount, wReg;
4105
4106         pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
4107                                   pci_dev);
4108         if (pci_dev == NULL)
4109                 return -1;
4110
4111         pci_read_config_dword(pci_dev, 0x7c, &dwVal);
4112         pci_write_config_dword(pci_dev, 0x7c, dwVal | 0x08000000);
4113         udelay(5000);
4114         pci_read_config_dword(pci_dev, 0x7c, &dwVal);
4115         pci_write_config_dword(pci_dev, 0x7c, dwVal & 0xf7ffffff);
4116         udelay(5000);
4117
4118         pci_dev = card->pci_dev;
4119         if (pci_dev == NULL)
4120                 return -1;
4121
4122         pci_read_config_dword(pci_dev, 0x44, &dwVal);
4123         pci_write_config_dword(pci_dev, 0x44, dwVal | 0x000c0000);
4124         udelay(500);
4125         pci_read_config_dword(pci_dev, 0x44, &dwVal);
4126         pci_write_config_dword(pci_dev, 0x44, dwVal & 0xfffbffff);
4127         udelay(5000);
4128
4129         /* TODO: recognize if we have a PM capable codec and only do this */
4130         /* if the codec is PM capable */
4131         wCount = 2000;
4132         while (wCount--) {
4133                 wReg = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
4134                 if ((wReg & 0x000f) == 0x000f)
4135                         return 0;
4136                 udelay(5000);
4137         }
4138         /* This is non fatal if you have a non PM capable codec.. */
4139         return 0;
4140 }
4141
4142 /* AC97 codec initialisation. */
4143 static int __devinit
4144 trident_ac97_init(struct trident_card *card)
4145 {
4146         int num_ac97 = 0;
4147         unsigned long ready_2nd = 0;
4148         struct ac97_codec *codec;
4149         int i = 0;
4150
4151         /* initialize controller side of AC link, and find out if secondary codes
4152            really exist */
4153         switch (card->pci_id) {
4154         case PCI_DEVICE_ID_ALI_5451:
4155                 if (ali_reset_5451(card)) {
4156                         printk(KERN_ERR "trident_ac97_init: error "
4157                                "resetting 5451.\n");
4158                         return -1;
4159                 }
4160                 outl(0x80000001, TRID_REG(card, ALI_GLOBAL_CONTROL));
4161                 outl(0x00000000, TRID_REG(card, T4D_AINTEN_A));
4162                 outl(0xffffffff, TRID_REG(card, T4D_AINT_A));
4163                 outl(0x00000000, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
4164                 outb(0x10, TRID_REG(card, ALI_MPUR2));
4165                 ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
4166                 ready_2nd &= 0x3fff;
4167                 outl(ready_2nd | PCMOUT | 0x8000, TRID_REG(card, ALI_SCTRL));
4168                 ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
4169                 ready_2nd &= SI_AC97_SECONDARY_READY;
4170                 if (card->revision < ALI_5451_V02)
4171                         ready_2nd = 0;
4172                 break;
4173         case PCI_DEVICE_ID_SI_7018:
4174                 /* disable AC97 GPIO interrupt */
4175                 outl(0x00, TRID_REG(card, SI_AC97_GPIO));
4176                 /* when power up the AC link is in cold reset mode so stop it */
4177                 outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT | SECONDARY_ID,
4178                      TRID_REG(card, SI_SERIAL_INTF_CTRL));
4179                 /* it take a long time to recover from a cold reset */
4180                 /* (especially when you have more than one codec) */
4181                 udelay(2000);
4182                 ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
4183                 ready_2nd &= SI_AC97_SECONDARY_READY;
4184                 break;
4185         case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
4186                 /* playback on */
4187                 outl(DX_AC97_PLAYBACK, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
4188                 break;
4189         case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
4190                 /* enable AC97 Output Slot 3,4 (PCM Left/Right Playback) */
4191                 outl(NX_AC97_PCM_OUTPUT, TRID_REG(card, NX_ACR0_AC97_COM_STAT));
4192                 ready_2nd = inl(TRID_REG(card, NX_ACR0_AC97_COM_STAT));
4193                 ready_2nd &= NX_AC97_SECONDARY_READY;
4194                 break;
4195         case PCI_DEVICE_ID_INTERG_5050:
4196                 /* disable AC97 GPIO interrupt */
4197                 outl(0x00, TRID_REG(card, SI_AC97_GPIO));
4198                 /* when power up, the AC link is in cold reset mode, so stop it */
4199                 outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT,
4200                      TRID_REG(card, SI_SERIAL_INTF_CTRL));
4201                 /* it take a long time to recover from a cold reset (especially */
4202                 /* when you have more than one codec) */
4203                 udelay(2000);
4204                 ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
4205                 ready_2nd &= SI_AC97_SECONDARY_READY;
4206                 break;
4207         }
4208
4209         for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4210                 if ((codec = ac97_alloc_codec()) == NULL)
4211                         return -ENOMEM;
4212
4213                 /* initialize some basic codec information, other fields */
4214                 /* will be filled in ac97_probe_codec */
4215                 codec->private_data = card;
4216                 codec->id = num_ac97;
4217
4218                 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4219                         codec->codec_read = ali_ac97_read;
4220                         codec->codec_write = ali_ac97_write;
4221                 } else {
4222                         codec->codec_read = trident_ac97_get;
4223                         codec->codec_write = trident_ac97_set;
4224                 }
4225
4226                 if (ac97_probe_codec(codec) == 0)
4227                         break;
4228
4229                 codec->dev_mixer = register_sound_mixer(&trident_mixer_fops, -1);
4230                 if (codec->dev_mixer < 0) {
4231                         printk(KERN_ERR "trident: couldn't register mixer!\n");
4232                         ac97_release_codec(codec);
4233                         break;
4234                 }
4235
4236                 card->ac97_codec[num_ac97] = codec;
4237
4238                 /* if there is no secondary codec at all, don't probe any more */
4239                 if (!ready_2nd)
4240                         break;
4241         }
4242
4243         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4244                 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4245                         if (card->ac97_codec[num_ac97] == NULL)
4246                                 break;
4247                         for (i = 0; i < 64; i++) {
4248                                 u16 reg = ali_ac97_get(card, num_ac97, i * 2);
4249                                 card->mixer_regs[i][num_ac97] = reg;
4250                         }
4251                 }
4252         }
4253         return num_ac97 + 1;
4254 }
4255
4256 #ifdef SUPPORT_JOYSTICK
4257 /* Gameport functions for the cards ADC gameport */
4258
4259 static unsigned char trident_game_read(struct gameport *gameport)
4260 {
4261         struct trident_card *card = gameport->port_data;
4262
4263         return inb(TRID_REG(card, T4D_GAME_LEG));
4264 }
4265
4266 static void trident_game_trigger(struct gameport *gameport)
4267 {
4268         struct trident_card *card = gameport->port_data;
4269
4270         outb(0xff, TRID_REG(card, T4D_GAME_LEG));
4271 }
4272
4273 static int trident_game_cooked_read(struct gameport *gameport,
4274                                     int *axes, int *buttons)
4275 {
4276         struct trident_card *card = gameport->port_data;
4277         int i;
4278
4279         *buttons = (~inb(TRID_REG(card, T4D_GAME_LEG)) >> 4) & 0xf;
4280
4281         for (i = 0; i < 4; i++) {
4282                 axes[i] = inw(TRID_REG(card, T4D_GAME_AXD) + i * sizeof (u16));
4283                 if (axes[i] == 0xffff)
4284                         axes[i] = -1;
4285         }
4286
4287         return 0;
4288 }
4289
4290 static int trident_game_open(struct gameport *gameport, int mode)
4291 {
4292         struct trident_card *card = gameport->port_data;
4293
4294         switch (mode) {
4295         case GAMEPORT_MODE_COOKED:
4296                 outb(0x80, TRID_REG(card, T4D_GAME_CR));
4297                 msleep(20);
4298                 return 0;
4299         case GAMEPORT_MODE_RAW:
4300                 outb(0x00, TRID_REG(card, T4D_GAME_CR));
4301                 return 0;
4302         default:
4303                 return -1;
4304         }
4305
4306         return 0;
4307 }
4308
4309 static int __devinit trident_register_gameport(struct trident_card *card)
4310 {
4311         struct gameport *gp;
4312
4313         card->gameport = gp = gameport_allocate_port();
4314         if (!gp) {
4315                 printk(KERN_ERR "trident: can not allocate memory for gameport\n");
4316                 return -ENOMEM;
4317         }
4318
4319         gameport_set_name(gp, "Trident 4DWave");
4320         gameport_set_phys(gp, "pci%s/gameport0", pci_name(card->pci_dev));
4321         gp->read = trident_game_read;
4322         gp->trigger = trident_game_trigger;
4323         gp->cooked_read = trident_game_cooked_read;
4324         gp->open = trident_game_open;
4325         gp->fuzz = 64;
4326         gp->port_data = card;
4327
4328         gameport_register_port(gp);
4329
4330         return 0;
4331 }
4332
4333 static inline void trident_unregister_gameport(struct trident_card *card)
4334 {
4335         if (card->gameport)
4336                 gameport_unregister_port(card->gameport);
4337 }
4338
4339 #else
4340 static inline int trident_register_gameport(struct trident_card *card) { return -ENOSYS; }
4341 static inline void trident_unregister_gameport(struct trident_card *card) { }
4342 #endif /* SUPPORT_JOYSTICK */
4343
4344 /* install the driver, we do not allocate hardware channel nor DMA buffer */
4345 /* now, they are defered until "ACCESS" time (in prog_dmabuf called by */
4346 /* open/read/write/ioctl/mmap) */
4347 static int __devinit
4348 trident_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
4349 {
4350         unsigned long iobase;
4351         struct trident_card *card;
4352         u8 bits;
4353         u8 revision;
4354         int i = 0;
4355         u16 temp;
4356         struct pci_dev *pci_dev_m1533 = NULL;
4357         int rc = -ENODEV;
4358         u64 dma_mask;
4359
4360         if (pci_enable_device(pci_dev))
4361                 goto out;
4362
4363         if (pci_dev->device == PCI_DEVICE_ID_ALI_5451)
4364                 dma_mask = ALI_DMA_MASK;
4365         else
4366                 dma_mask = TRIDENT_DMA_MASK;
4367         if (pci_set_dma_mask(pci_dev, dma_mask)) {
4368                 printk(KERN_ERR "trident: architecture does not support"
4369                        " %s PCI busmaster DMA\n",
4370                        pci_dev->device == PCI_DEVICE_ID_ALI_5451 ?
4371                        "32-bit" : "30-bit");
4372                 goto out;
4373         }
4374         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
4375
4376         if (pci_id->device == PCI_DEVICE_ID_INTERG_5050)
4377                 iobase = pci_resource_start(pci_dev, 1);
4378         else
4379                 iobase = pci_resource_start(pci_dev, 0);
4380
4381         if (!request_region(iobase, 256, card_names[pci_id->driver_data])) {
4382                 printk(KERN_ERR "trident: can't allocate I/O space at "
4383                        "0x%4.4lx\n", iobase);
4384                 goto out;
4385         }
4386
4387         rc = -ENOMEM;
4388         if ((card = kmalloc(sizeof(*card), GFP_KERNEL)) == NULL) {
4389                 printk(KERN_ERR "trident: out of memory\n");
4390                 goto out_release_region;
4391         }
4392         memset(card, 0, sizeof (*card));
4393
4394         init_timer(&card->timer);
4395         card->iobase = iobase;
4396         card->pci_dev = pci_dev;
4397         card->pci_id = pci_id->device;
4398         card->revision = revision;
4399         card->irq = pci_dev->irq;
4400         card->next = devs;
4401         card->magic = TRIDENT_CARD_MAGIC;
4402         card->banks[BANK_A].addresses = &bank_a_addrs;
4403         card->banks[BANK_A].bitmap = 0UL;
4404         card->banks[BANK_B].addresses = &bank_b_addrs;
4405         card->banks[BANK_B].bitmap = 0UL;
4406
4407         mutex_init(&card->open_mutex);
4408         spin_lock_init(&card->lock);
4409         init_timer(&card->timer);
4410
4411         devs = card;
4412
4413         pci_set_master(pci_dev);
4414
4415         printk(KERN_INFO "trident: %s found at IO 0x%04lx, IRQ %d\n",
4416                card_names[pci_id->driver_data], card->iobase, card->irq);
4417
4418         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4419                 /* ALi channel Management */
4420                 card->alloc_pcm_channel = ali_alloc_pcm_channel;
4421                 card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
4422                 card->free_pcm_channel = ali_free_pcm_channel;
4423
4424                 card->address_interrupt = ali_address_interrupt;
4425
4426                 /* Added by Matt Wu 01-05-2001 for spdif in */
4427                 card->multi_channel_use_count = 0;
4428                 card->rec_channel_use_count = 0;
4429
4430                 /* ALi SPDIF OUT function */
4431                 if (card->revision == ALI_5451_V02) {
4432                         ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4433                         res = create_proc_entry("ALi5451", 0, NULL);
4434                         if (res) {
4435                                 res->write_proc = ali_write_proc;
4436                                 res->data = card;
4437                         }
4438                 }
4439
4440                 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4441                 card->hwvolctl = 0;
4442                 pci_dev_m1533 = pci_find_device(PCI_VENDOR_ID_AL,
4443                                                 PCI_DEVICE_ID_AL_M1533,
4444                                                 pci_dev_m1533);
4445                 rc = -ENODEV;
4446                 if (pci_dev_m1533 == NULL)
4447                         goto out_proc_fs;
4448                 pci_read_config_byte(pci_dev_m1533, 0x63, &bits);
4449                 if (bits & (1 << 5))
4450                         card->hwvolctl = 1;
4451                 if (card->hwvolctl) {
4452                         /* Clear m1533 pci cfg 78h bit 30 to zero, which makes
4453                            GPIO11/12/13 work as ACGP_UP/DOWN/MUTE. */
4454                         pci_read_config_byte(pci_dev_m1533, 0x7b, &bits);
4455                         bits &= 0xbf;   /*clear bit 6 */
4456                         pci_write_config_byte(pci_dev_m1533, 0x7b, bits);
4457                 }
4458         } else if (card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
4459                 card->alloc_pcm_channel = cyber_alloc_pcm_channel;
4460                 card->alloc_rec_pcm_channel = cyber_alloc_pcm_channel;
4461                 card->free_pcm_channel = cyber_free_pcm_channel;
4462                 card->address_interrupt = cyber_address_interrupt;
4463                 cyber_init_ritual(card);
4464         } else {
4465                 card->alloc_pcm_channel = trident_alloc_pcm_channel;
4466                 card->alloc_rec_pcm_channel = trident_alloc_pcm_channel;
4467                 card->free_pcm_channel = trident_free_pcm_channel;
4468                 card->address_interrupt = trident_address_interrupt;
4469         }
4470
4471         /* claim our irq */
4472         rc = -ENODEV;
4473         if (request_irq(card->irq, &trident_interrupt, IRQF_SHARED,
4474                         card_names[pci_id->driver_data], card)) {
4475                 printk(KERN_ERR "trident: unable to allocate irq %d\n",
4476                        card->irq);
4477                 goto out_proc_fs;
4478         }
4479         /* register /dev/dsp */
4480         if ((card->dev_audio = register_sound_dsp(&trident_audio_fops, -1)) < 0) {
4481                 printk(KERN_ERR "trident: couldn't register DSP device!\n");
4482                 goto out_free_irq;
4483         }
4484         card->mixer_regs_ready = 0;
4485         /* initialize AC97 codec and register /dev/mixer */
4486         if (trident_ac97_init(card) <= 0) {
4487                 /* unregister audio devices */
4488                 for (i = 0; i < NR_AC97; i++) {
4489                         if (card->ac97_codec[i] != NULL) {
4490                                 struct ac97_codec* codec = card->ac97_codec[i];
4491                                 unregister_sound_mixer(codec->dev_mixer);
4492                                 ac97_release_codec(codec);
4493                         }
4494                 }
4495                 goto out_unregister_sound_dsp;
4496         }
4497         card->mixer_regs_ready = 1;
4498         outl(0x00, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
4499
4500         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4501                 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4502                 if (card->hwvolctl) {
4503                         /* Enable GPIO IRQ (MISCINT bit 18h) */
4504                         temp = inw(TRID_REG(card, T4D_MISCINT + 2));
4505                         temp |= 0x0004;
4506                         outw(temp, TRID_REG(card, T4D_MISCINT + 2));
4507
4508                         /* Enable H/W Volume Control GLOVAL CONTROL bit 0 */
4509                         temp = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
4510                         temp |= 0x0001;
4511                         outw(temp, TRID_REG(card, ALI_GLOBAL_CONTROL));
4512
4513                 }
4514                 if (card->revision == ALI_5451_V02)
4515                         ali_close_multi_channels();
4516                 /* edited by HMSEO for GT sound */
4517 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
4518                 {
4519                         u16 ac97_data;
4520                         extern struct hwrpb_struct *hwrpb;
4521
4522                         if ((hwrpb->sys_type) == 201) {
4523                                 printk(KERN_INFO "trident: Running on Alpha system "
4524                                        "type Nautilus\n");
4525                                 ac97_data = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
4526                                 ali_ac97_set(card, 0, AC97_POWER_CONTROL,
4527                                              ac97_data | ALI_EAPD_POWER_DOWN);
4528                         }
4529                 }
4530 #endif                          /* CONFIG_ALPHA_NAUTILUS || CONFIG_ALPHA_GENERIC */
4531                 /* edited by HMSEO for GT sound */
4532         }
4533         rc = 0;
4534         pci_set_drvdata(pci_dev, card);
4535
4536         /* Enable Address Engine Interrupts */
4537         trident_enable_loop_interrupts(card);
4538
4539         /* Register gameport */
4540         trident_register_gameport(card);
4541
4542 out:
4543         return rc;
4544
4545 out_unregister_sound_dsp:
4546         unregister_sound_dsp(card->dev_audio);
4547 out_free_irq:
4548         free_irq(card->irq, card);
4549 out_proc_fs:
4550         if (res) {
4551                 remove_proc_entry("ALi5451", NULL);
4552                 res = NULL;
4553         }
4554         kfree(card);
4555         devs = NULL;
4556 out_release_region:
4557         release_region(iobase, 256);
4558         return rc;
4559 }
4560
4561 static void __devexit
4562 trident_remove(struct pci_dev *pci_dev)
4563 {
4564         int i;
4565         struct trident_card *card = pci_get_drvdata(pci_dev);
4566
4567         /*
4568          *      Kill running timers before unload. We can't have them
4569          *      going off after rmmod!
4570          */
4571         if (card->hwvolctl)
4572                 del_timer_sync(&card->timer);
4573
4574         /* ALi S/PDIF and Power Management */
4575         if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4576                 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4577                 ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
4578                 ali_disable_spdif_in(card);
4579                 remove_proc_entry("ALi5451", NULL);
4580         }
4581
4582         /* Unregister gameport */
4583         trident_unregister_gameport(card);
4584
4585         /* Kill interrupts, and SP/DIF */
4586         trident_disable_loop_interrupts(card);
4587
4588         /* free hardware resources */
4589         free_irq(card->irq, card);
4590         release_region(card->iobase, 256);
4591
4592         /* unregister audio devices */
4593         for (i = 0; i < NR_AC97; i++)
4594                 if (card->ac97_codec[i] != NULL) {
4595                         unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
4596                         ac97_release_codec(card->ac97_codec[i]);
4597                 }
4598         unregister_sound_dsp(card->dev_audio);
4599
4600         kfree(card);
4601
4602         pci_set_drvdata(pci_dev, NULL);
4603 }
4604
4605 MODULE_AUTHOR("Alan Cox, Aaron Holtzman, Ollie Lho, Ching Ling Lee, Muli Ben-Yehuda");
4606 MODULE_DESCRIPTION("Trident 4DWave/SiS 7018/ALi 5451 and Tvia/IGST CyberPro5050 PCI "
4607                    "Audio Driver");
4608 MODULE_LICENSE("GPL");
4609
4610 #define TRIDENT_MODULE_NAME "trident"
4611
4612 static struct pci_driver trident_pci_driver = {
4613         .name = TRIDENT_MODULE_NAME,
4614         .id_table = trident_pci_tbl,
4615         .probe = trident_probe,
4616         .remove = __devexit_p(trident_remove),
4617 #ifdef CONFIG_PM
4618         .suspend = trident_suspend,
4619         .resume = trident_resume
4620 #endif
4621 };
4622
4623 static int __init
4624 trident_init_module(void)
4625 {
4626         printk(KERN_INFO "Trident 4DWave/SiS 7018/ALi 5451,Tvia CyberPro "
4627                "5050 PCI Audio, version " DRIVER_VERSION ", " __TIME__ " "
4628                __DATE__ "\n");
4629
4630         return pci_register_driver(&trident_pci_driver);
4631 }
4632
4633 static void __exit
4634 trident_cleanup_module(void)
4635 {
4636         pci_unregister_driver(&trident_pci_driver);
4637 }
4638
4639 module_init(trident_init_module);
4640 module_exit(trident_cleanup_module);