2 * OSS driver for Linux 2.[46].x for
7 * Tvia/IGST CyberPro 5050
9 * Driver: Alan Cox <alan@redhat.com>
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>
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>
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.
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.
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.
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.
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().
50 * Sept 10 2002 Pascal Schmidt <der.eremit@email.de>
51 * added support for ALi 5451 joystick port
53 * Sept 05 2002 Alan Cox <alan@redhat.com>
54 * adapt to new pci joystick attachment interface
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*.
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.
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.
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.
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.
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.
82 * June 6 2002 Lei Hu <Lei_hu@ali.com.tw>
83 * rewrite the part to read/write registers of audio codec for Ali5451
85 * January 2 2002 Vojtech Pavlik <vojtech@ucw.cz> added gameport
86 * support to avoid resource conflict with pcigame.c
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
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)
96 * Switch to static inline not extern inline (gcc 3)
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
104 * Jul 10 2001 Matt Wu
105 * Add H/W Volume Control
107 * July 7 2001 Alan Cox
108 * Moved Matt Wu's ac97 register cache into the card structure
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
115 * Mar 09 2001 Matt Wu
116 * Add cache for ac97 access
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+
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
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)
188 * "Channel Binding" ioctl extension (done)
189 * new pci device driver interface for 2.4 kernel (done)
191 * Lock order (high->low)
192 * lock - hardware lock
193 * open_sem - guard opens
194 * sem - guard dmabuf, write re-entry etc
197 #include <linux/config.h>
198 #include <linux/module.h>
199 #include <linux/string.h>
200 #include <linux/ctype.h>
201 #include <linux/ioport.h>
202 #include <linux/sched.h>
203 #include <linux/delay.h>
204 #include <linux/sound.h>
205 #include <linux/slab.h>
206 #include <linux/soundcard.h>
207 #include <linux/pci.h>
208 #include <linux/init.h>
209 #include <linux/poll.h>
210 #include <linux/spinlock.h>
211 #include <linux/smp_lock.h>
212 #include <linux/ac97_codec.h>
213 #include <linux/bitops.h>
214 #include <linux/proc_fs.h>
215 #include <linux/interrupt.h>
216 #include <linux/pm.h>
217 #include <linux/gameport.h>
218 #include <linux/kernel.h>
219 #include <asm/uaccess.h>
223 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
224 #include <asm/hwrpb.h>
229 #define DRIVER_VERSION "0.14.10j-2.6"
231 /* magic numbers to protect our data structures */
232 #define TRIDENT_CARD_MAGIC 0x5072696E /* "Prin" */
233 #define TRIDENT_STATE_MAGIC 0x63657373 /* "cess" */
235 #define TRIDENT_DMA_MASK 0x3fffffff /* DMA buffer mask for pci_alloc_consist */
236 #define ALI_DMA_MASK 0x7fffffff /* ALI Tridents have 31-bit DMA. Wow. */
240 /* maximum number of AC97 codecs connected, AC97 2.0 defined 4, but 7018 and 4D-NX only
241 have 2 SDATA_IN lines (currently) */
244 /* minor number of /dev/swmodem (temporary, experimental) */
245 #define SND_DEV_SWMODEM 7
247 static const unsigned ali_multi_channels_5_1[] = {
248 /*ALI_SURR_LEFT_CHANNEL, ALI_SURR_RIGHT_CHANNEL, */
251 ALI_SURR_LEFT_CHANNEL,
252 ALI_SURR_RIGHT_CHANNEL
255 static const unsigned sample_size[] = { 1, 2, 2, 4 };
256 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
258 static const char invalid_magic[] = KERN_CRIT "trident: invalid magic value in %s\n";
268 static char *card_names[] = {
271 "SiS 7018 PCI Audio",
272 "ALi Audio Accelerator",
273 "Tvia/IGST CyberPro 5050"
276 static struct pci_device_id trident_pci_tbl[] = {
277 {PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_DX,
278 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TRIDENT_4D_DX},
279 {PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_NX,
280 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TRIDENT_4D_NX},
281 {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7018,
282 PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_7018},
283 {PCI_VENDOR_ID_ALI, PCI_DEVICE_ID_ALI_5451,
284 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ALI_5451},
285 {PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_5050,
286 PCI_ANY_ID, PCI_ANY_ID, 0, 0, CYBER5050},
290 MODULE_DEVICE_TABLE(pci, trident_pci_tbl);
292 /* "software" or virtual channel, an instance of opened /dev/dsp */
293 struct trident_state {
295 struct trident_card *card; /* Card info */
300 /* virtual channel number */
304 /* wave sample stuff */
306 unsigned char fmt, enable;
308 /* hardware channel */
309 struct trident_channel *channel;
311 /* OSS buffer management stuff */
313 dma_addr_t dma_handle;
318 /* our buffer acts like a circular ring */
319 unsigned hwptr; /* where dma last started, updated by update_ptr */
320 unsigned swptr; /* where driver last clear/filled, updated by read/write */
321 int count; /* bytes to be comsumed or been generated by dma machine */
322 unsigned total_bytes; /* total bytes dmaed by hardware */
324 unsigned error; /* number of over/underruns */
325 /* put process on wait queue when no more space in buffer */
326 wait_queue_head_t wait;
328 /* redundant, but makes calculations easier */
331 unsigned fragsamples;
336 unsigned endcleared:1;
337 unsigned update_flag;
338 unsigned ossfragshift;
340 unsigned subdivision;
345 struct trident_state *other_states[4];
346 int multi_channels_adjust_count;
348 unsigned long fmt_flag;
349 /* Guard against mmap/write/read races */
350 struct semaphore sem;
354 /* hardware channels */
355 struct trident_channel {
356 int num; /* channel number */
357 u32 lba; /* Loop Begine Address, where dma buffer starts */
358 u32 eso; /* End Sample Offset, wehre dma buffer ends */
359 /* (in the unit of samples) */
360 u32 delta; /* delta value, sample rate / 48k for playback, */
361 /* 48k/sample rate for recording */
362 u16 attribute; /* control where PCM data go and come */
364 u32 control; /* signed/unsigned, 8/16 bits, mono/stereo */
367 struct trident_pcm_bank_address {
374 static struct trident_pcm_bank_address bank_a_addrs = {
381 static struct trident_pcm_bank_address bank_b_addrs = {
388 struct trident_pcm_bank {
389 /* register addresses to control bank operations */
390 struct trident_pcm_bank_address *addresses;
391 /* each bank has 32 channels */
392 u32 bitmap; /* channel allocation bitmap */
393 struct trident_channel channels[32];
396 struct trident_card {
399 /* We keep trident cards in a linked list */
400 struct trident_card *next;
402 /* single open lock mechanism, only used for recording */
403 struct semaphore open_sem;
405 /* The trident has a certain amount of cross channel interaction
406 so we use a single per card lock */
409 /* PCI device stuff */
410 struct pci_dev *pci_dev;
414 /* soundcore stuff */
417 /* structures for abstraction of hardware facilities, codecs, */
418 /* banks and channels */
419 struct ac97_codec *ac97_codec[NR_AC97];
420 struct trident_pcm_bank banks[NR_BANKS];
421 struct trident_state *states[NR_HW_CH];
423 /* hardware resources */
424 unsigned long iobase;
427 /* Function support */
428 struct trident_channel *(*alloc_pcm_channel) (struct trident_card *);
429 struct trident_channel *(*alloc_rec_pcm_channel) (struct trident_card *);
430 void (*free_pcm_channel) (struct trident_card *, unsigned int chan);
431 void (*address_interrupt) (struct trident_card *);
433 /* Added by Matt Wu 01-05-2001 for spdif in */
434 int multi_channel_use_count;
435 int rec_channel_use_count;
436 u16 mixer_regs[64][NR_AC97]; /* Made card local by Alan */
437 int mixer_regs_ready;
439 /* Added for hardware volume control */
441 struct timer_list timer;
443 /* Game port support */
444 struct gameport gameport;
452 /* table to map from CHANNELMASK to channel attribute for SiS 7018 */
453 static u16 mask2attr[] = {
454 PCM_LR, PCM_LR, SURR_LR, CENTER_LFE,
455 HSET, MIC, MODEM_LINE1, MODEM_LINE2,
459 /* table to map from channel attribute to CHANNELMASK for SiS 7018 */
460 static int attr2mask[] = {
461 DSP_BIND_MODEM1, DSP_BIND_MODEM2, DSP_BIND_FRONT, DSP_BIND_HANDSET,
462 DSP_BIND_I2S, DSP_BIND_CENTER_LFE, DSP_BIND_SURR, DSP_BIND_SPDIF
465 /* Added by Matt Wu 01-05-2001 for spdif in */
466 static int ali_close_multi_channels(void);
467 static void ali_delay(struct trident_card *card, int interval);
468 static void ali_detect_spdif_rate(struct trident_card *card);
470 static void ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val);
471 static u16 ali_ac97_read(struct ac97_codec *codec, u8 reg);
473 static struct trident_card *devs;
475 static void trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val);
476 static u16 trident_ac97_get(struct ac97_codec *codec, u8 reg);
478 static int trident_open_mixdev(struct inode *inode, struct file *file);
479 static int trident_ioctl_mixdev(struct inode *inode, struct file *file,
480 unsigned int cmd, unsigned long arg);
482 static void ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val);
483 static u16 ali_ac97_get(struct trident_card *card, int secondary, u8 reg);
484 static void ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate);
485 static void ali_enable_special_channel(struct trident_state *stat);
486 static struct trident_channel *ali_alloc_rec_pcm_channel(struct trident_card *card);
487 static struct trident_channel *ali_alloc_pcm_channel(struct trident_card *card);
488 static void ali_restore_regs(struct trident_card *card);
489 static void ali_save_regs(struct trident_card *card);
490 static int trident_suspend(struct pci_dev *dev, u32 unused);
491 static int trident_resume(struct pci_dev *dev);
492 static void ali_free_pcm_channel(struct trident_card *card, unsigned int channel);
493 static int ali_setup_multi_channels(struct trident_card *card, int chan_nums);
494 static unsigned int ali_get_spdif_in_rate(struct trident_card *card);
495 static void ali_setup_spdif_in(struct trident_card *card);
496 static void ali_disable_spdif_in(struct trident_card *card);
497 static void ali_disable_special_channel(struct trident_card *card, int ch);
498 static void ali_setup_spdif_out(struct trident_card *card, int flag);
499 static int ali_write_5_1(struct trident_state *state,
500 const char __user *buffer,
501 int cnt_for_multi_channel, unsigned int *copy_count,
502 unsigned int *state_cnt);
503 static int ali_allocate_other_states_resources(struct trident_state *state,
505 static void ali_free_other_states_resources(struct trident_state *state);
507 /* save registers for ALi Power Management */
508 static struct ali_saved_registers {
509 unsigned long global_regs[ALI_GLOBAL_REGS];
510 unsigned long channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS];
511 unsigned mixer_regs[ALI_MIXER_REGS];
514 #define seek_offset(dma_ptr, buffer, cnt, offset, copy_count) do { \
515 (dma_ptr) += (offset); \
516 (buffer) += (offset); \
518 (copy_count) += (offset); \
521 static inline int lock_set_fmt(struct trident_state* state)
523 if (test_and_set_bit(0, &state->fmt_flag))
529 static inline void unlock_set_fmt(struct trident_state* state)
531 clear_bit(0, &state->fmt_flag);
535 trident_enable_loop_interrupts(struct trident_card *card)
539 global_control = inl(TRID_REG(card, T4D_LFO_GC_CIR));
541 switch (card->pci_id) {
542 case PCI_DEVICE_ID_SI_7018:
543 global_control |= (ENDLP_IE | MIDLP_IE | BANK_B_EN);
545 case PCI_DEVICE_ID_ALI_5451:
546 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
547 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
548 case PCI_DEVICE_ID_INTERG_5050:
549 global_control |= (ENDLP_IE | MIDLP_IE);
555 outl(global_control, TRID_REG(card, T4D_LFO_GC_CIR));
557 pr_debug("trident: Enable Loop Interrupts, globctl = 0x%08X\n",
558 inl(TRID_REG(card, T4D_LFO_GC_CIR)));
564 trident_disable_loop_interrupts(struct trident_card *card)
568 global_control = inl(TRID_REG(card, T4D_LFO_GC_CIR));
569 global_control &= ~(ENDLP_IE | MIDLP_IE);
570 outl(global_control, TRID_REG(card, T4D_LFO_GC_CIR));
572 pr_debug("trident: Disabled Loop Interrupts, globctl = 0x%08X\n",
579 trident_enable_voice_irq(struct trident_card *card, unsigned int channel)
581 unsigned int mask = 1 << (channel & 0x1f);
582 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
583 u32 reg, addr = bank->addresses->aint_en;
585 reg = inl(TRID_REG(card, addr));
587 outl(reg, TRID_REG(card, addr));
590 reg = inl(TRID_REG(card, addr));
591 pr_debug("trident: enabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
592 channel, addr == T4D_AINTEN_B ? "AINTEN_B" : "AINTEN_A",
598 trident_disable_voice_irq(struct trident_card *card, unsigned int channel)
600 unsigned int mask = 1 << (channel & 0x1f);
601 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
602 u32 reg, addr = bank->addresses->aint_en;
604 reg = inl(TRID_REG(card, addr));
606 outl(reg, TRID_REG(card, addr));
608 /* Ack the channel in case the interrupt was set before we disable it. */
609 outl(mask, TRID_REG(card, bank->addresses->aint));
612 reg = inl(TRID_REG(card, addr));
613 pr_debug("trident: disabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
614 channel, addr == T4D_AINTEN_B ? "AINTEN_B" : "AINTEN_A",
620 trident_start_voice(struct trident_card *card, unsigned int channel)
622 unsigned int mask = 1 << (channel & 0x1f);
623 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
624 u32 addr = bank->addresses->start;
630 outl(mask, TRID_REG(card, addr));
633 reg = inl(TRID_REG(card, addr));
634 pr_debug("trident: start voice on channel %d, %s = 0x%08x(addr:%X)\n",
635 channel, addr == T4D_START_B ? "START_B" : "START_A",
641 trident_stop_voice(struct trident_card *card, unsigned int channel)
643 unsigned int mask = 1 << (channel & 0x1f);
644 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
645 u32 addr = bank->addresses->stop;
651 outl(mask, TRID_REG(card, addr));
654 reg = inl(TRID_REG(card, addr));
655 pr_debug("trident: stop voice on channel %d, %s = 0x%08x(addr:%X)\n",
656 channel, addr == T4D_STOP_B ? "STOP_B" : "STOP_A",
662 trident_get_interrupt_mask(struct trident_card *card, unsigned int channel)
664 struct trident_pcm_bank *bank = &card->banks[channel];
665 u32 addr = bank->addresses->aint;
666 return inl(TRID_REG(card, addr));
670 trident_check_channel_interrupt(struct trident_card *card, unsigned int channel)
672 unsigned int mask = 1 << (channel & 0x1f);
673 u32 reg = trident_get_interrupt_mask(card, channel >> 5);
677 pr_debug("trident: channel %d has interrupt, %s = 0x%08x\n",
678 channel, reg == T4D_AINT_B ? "AINT_B" : "AINT_A",
681 return (reg & mask) ? 1 : 0;
685 trident_ack_channel_interrupt(struct trident_card *card, unsigned int channel)
687 unsigned int mask = 1 << (channel & 0x1f);
688 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
689 u32 reg, addr = bank->addresses->aint;
691 reg = inl(TRID_REG(card, addr));
693 outl(reg, TRID_REG(card, addr));
696 reg = inl(TRID_REG(card, T4D_AINT_B));
697 pr_debug("trident: Ack channel %d interrupt, AINT_B = 0x%08x\n",
702 static struct trident_channel *
703 trident_alloc_pcm_channel(struct trident_card *card)
705 struct trident_pcm_bank *bank;
708 bank = &card->banks[BANK_B];
710 for (idx = 31; idx >= 0; idx--) {
711 if (!(bank->bitmap & (1 << idx))) {
712 struct trident_channel *channel = &bank->channels[idx];
713 bank->bitmap |= 1 << idx;
714 channel->num = idx + 32;
719 /* no more free channels available */
720 printk(KERN_ERR "trident: no more channels available on Bank B.\n");
725 trident_free_pcm_channel(struct trident_card *card, unsigned int channel)
730 if (channel < 31 || channel > 63)
733 if (card->pci_id == PCI_DEVICE_ID_TRIDENT_4DWAVE_DX ||
734 card->pci_id == PCI_DEVICE_ID_TRIDENT_4DWAVE_NX) {
735 b = inb(TRID_REG(card, T4D_REC_CH));
736 if ((b & ~0x80) == channel)
737 outb(0x0, TRID_REG(card, T4D_REC_CH));
741 channel = channel & 0x1f;
743 card->banks[bank].bitmap &= ~(1 << (channel));
746 static struct trident_channel *
747 cyber_alloc_pcm_channel(struct trident_card *card)
749 struct trident_pcm_bank *bank;
752 /* The cyberpro 5050 has only 32 voices and one bank */
753 /* .. at least they are not documented (if you want to call that
754 * crap documentation), perhaps broken ? */
756 bank = &card->banks[BANK_A];
758 for (idx = 31; idx >= 0; idx--) {
759 if (!(bank->bitmap & (1 << idx))) {
760 struct trident_channel *channel = &bank->channels[idx];
761 bank->bitmap |= 1 << idx;
767 /* no more free channels available */
768 printk(KERN_ERR "cyberpro5050: no more channels available on Bank A.\n");
773 cyber_free_pcm_channel(struct trident_card *card, unsigned int channel)
777 card->banks[BANK_A].bitmap &= ~(1 << (channel));
781 cyber_outidx(int port, int idx, int data)
784 outb(data, port + 1);
788 cyber_inidx(int port, int idx)
791 return inb(port + 1);
795 cyber_init_ritual(struct trident_card *card)
797 /* some black magic, taken from SDK samples */
798 /* remove this and nothing will work */
804 * Keep interrupts off for the configure - we don't want to
805 * clash with another cyberpro config event
808 spin_lock_irqsave(&card->lock, flags);
809 portDat = cyber_inidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE);
810 /* enable, if it was disabled */
811 if ((portDat & CYBER_BMSK_AUENZ) != CYBER_BMSK_AUENZ_ENABLE) {
812 printk(KERN_INFO "cyberpro5050: enabling audio controller\n");
813 cyber_outidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE,
814 portDat | CYBER_BMSK_AUENZ_ENABLE);
815 /* check again if hardware is enabled now */
816 portDat = cyber_inidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE);
818 if ((portDat & CYBER_BMSK_AUENZ) != CYBER_BMSK_AUENZ_ENABLE) {
819 printk(KERN_ERR "cyberpro5050: initAudioAccess: no success\n");
822 cyber_outidx(CYBER_PORT_AUDIO, CYBER_IDX_IRQ_ENABLE,
823 CYBER_BMSK_AUDIO_INT_ENABLE);
824 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x01);
825 cyber_outidx(CYBER_PORT_AUDIO, 0xba, 0x20);
826 cyber_outidx(CYBER_PORT_AUDIO, 0xbb, 0x08);
827 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x02);
828 cyber_outidx(CYBER_PORT_AUDIO, 0xb3, 0x06);
829 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x00);
831 spin_unlock_irqrestore(&card->lock, flags);
835 /* called with spin lock held */
838 trident_load_channel_registers(struct trident_card *card, u32 * data,
839 unsigned int channel)
846 /* select hardware channel to write */
847 outb(channel, TRID_REG(card, T4D_LFO_GC_CIR));
849 /* Output the channel registers, but don't write register
850 three to an ALI chip. */
851 for (i = 0; i < CHANNEL_REGS; i++) {
852 if (i == 3 && card->pci_id == PCI_DEVICE_ID_ALI_5451)
854 outl(data[i], TRID_REG(card, CHANNEL_START + 4 * i));
856 if (card->pci_id == PCI_DEVICE_ID_ALI_5451 ||
857 card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
858 outl(ALI_EMOD_Still, TRID_REG(card, ALI_EBUF1));
859 outl(ALI_EMOD_Still, TRID_REG(card, ALI_EBUF2));
864 /* called with spin lock held */
866 trident_write_voice_regs(struct trident_state *state)
868 unsigned int data[CHANNEL_REGS + 1];
869 struct trident_channel *channel;
871 channel = state->dmabuf.channel;
873 data[1] = channel->lba;
874 data[4] = channel->control;
876 switch (state->card->pci_id) {
877 case PCI_DEVICE_ID_ALI_5451:
878 data[0] = 0; /* Current Sample Offset */
879 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
882 case PCI_DEVICE_ID_SI_7018:
883 case PCI_DEVICE_ID_INTERG_5050:
884 data[0] = 0; /* Current Sample Offset */
885 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
886 data[3] = (channel->attribute << 16) | (channel->fm_vol & 0xffff);
888 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
889 data[0] = 0; /* Current Sample Offset */
890 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
891 data[3] = channel->fm_vol & 0xffff;
893 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
894 data[0] = (channel->delta << 24);
895 data[2] = ((channel->delta << 16) & 0xff000000) |
896 (channel->eso & 0x00ffffff);
897 data[3] = channel->fm_vol & 0xffff;
903 return trident_load_channel_registers(state->card, data, channel->num);
907 compute_rate_play(u32 rate)
910 /* We special case 44100 and 8000 since rounding with the equation
911 does not give us an accurate enough value. For 11025 and 22050
912 the equation gives us the best answer. All other frequencies will
913 also use the equation. JDW */
916 else if (rate == 8000)
918 else if (rate == 48000)
921 delta = (((rate << 12) + rate) / 48000) & 0x0000ffff;
926 compute_rate_rec(u32 rate)
932 else if (rate == 8000)
934 else if (rate == 48000)
937 delta = ((48000 << 12) / rate) & 0x0000ffff;
942 /* set playback sample rate */
944 trident_set_dac_rate(struct trident_state *state, unsigned int rate)
946 struct dmabuf *dmabuf = &state->dmabuf;
954 dmabuf->channel->delta = compute_rate_play(rate);
956 trident_write_voice_regs(state);
958 pr_debug("trident: called trident_set_dac_rate : rate = %d\n", rate);
963 /* set recording sample rate */
965 trident_set_adc_rate(struct trident_state *state, unsigned int rate)
967 struct dmabuf *dmabuf = &state->dmabuf;
975 dmabuf->channel->delta = compute_rate_rec(rate);
977 trident_write_voice_regs(state);
979 pr_debug("trident: called trident_set_adc_rate : rate = %d\n", rate);
984 /* prepare channel attributes for playback */
986 trident_play_setup(struct trident_state *state)
988 struct dmabuf *dmabuf = &state->dmabuf;
989 struct trident_channel *channel = dmabuf->channel;
991 channel->lba = dmabuf->dma_handle;
992 channel->delta = compute_rate_play(dmabuf->rate);
994 channel->eso = dmabuf->dmasize >> sample_shift[dmabuf->fmt];
997 if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
998 channel->attribute = 0;
999 if (state->card->pci_id == PCI_DEVICE_ID_ALI_5451) {
1000 if ((channel->num == ALI_SPDIF_IN_CHANNEL) ||
1001 (channel->num == ALI_PCM_IN_CHANNEL))
1002 ali_disable_special_channel(state->card, channel->num);
1003 else if ((inl(TRID_REG(state->card, ALI_GLOBAL_CONTROL))
1004 & ALI_SPDIF_OUT_CH_ENABLE)
1005 && (channel->num == ALI_SPDIF_OUT_CHANNEL)) {
1006 ali_set_spdif_out_rate(state->card,
1007 state->dmabuf.rate);
1008 state->dmabuf.channel->delta = 0x1000;
1013 channel->fm_vol = 0x0;
1015 channel->control = CHANNEL_LOOP;
1016 if (dmabuf->fmt & TRIDENT_FMT_16BIT) {
1018 channel->control |= CHANNEL_16BITS;
1020 channel->control |= CHANNEL_SIGNED;
1022 if (dmabuf->fmt & TRIDENT_FMT_STEREO)
1024 channel->control |= CHANNEL_STEREO;
1026 pr_debug("trident: trident_play_setup, LBA = 0x%08x, Delta = 0x%08x, "
1027 "ESO = 0x%08x, Control = 0x%08x\n", channel->lba,
1028 channel->delta, channel->eso, channel->control);
1030 trident_write_voice_regs(state);
1033 /* prepare channel attributes for recording */
1035 trident_rec_setup(struct trident_state *state)
1040 struct trident_card *card = state->card;
1041 struct dmabuf *dmabuf = &state->dmabuf;
1042 struct trident_channel *channel = dmabuf->channel;
1045 /* Enable AC-97 ADC (capture) */
1046 switch (card->pci_id) {
1047 case PCI_DEVICE_ID_ALI_5451:
1048 ali_enable_special_channel(state);
1050 case PCI_DEVICE_ID_SI_7018:
1051 /* for 7018, the ac97 is always in playback/record (duplex) mode */
1053 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
1054 w = inb(TRID_REG(card, DX_ACR2_AC97_COM_STAT));
1055 outb(w | 0x48, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
1056 /* enable and set record channel */
1057 outb(0x80 | channel->num, TRID_REG(card, T4D_REC_CH));
1059 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
1060 w = inw(TRID_REG(card, T4D_MISCINT));
1061 outw(w | 0x1000, TRID_REG(card, T4D_MISCINT));
1062 /* enable and set record channel */
1063 outb(0x80 | channel->num, TRID_REG(card, T4D_REC_CH));
1065 case PCI_DEVICE_ID_INTERG_5050:
1066 /* don't know yet, using special channel 22 in GC1(0xd4)? */
1072 channel->lba = dmabuf->dma_handle;
1073 channel->delta = compute_rate_rec(dmabuf->rate);
1074 if ((card->pci_id == PCI_DEVICE_ID_ALI_5451) &&
1075 (channel->num == ALI_SPDIF_IN_CHANNEL)) {
1076 rate = ali_get_spdif_in_rate(card);
1078 printk(KERN_WARNING "trident: ALi 5451 "
1079 "S/PDIF input setup error!\n");
1082 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
1084 outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
1085 printk(KERN_WARNING "trident: cleared ALi "
1086 "5451 S/PDIF parity error flag.\n");
1090 channel->delta = ((rate << 12) / dmabuf->rate) & 0x0000ffff;
1093 channel->eso = dmabuf->dmasize >> sample_shift[dmabuf->fmt];
1096 if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
1097 channel->attribute = 0;
1100 channel->fm_vol = 0x0;
1102 channel->control = CHANNEL_LOOP;
1103 if (dmabuf->fmt & TRIDENT_FMT_16BIT) {
1105 channel->control |= CHANNEL_16BITS;
1107 channel->control |= CHANNEL_SIGNED;
1109 if (dmabuf->fmt & TRIDENT_FMT_STEREO)
1111 channel->control |= CHANNEL_STEREO;
1113 pr_debug("trident: trident_rec_setup, LBA = 0x%08x, Delat = 0x%08x, "
1114 "ESO = 0x%08x, Control = 0x%08x\n", channel->lba,
1115 channel->delta, channel->eso, channel->control);
1117 trident_write_voice_regs(state);
1120 /* get current playback/recording dma buffer pointer (byte offset from LBA),
1121 called with spinlock held! */
1122 static inline unsigned
1123 trident_get_dma_addr(struct trident_state *state)
1125 struct dmabuf *dmabuf = &state->dmabuf;
1128 if (!dmabuf->enable)
1131 outb(dmabuf->channel->num, TRID_REG(state->card, T4D_LFO_GC_CIR));
1133 switch (state->card->pci_id) {
1134 case PCI_DEVICE_ID_ALI_5451:
1135 case PCI_DEVICE_ID_SI_7018:
1136 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
1137 case PCI_DEVICE_ID_INTERG_5050:
1138 /* 16 bits ESO, CSO for 7018 and DX */
1139 cso = inw(TRID_REG(state->card, CH_DX_CSO_ALPHA_FMS + 2));
1141 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
1142 /* 24 bits ESO, CSO for NX */
1143 cso = inl(TRID_REG(state->card, CH_NX_DELTA_CSO)) & 0x00ffffff;
1149 pr_debug("trident: trident_get_dma_addr: chip reported channel: %d, "
1150 "cso = 0x%04x\n", dmabuf->channel->num, cso);
1152 /* ESO and CSO are in units of Samples, convert to byte offset */
1153 cso <<= sample_shift[dmabuf->fmt];
1155 return (cso % dmabuf->dmasize);
1158 /* Stop recording (lock held) */
1160 __stop_adc(struct trident_state *state)
1162 struct dmabuf *dmabuf = &state->dmabuf;
1163 unsigned int chan_num = dmabuf->channel->num;
1164 struct trident_card *card = state->card;
1166 dmabuf->enable &= ~ADC_RUNNING;
1167 trident_stop_voice(card, chan_num);
1168 trident_disable_voice_irq(card, chan_num);
1172 stop_adc(struct trident_state *state)
1174 struct trident_card *card = state->card;
1175 unsigned long flags;
1177 spin_lock_irqsave(&card->lock, flags);
1179 spin_unlock_irqrestore(&card->lock, flags);
1183 start_adc(struct trident_state *state)
1185 struct dmabuf *dmabuf = &state->dmabuf;
1186 unsigned int chan_num = dmabuf->channel->num;
1187 struct trident_card *card = state->card;
1188 unsigned long flags;
1190 spin_lock_irqsave(&card->lock, flags);
1191 if ((dmabuf->mapped ||
1192 dmabuf->count < (signed) dmabuf->dmasize) &&
1194 dmabuf->enable |= ADC_RUNNING;
1195 trident_enable_voice_irq(card, chan_num);
1196 trident_start_voice(card, chan_num);
1198 spin_unlock_irqrestore(&card->lock, flags);
1201 /* stop playback (lock held) */
1203 __stop_dac(struct trident_state *state)
1205 struct dmabuf *dmabuf = &state->dmabuf;
1206 unsigned int chan_num = dmabuf->channel->num;
1207 struct trident_card *card = state->card;
1209 dmabuf->enable &= ~DAC_RUNNING;
1210 trident_stop_voice(card, chan_num);
1211 if (state->chans_num == 6) {
1212 trident_stop_voice(card, state->other_states[0]->
1213 dmabuf.channel->num);
1214 trident_stop_voice(card, state->other_states[1]->
1215 dmabuf.channel->num);
1216 trident_stop_voice(card, state->other_states[2]->
1217 dmabuf.channel->num);
1218 trident_stop_voice(card, state->other_states[3]->
1219 dmabuf.channel->num);
1221 trident_disable_voice_irq(card, chan_num);
1225 stop_dac(struct trident_state *state)
1227 struct trident_card *card = state->card;
1228 unsigned long flags;
1230 spin_lock_irqsave(&card->lock, flags);
1232 spin_unlock_irqrestore(&card->lock, flags);
1236 start_dac(struct trident_state *state)
1238 struct dmabuf *dmabuf = &state->dmabuf;
1239 unsigned int chan_num = dmabuf->channel->num;
1240 struct trident_card *card = state->card;
1241 unsigned long flags;
1243 spin_lock_irqsave(&card->lock, flags);
1244 if ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) {
1245 dmabuf->enable |= DAC_RUNNING;
1246 trident_enable_voice_irq(card, chan_num);
1247 trident_start_voice(card, chan_num);
1248 if (state->chans_num == 6) {
1249 trident_start_voice(card, state->other_states[0]->
1250 dmabuf.channel->num);
1251 trident_start_voice(card, state->other_states[1]->
1252 dmabuf.channel->num);
1253 trident_start_voice(card, state->other_states[2]->
1254 dmabuf.channel->num);
1255 trident_start_voice(card, state->other_states[3]->
1256 dmabuf.channel->num);
1259 spin_unlock_irqrestore(&card->lock, flags);
1262 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
1263 #define DMABUF_MINORDER 1
1265 /* alloc a DMA buffer of with a buffer of this order */
1267 alloc_dmabuf(struct dmabuf *dmabuf, struct pci_dev *pci_dev, int order)
1269 void *rawbuf = NULL;
1270 struct page *page, *pend;
1272 if (!(rawbuf = pci_alloc_consistent(pci_dev, PAGE_SIZE << order,
1273 &dmabuf->dma_handle)))
1276 pr_debug("trident: allocated %ld (order = %d) bytes at %p\n",
1277 PAGE_SIZE << order, order, rawbuf);
1279 dmabuf->ready = dmabuf->mapped = 0;
1280 dmabuf->rawbuf = rawbuf;
1281 dmabuf->buforder = order;
1283 /* now mark the pages as reserved; otherwise */
1284 /* remap_page_range doesn't do what we want */
1285 pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
1286 for (page = virt_to_page(rawbuf); page <= pend; page++)
1287 SetPageReserved(page);
1292 /* allocate the main DMA buffer, playback and recording buffer should be */
1293 /* allocated separately */
1295 alloc_main_dmabuf(struct trident_state *state)
1297 struct dmabuf *dmabuf = &state->dmabuf;
1301 /* alloc as big a chunk as we can, FIXME: is this necessary ?? */
1302 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
1303 if (!(ret = alloc_dmabuf(dmabuf, state->card->pci_dev, order)))
1305 /* else try again */
1310 /* deallocate a DMA buffer */
1312 dealloc_dmabuf(struct dmabuf *dmabuf, struct pci_dev *pci_dev)
1314 struct page *page, *pend;
1316 if (dmabuf->rawbuf) {
1317 /* undo marking the pages as reserved */
1318 pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
1319 for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
1320 ClearPageReserved(page);
1321 pci_free_consistent(pci_dev, PAGE_SIZE << dmabuf->buforder,
1322 dmabuf->rawbuf, dmabuf->dma_handle);
1323 dmabuf->rawbuf = NULL;
1325 dmabuf->mapped = dmabuf->ready = 0;
1329 prog_dmabuf(struct trident_state *state, enum dmabuf_mode rec)
1331 struct dmabuf *dmabuf = &state->dmabuf;
1332 unsigned bytepersec;
1333 struct trident_state *s = state;
1334 unsigned bufsize, dma_nums;
1335 unsigned long flags;
1338 if ((ret = lock_set_fmt(state)) < 0)
1341 if (state->chans_num == 6)
1346 for (i = 0; i < dma_nums; i++) {
1348 s = state->other_states[i - 1];
1349 dmabuf = &s->dmabuf;
1350 dmabuf->fmt = state->dmabuf.fmt;
1351 dmabuf->rate = state->dmabuf.rate;
1354 spin_lock_irqsave(&s->card->lock, flags);
1355 dmabuf->hwptr = dmabuf->swptr = dmabuf->total_bytes = 0;
1356 dmabuf->count = dmabuf->error = 0;
1357 spin_unlock_irqrestore(&s->card->lock, flags);
1359 /* allocate DMA buffer if not allocated yet */
1360 if (!dmabuf->rawbuf) {
1362 if ((ret = alloc_main_dmabuf(state))) {
1363 unlock_set_fmt(state);
1368 order = state->dmabuf.buforder - 1;
1369 if (order >= DMABUF_MINORDER) {
1370 ret = alloc_dmabuf(dmabuf,
1371 state->card->pci_dev,
1375 /* release the main DMA buffer */
1376 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
1377 /* release the auxiliary DMA buffers */
1378 for (i -= 2; i >= 0; i--)
1379 dealloc_dmabuf(&state->other_states[i]->dmabuf,
1380 state->card->pci_dev);
1381 unlock_set_fmt(state);
1386 /* FIXME: figure out all this OSS fragment stuff */
1387 bytepersec = dmabuf->rate << sample_shift[dmabuf->fmt];
1388 bufsize = PAGE_SIZE << dmabuf->buforder;
1389 if (dmabuf->ossfragshift) {
1390 if ((1000 << dmabuf->ossfragshift) < bytepersec)
1391 dmabuf->fragshift = ld2(bytepersec / 1000);
1393 dmabuf->fragshift = dmabuf->ossfragshift;
1395 /* lets hand out reasonable big ass buffers by default */
1396 dmabuf->fragshift = (dmabuf->buforder + PAGE_SHIFT - 2);
1398 dmabuf->numfrag = bufsize >> dmabuf->fragshift;
1399 while (dmabuf->numfrag < 4 && dmabuf->fragshift > 3) {
1400 dmabuf->fragshift--;
1401 dmabuf->numfrag = bufsize >> dmabuf->fragshift;
1403 dmabuf->fragsize = 1 << dmabuf->fragshift;
1404 if (dmabuf->ossmaxfrags >= 4 && dmabuf->ossmaxfrags < dmabuf->numfrag)
1405 dmabuf->numfrag = dmabuf->ossmaxfrags;
1406 dmabuf->fragsamples = dmabuf->fragsize >> sample_shift[dmabuf->fmt];
1407 dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
1409 memset(dmabuf->rawbuf, (dmabuf->fmt & TRIDENT_FMT_16BIT) ? 0 : 0x80,
1412 spin_lock_irqsave(&s->card->lock, flags);
1413 if (rec == DM_RECORD)
1414 trident_rec_setup(s);
1415 else /* DM_PLAYBACK */
1416 trident_play_setup(s);
1418 spin_unlock_irqrestore(&s->card->lock, flags);
1420 /* set the ready flag for the dma buffer */
1423 pr_debug("trident: prog_dmabuf(%d), sample rate = %d, "
1424 "format = %d, numfrag = %d, fragsize = %d "
1425 "dmasize = %d\n", dmabuf->channel->num,
1426 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1427 dmabuf->fragsize, dmabuf->dmasize);
1429 unlock_set_fmt(state);
1434 static inline int prog_dmabuf_record(struct trident_state* state)
1436 return prog_dmabuf(state, DM_RECORD);
1439 static inline int prog_dmabuf_playback(struct trident_state* state)
1441 return prog_dmabuf(state, DM_PLAYBACK);
1444 /* we are doing quantum mechanics here, the buffer can only be empty, half or full filled i.e.
1445 |------------|------------| or |xxxxxxxxxxxx|------------| or |xxxxxxxxxxxx|xxxxxxxxxxxx|
1446 but we almost always get this
1447 |xxxxxx------|------------| or |xxxxxxxxxxxx|xxxxx-------|
1448 so we have to clear the tail space to "silence"
1449 |xxxxxx000000|------------| or |xxxxxxxxxxxx|xxxxxx000000|
1452 trident_clear_tail(struct trident_state *state)
1454 struct dmabuf *dmabuf = &state->dmabuf;
1456 unsigned char silence = (dmabuf->fmt & TRIDENT_FMT_16BIT) ? 0 : 0x80;
1458 unsigned long flags;
1460 spin_lock_irqsave(&state->card->lock, flags);
1461 swptr = dmabuf->swptr;
1462 spin_unlock_irqrestore(&state->card->lock, flags);
1464 if (swptr == 0 || swptr == dmabuf->dmasize / 2 ||
1465 swptr == dmabuf->dmasize)
1468 if (swptr < dmabuf->dmasize / 2)
1469 len = dmabuf->dmasize / 2 - swptr;
1471 len = dmabuf->dmasize - swptr;
1473 memset(dmabuf->rawbuf + swptr, silence, len);
1474 if (state->card->pci_id != PCI_DEVICE_ID_ALI_5451) {
1475 spin_lock_irqsave(&state->card->lock, flags);
1476 dmabuf->swptr += len;
1477 dmabuf->count += len;
1478 spin_unlock_irqrestore(&state->card->lock, flags);
1481 /* restart the dma machine in case it is halted */
1486 drain_dac(struct trident_state *state, int nonblock)
1488 DECLARE_WAITQUEUE(wait, current);
1489 struct dmabuf *dmabuf = &state->dmabuf;
1490 unsigned long flags;
1493 unsigned long diff = 0;
1495 if (dmabuf->mapped || !dmabuf->ready)
1498 add_wait_queue(&dmabuf->wait, &wait);
1500 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1501 every time to make the process really go to sleep */
1502 set_current_state(TASK_INTERRUPTIBLE);
1504 spin_lock_irqsave(&state->card->lock, flags);
1505 count = dmabuf->count;
1506 spin_unlock_irqrestore(&state->card->lock, flags);
1511 if (signal_pending(current))
1515 remove_wait_queue(&dmabuf->wait, &wait);
1516 set_current_state(TASK_RUNNING);
1520 /* No matter how much data is left in the buffer, we have to wait until
1521 CSO == ESO/2 or CSO == ESO when address engine interrupts */
1522 if (state->card->pci_id == PCI_DEVICE_ID_ALI_5451 ||
1523 state->card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
1524 diff = dmabuf->swptr - trident_get_dma_addr(state) + dmabuf->dmasize;
1525 diff = diff % (dmabuf->dmasize);
1526 tmo = (diff * HZ) / dmabuf->rate;
1528 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1530 tmo >>= sample_shift[dmabuf->fmt];
1531 if (!schedule_timeout(tmo ? tmo : 1) && tmo) {
1535 remove_wait_queue(&dmabuf->wait, &wait);
1536 set_current_state(TASK_RUNNING);
1537 if (signal_pending(current))
1538 return -ERESTARTSYS;
1543 /* update buffer manangement pointers, especially, */
1544 /* dmabuf->count and dmabuf->hwptr */
1546 trident_update_ptr(struct trident_state *state)
1548 struct dmabuf *dmabuf = &state->dmabuf;
1549 unsigned hwptr, swptr;
1552 unsigned char silence;
1553 unsigned half_dmasize;
1555 /* update hardware pointer */
1556 hwptr = trident_get_dma_addr(state);
1557 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1558 dmabuf->hwptr = hwptr;
1559 dmabuf->total_bytes += diff;
1561 /* error handling and process wake up for ADC */
1562 if (dmabuf->enable == ADC_RUNNING) {
1563 if (dmabuf->mapped) {
1564 dmabuf->count -= diff;
1565 if (dmabuf->count >= (signed) dmabuf->fragsize)
1566 wake_up(&dmabuf->wait);
1568 dmabuf->count += diff;
1570 if (dmabuf->count < 0 ||
1571 dmabuf->count > dmabuf->dmasize) {
1572 /* buffer underrun or buffer overrun, */
1573 /* we have no way to recover it here, just */
1574 /* stop the machine and let the process */
1575 /* force hwptr and swptr to sync */
1579 if (dmabuf->count < (signed) dmabuf->dmasize / 2)
1580 wake_up(&dmabuf->wait);
1584 /* error handling and process wake up for DAC */
1585 if (dmabuf->enable == DAC_RUNNING) {
1586 if (dmabuf->mapped) {
1587 dmabuf->count += diff;
1588 if (dmabuf->count >= (signed) dmabuf->fragsize)
1589 wake_up(&dmabuf->wait);
1591 dmabuf->count -= diff;
1593 if (dmabuf->count < 0 ||
1594 dmabuf->count > dmabuf->dmasize) {
1595 /* buffer underrun or buffer overrun, we have no way to recover
1596 it here, just stop the machine and let the process force hwptr
1597 and swptr to sync */
1600 } else if (!dmabuf->endcleared) {
1601 swptr = dmabuf->swptr;
1602 silence = (dmabuf->fmt & TRIDENT_FMT_16BIT ? 0 : 0x80);
1603 if (dmabuf->update_flag & ALI_ADDRESS_INT_UPDATE) {
1604 /* We must clear end data of 1/2 dmabuf if needed.
1605 According to 1/2 algorithm of Address Engine Interrupt,
1606 check the validation of the data of half dmasize. */
1607 half_dmasize = dmabuf->dmasize / 2;
1608 if ((diff = hwptr - half_dmasize) < 0)
1610 if ((dmabuf->count + diff) < half_dmasize) {
1611 //there is invalid data in the end of half buffer
1612 if ((clear_cnt = half_dmasize - swptr) < 0)
1613 clear_cnt += half_dmasize;
1614 //clear the invalid data
1615 memset(dmabuf->rawbuf + swptr, silence, clear_cnt);
1616 if (state->chans_num == 6) {
1617 clear_cnt = clear_cnt / 2;
1619 memset(state->other_states[0]->dmabuf.rawbuf + swptr,
1620 silence, clear_cnt);
1621 memset(state->other_states[1]->dmabuf.rawbuf + swptr,
1622 silence, clear_cnt);
1623 memset(state->other_states[2]->dmabuf.rawbuf + swptr,
1624 silence, clear_cnt);
1625 memset(state->other_states[3]->dmabuf.rawbuf + swptr,
1626 silence, clear_cnt);
1628 dmabuf->endcleared = 1;
1630 } else if (dmabuf->count < (signed) dmabuf->fragsize) {
1631 clear_cnt = dmabuf->fragsize;
1632 if ((swptr + clear_cnt) > dmabuf->dmasize)
1633 clear_cnt = dmabuf->dmasize - swptr;
1634 memset(dmabuf->rawbuf + swptr, silence, clear_cnt);
1635 if (state->chans_num == 6) {
1636 clear_cnt = clear_cnt / 2;
1638 memset(state->other_states[0]->dmabuf.rawbuf + swptr,
1639 silence, clear_cnt);
1640 memset(state->other_states[1]->dmabuf.rawbuf + swptr,
1641 silence, clear_cnt);
1642 memset(state->other_states[2]->dmabuf.rawbuf + swptr,
1643 silence, clear_cnt);
1644 memset(state->other_states[3]->dmabuf.rawbuf + swptr,
1645 silence, clear_cnt);
1647 dmabuf->endcleared = 1;
1650 /* trident_update_ptr is called by interrupt handler or by process via
1651 ioctl/poll, we only wake up the waiting process when we have more
1652 than 1/2 buffer free (always true for interrupt handler) */
1653 if (dmabuf->count < (signed) dmabuf->dmasize / 2)
1654 wake_up(&dmabuf->wait);
1657 dmabuf->update_flag &= ~ALI_ADDRESS_INT_UPDATE;
1661 trident_address_interrupt(struct trident_card *card)
1664 struct trident_state *state;
1665 unsigned int channel;
1667 /* Update the pointers for all channels we are running. */
1668 /* FIXME: should read interrupt status only once */
1669 for (i = 0; i < NR_HW_CH; i++) {
1671 if (trident_check_channel_interrupt(card, channel)) {
1672 trident_ack_channel_interrupt(card, channel);
1673 if ((state = card->states[i]) != NULL) {
1674 trident_update_ptr(state);
1676 printk(KERN_WARNING "trident: spurious channel "
1677 "irq %d.\n", channel);
1678 trident_stop_voice(card, channel);
1679 trident_disable_voice_irq(card, channel);
1686 ali_hwvol_control(struct trident_card *card, int opt)
1688 u16 dwTemp, volume[2], mute, diff, *pVol[2];
1690 dwTemp = ali_ac97_read(card->ac97_codec[0], 0x02);
1691 mute = dwTemp & 0x8000;
1692 volume[0] = dwTemp & 0x001f;
1693 volume[1] = (dwTemp & 0x1f00) >> 8;
1694 if (volume[0] < volume[1]) {
1695 pVol[0] = &volume[0];
1696 pVol[1] = &volume[1];
1698 pVol[1] = &volume[0];
1699 pVol[0] = &volume[1];
1701 diff = *(pVol[1]) - *(pVol[0]);
1703 if (opt == 1) { // MUTE
1705 ali_ac97_write(card->ac97_codec[0],
1707 } else if (opt == 2) { // Down
1710 if (*(pVol[1]) < 0x001f) {
1712 *(pVol[0]) = *(pVol[1]) - diff;
1715 dwTemp |= (volume[0]) | (volume[1] << 8);
1716 ali_ac97_write(card->ac97_codec[0], 0x02, dwTemp);
1717 card->ac97_codec[0]->mixer_state[0] = ((32 - volume[0]) * 25 / 8) |
1718 (((32 - volume[1]) * 25 / 8) << 8);
1719 } else if (opt == 4) { // Up
1722 if (*(pVol[0]) > 0) {
1724 *(pVol[1]) = *(pVol[0]) + diff;
1727 dwTemp |= (volume[0]) | (volume[1] << 8);
1728 ali_ac97_write(card->ac97_codec[0], 0x02, dwTemp);
1729 card->ac97_codec[0]->mixer_state[0] = ((32 - volume[0]) * 25 / 8) |
1730 (((32 - volume[1]) * 25 / 8) << 8);
1732 /* Nothing needs doing */
1737 * Re-enable reporting of vol change after 0.1 seconds
1741 ali_timeout(unsigned long ptr)
1743 struct trident_card *card = (struct trident_card *) ptr;
1746 /* Enable GPIO IRQ (MISCINT bit 18h) */
1747 temp = inw(TRID_REG(card, T4D_MISCINT + 2));
1749 outw(temp, TRID_REG(card, T4D_MISCINT + 2));
1753 * Set up the timer to clear the vol change notification
1757 ali_set_timer(struct trident_card *card)
1759 /* Add Timer Routine to Enable GPIO IRQ */
1760 del_timer(&card->timer); /* Never queue twice */
1761 card->timer.function = ali_timeout;
1762 card->timer.data = (unsigned long) card;
1763 card->timer.expires = jiffies + HZ / 10;
1764 add_timer(&card->timer);
1768 * Process a GPIO event
1772 ali_queue_task(struct trident_card *card, int opt)
1776 /* Disable GPIO IRQ (MISCINT bit 18h) */
1777 temp = inw(TRID_REG(card, T4D_MISCINT + 2));
1778 temp &= (u16) (~0x0004);
1779 outw(temp, TRID_REG(card, T4D_MISCINT + 2));
1781 /* Adjust the volume */
1782 ali_hwvol_control(card, opt);
1784 /* Set the timer for 1/10th sec */
1785 ali_set_timer(card);
1789 cyber_address_interrupt(struct trident_card *card)
1792 struct trident_state *state;
1793 unsigned int channel;
1795 /* Update the pointers for all channels we are running. */
1796 /* FIXED: read interrupt status only once */
1797 irq_status = inl(TRID_REG(card, T4D_AINT_A));
1799 pr_debug("cyber_address_interrupt: irq_status 0x%X\n", irq_status);
1801 for (i = 0; i < NR_HW_CH; i++) {
1803 if (irq_status & (1 << channel)) {
1804 /* clear bit by writing a 1, zeroes are ignored */
1805 outl((1 << channel), TRID_REG(card, T4D_AINT_A));
1807 pr_debug("cyber_interrupt: channel %d\n", channel);
1809 if ((state = card->states[i]) != NULL) {
1810 trident_update_ptr(state);
1812 printk(KERN_WARNING "cyber5050: spurious "
1813 "channel irq %d.\n", channel);
1814 trident_stop_voice(card, channel);
1815 trident_disable_voice_irq(card, channel);
1822 trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1824 struct trident_card *card = (struct trident_card *) dev_id;
1828 spin_lock(&card->lock);
1829 event = inl(TRID_REG(card, T4D_MISCINT));
1831 pr_debug("trident: trident_interrupt called, MISCINT = 0x%08x\n",
1834 if (event & ADDRESS_IRQ) {
1835 card->address_interrupt(card);
1838 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
1839 /* GPIO IRQ (H/W Volume Control) */
1840 event = inl(TRID_REG(card, T4D_MISCINT));
1841 if (event & (1 << 25)) {
1842 gpio = inl(TRID_REG(card, ALI_GPIO));
1843 if (!timer_pending(&card->timer))
1844 ali_queue_task(card, gpio & 0x07);
1846 event = inl(TRID_REG(card, T4D_MISCINT));
1847 outl(event | (ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
1848 TRID_REG(card, T4D_MISCINT));
1849 spin_unlock(&card->lock);
1853 /* manually clear interrupt status, bad hardware design, blame T^2 */
1854 outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
1855 TRID_REG(card, T4D_MISCINT));
1856 spin_unlock(&card->lock);
1860 /* in this loop, dmabuf.count signifies the amount of data that is waiting */
1861 /* to be copied to the user's buffer. it is filled by the dma machine and */
1862 /* drained by this loop. */
1864 trident_read(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
1866 struct trident_state *state = (struct trident_state *)file->private_data;
1867 struct dmabuf *dmabuf = &state->dmabuf;
1869 unsigned long flags;
1873 pr_debug("trident: trident_read called, count = %d\n", count);
1875 VALIDATE_STATE(state);
1879 if (!access_ok(VERIFY_WRITE, buffer, count))
1883 if (!dmabuf->ready && (ret = prog_dmabuf_record(state)))
1887 spin_lock_irqsave(&state->card->lock, flags);
1888 if (dmabuf->count > (signed) dmabuf->dmasize) {
1889 /* buffer overrun, we are recovering from */
1890 /* sleep_on_timeout, resync hwptr and swptr, */
1891 /* make process flush the buffer */
1892 dmabuf->count = dmabuf->dmasize;
1893 dmabuf->swptr = dmabuf->hwptr;
1895 swptr = dmabuf->swptr;
1896 cnt = dmabuf->dmasize - swptr;
1897 if (dmabuf->count < cnt)
1898 cnt = dmabuf->count;
1899 spin_unlock_irqrestore(&state->card->lock, flags);
1905 /* buffer is empty, start the dma machine and */
1906 /* wait for data to be recorded */
1908 if (file->f_flags & O_NONBLOCK) {
1915 /* No matter how much space left in the buffer, */
1916 /* we have to wait until CSO == ESO/2 or CSO == ESO */
1917 /* when address engine interrupts */
1918 tmo = (dmabuf->dmasize * HZ) / (dmabuf->rate * 2);
1919 tmo >>= sample_shift[dmabuf->fmt];
1920 /* There are two situations when sleep_on_timeout returns, one is when
1921 the interrupt is serviced correctly and the process is waked up by
1922 ISR ON TIME. Another is when timeout is expired, which means that
1923 either interrupt is NOT serviced correctly (pending interrupt) or it
1924 is TOO LATE for the process to be scheduled to run (scheduler latency)
1925 which results in a (potential) buffer overrun. And worse, there is
1926 NOTHING we can do to prevent it. */
1927 if (!interruptible_sleep_on_timeout(&dmabuf->wait, tmo)) {
1928 pr_debug(KERN_ERR "trident: recording schedule timeout, "
1929 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1930 dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
1931 dmabuf->hwptr, dmabuf->swptr);
1933 /* a buffer overrun, we delay the recovery until next time the
1934 while loop begin and we REALLY have space to record */
1936 if (signal_pending(current)) {
1942 if (dmabuf->mapped) {
1950 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1956 swptr = (swptr + cnt) % dmabuf->dmasize;
1958 spin_lock_irqsave(&state->card->lock, flags);
1959 dmabuf->swptr = swptr;
1960 dmabuf->count -= cnt;
1961 spin_unlock_irqrestore(&state->card->lock, flags);
1973 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1974 the soundcard. it is drained by the dma machine and filled by this loop. */
1977 trident_write(struct file *file, const char __user *buffer, size_t count, loff_t * ppos)
1979 struct trident_state *state = (struct trident_state *)file->private_data;
1980 struct dmabuf *dmabuf = &state->dmabuf;
1982 unsigned long flags;
1985 unsigned int state_cnt;
1986 unsigned int copy_count;
1987 int lret; /* for lock_set_fmt */
1989 pr_debug("trident: trident_write called, count = %d\n", count);
1991 VALIDATE_STATE(state);
1994 * Guard against an mmap or ioctl while writing
1999 if (dmabuf->mapped) {
2003 if (!dmabuf->ready && (ret = prog_dmabuf_playback(state)))
2006 if (!access_ok(VERIFY_READ, buffer, count)) {
2014 spin_lock_irqsave(&state->card->lock, flags);
2015 if (dmabuf->count < 0) {
2016 /* buffer underrun, we are recovering from */
2017 /* sleep_on_timeout, resync hwptr and swptr */
2019 dmabuf->swptr = dmabuf->hwptr;
2021 swptr = dmabuf->swptr;
2022 cnt = dmabuf->dmasize - swptr;
2023 if (dmabuf->count + cnt > dmabuf->dmasize)
2024 cnt = dmabuf->dmasize - dmabuf->count;
2025 spin_unlock_irqrestore(&state->card->lock, flags);
2031 /* buffer is full, start the dma machine and */
2032 /* wait for data to be played */
2034 if (file->f_flags & O_NONBLOCK) {
2039 /* No matter how much data left in the buffer, */
2040 /* we have to wait until CSO == ESO/2 or CSO == ESO */
2041 /* when address engine interrupts */
2042 lock_set_fmt(state);
2043 tmo = (dmabuf->dmasize * HZ) / (dmabuf->rate * 2);
2044 tmo >>= sample_shift[dmabuf->fmt];
2045 unlock_set_fmt(state);
2048 /* There are two situations when sleep_on_timeout */
2049 /* returns, one is when the interrupt is serviced */
2050 /* correctly and the process is waked up by ISR */
2051 /* ON TIME. Another is when timeout is expired, which */
2052 /* means that either interrupt is NOT serviced */
2053 /* correctly (pending interrupt) or it is TOO LATE */
2054 /* for the process to be scheduled to run */
2055 /* (scheduler latency) which results in a (potential) */
2056 /* buffer underrun. And worse, there is NOTHING we */
2057 /* can do to prevent it. */
2058 if (!interruptible_sleep_on_timeout(&dmabuf->wait, tmo)) {
2059 pr_debug(KERN_ERR "trident: playback schedule "
2060 "timeout, dmasz %u fragsz %u count %i "
2061 "hwptr %u swptr %u\n", dmabuf->dmasize,
2062 dmabuf->fragsize, dmabuf->count,
2063 dmabuf->hwptr, dmabuf->swptr);
2065 /* a buffer underrun, we delay the recovery */
2066 /* until next time the while loop begin and */
2067 /* we REALLY have data to play */
2069 if (signal_pending(current)) {
2075 if (dmabuf->mapped) {
2082 if ((lret = lock_set_fmt(state)) < 0) {
2087 if (state->chans_num == 6) {
2090 if (ali_write_5_1(state, buffer, cnt, ©_count,
2091 &state_cnt) == -EFAULT) {
2093 swptr = (swptr + state_cnt) % dmabuf->dmasize;
2094 spin_lock_irqsave(&state->card->lock, flags);
2095 dmabuf->swptr = swptr;
2096 dmabuf->count += state_cnt;
2097 dmabuf->endcleared = 0;
2098 spin_unlock_irqrestore(&state->card->lock, flags);
2103 unlock_set_fmt(state);
2107 if (copy_from_user(dmabuf->rawbuf + swptr,
2111 unlock_set_fmt(state);
2116 unlock_set_fmt(state);
2118 swptr = (swptr + state_cnt) % dmabuf->dmasize;
2120 spin_lock_irqsave(&state->card->lock, flags);
2121 dmabuf->swptr = swptr;
2122 dmabuf->count += state_cnt;
2123 dmabuf->endcleared = 0;
2124 spin_unlock_irqrestore(&state->card->lock, flags);
2137 /* No kernel lock - we have our own spinlock */
2139 trident_poll(struct file *file, struct poll_table_struct *wait)
2141 struct trident_state *state = (struct trident_state *)file->private_data;
2142 struct dmabuf *dmabuf = &state->dmabuf;
2143 unsigned long flags;
2144 unsigned int mask = 0;
2146 VALIDATE_STATE(state);
2149 * Guard against a parallel poll and write causing multiple
2150 * prog_dmabuf events
2155 if (file->f_mode & FMODE_WRITE) {
2156 if (!dmabuf->ready && prog_dmabuf_playback(state)) {
2160 poll_wait(file, &dmabuf->wait, wait);
2162 if (file->f_mode & FMODE_READ) {
2163 if (!dmabuf->ready && prog_dmabuf_record(state)) {
2167 poll_wait(file, &dmabuf->wait, wait);
2172 spin_lock_irqsave(&state->card->lock, flags);
2173 trident_update_ptr(state);
2174 if (file->f_mode & FMODE_READ) {
2175 if (dmabuf->count >= (signed) dmabuf->fragsize)
2176 mask |= POLLIN | POLLRDNORM;
2178 if (file->f_mode & FMODE_WRITE) {
2179 if (dmabuf->mapped) {
2180 if (dmabuf->count >= (signed) dmabuf->fragsize)
2181 mask |= POLLOUT | POLLWRNORM;
2183 if ((signed) dmabuf->dmasize >= dmabuf->count +
2184 (signed) dmabuf->fragsize)
2185 mask |= POLLOUT | POLLWRNORM;
2188 spin_unlock_irqrestore(&state->card->lock, flags);
2194 trident_mmap(struct file *file, struct vm_area_struct *vma)
2196 struct trident_state *state = (struct trident_state *)file->private_data;
2197 struct dmabuf *dmabuf = &state->dmabuf;
2201 VALIDATE_STATE(state);
2204 * Lock against poll read write or mmap creating buffers. Also lock
2205 * a read or write against an mmap.
2210 if (vma->vm_flags & VM_WRITE) {
2211 if ((ret = prog_dmabuf_playback(state)) != 0)
2213 } else if (vma->vm_flags & VM_READ) {
2214 if ((ret = prog_dmabuf_record(state)) != 0)
2220 if (vma->vm_pgoff != 0)
2222 size = vma->vm_end - vma->vm_start;
2223 if (size > (PAGE_SIZE << dmabuf->buforder))
2226 if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf),
2227 size, vma->vm_page_prot))
2237 trident_ioctl(struct inode *inode, struct file *file,
2238 unsigned int cmd, unsigned long arg)
2240 struct trident_state *state = (struct trident_state *)file->private_data;
2241 struct dmabuf *dmabuf = &state->dmabuf;
2242 unsigned long flags;
2243 audio_buf_info abinfo;
2245 int val, mapped, ret = 0;
2246 struct trident_card *card = state->card;
2247 void __user *argp = (void __user *)arg;
2248 int __user *p = argp;
2250 VALIDATE_STATE(state);
2253 mapped = ((file->f_mode & (FMODE_WRITE | FMODE_READ)) && dmabuf->mapped);
2255 pr_debug("trident: trident_ioctl, command = %2d, arg = 0x%08x\n",
2256 _IOC_NR(cmd), arg ? *p : 0);
2259 case OSS_GETVERSION:
2260 ret = put_user(SOUND_VERSION, p);
2263 case SNDCTL_DSP_RESET:
2264 /* FIXME: spin_lock ? */
2265 if (file->f_mode & FMODE_WRITE) {
2267 synchronize_irq(card->irq);
2269 dmabuf->swptr = dmabuf->hwptr = 0;
2270 dmabuf->count = dmabuf->total_bytes = 0;
2272 if (file->f_mode & FMODE_READ) {
2274 synchronize_irq(card->irq);
2276 dmabuf->swptr = dmabuf->hwptr = 0;
2277 dmabuf->count = dmabuf->total_bytes = 0;
2281 case SNDCTL_DSP_SYNC:
2282 if (file->f_mode & FMODE_WRITE)
2283 ret = drain_dac(state, file->f_flags & O_NONBLOCK);
2286 case SNDCTL_DSP_SPEED: /* set smaple rate */
2287 if (get_user(val, p)) {
2292 if (file->f_mode & FMODE_WRITE) {
2295 spin_lock_irqsave(&state->card->lock, flags);
2296 trident_set_dac_rate(state, val);
2297 spin_unlock_irqrestore(&state->card->lock, flags);
2299 if (file->f_mode & FMODE_READ) {
2302 spin_lock_irqsave(&state->card->lock, flags);
2303 trident_set_adc_rate(state, val);
2304 spin_unlock_irqrestore(&state->card->lock, flags);
2307 ret = put_user(dmabuf->rate, p);
2310 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2311 if (get_user(val, p)) {
2315 if ((ret = lock_set_fmt(state)) < 0)
2318 if (file->f_mode & FMODE_WRITE) {
2322 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2324 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2326 if (file->f_mode & FMODE_READ) {
2330 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2332 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2334 unlock_set_fmt(state);
2337 case SNDCTL_DSP_GETBLKSIZE:
2338 if (file->f_mode & FMODE_WRITE) {
2339 if ((val = prog_dmabuf_playback(state)))
2342 ret = put_user(dmabuf->fragsize, p);
2345 if (file->f_mode & FMODE_READ) {
2346 if ((val = prog_dmabuf_record(state)))
2349 ret = put_user(dmabuf->fragsize, p);
2352 /* neither READ nor WRITE? is this even possible? */
2357 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format */
2358 ret = put_user(AFMT_S16_LE | AFMT_U16_LE | AFMT_S8 |
2362 case SNDCTL_DSP_SETFMT: /* Select sample format */
2363 if (get_user(val, p)) {
2367 if ((ret = lock_set_fmt(state)) < 0)
2370 if (val != AFMT_QUERY) {
2371 if (file->f_mode & FMODE_WRITE) {
2374 if (val == AFMT_S16_LE)
2375 dmabuf->fmt |= TRIDENT_FMT_16BIT;
2377 dmabuf->fmt &= ~TRIDENT_FMT_16BIT;
2379 if (file->f_mode & FMODE_READ) {
2382 if (val == AFMT_S16_LE)
2383 dmabuf->fmt |= TRIDENT_FMT_16BIT;
2385 dmabuf->fmt &= ~TRIDENT_FMT_16BIT;
2388 unlock_set_fmt(state);
2389 ret = put_user((dmabuf->fmt & TRIDENT_FMT_16BIT) ? AFMT_S16_LE :
2393 case SNDCTL_DSP_CHANNELS:
2394 if (get_user(val, p)) {
2399 if ((ret = lock_set_fmt(state)) < 0)
2402 if (file->f_mode & FMODE_WRITE) {
2406 //prevent from memory leak
2407 if ((state->chans_num > 2) && (state->chans_num != val)) {
2408 ali_free_other_states_resources(state);
2409 state->chans_num = 1;
2414 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2415 if ((val == 6) && (state->card->pci_id == PCI_DEVICE_ID_ALI_5451)) {
2416 if (card->rec_channel_use_count > 0) {
2417 printk(KERN_ERR "trident: Record is "
2418 "working on the card!\n");
2420 unlock_set_fmt(state);
2424 ret = ali_setup_multi_channels(state->card, 6);
2426 unlock_set_fmt(state);
2429 down(&state->card->open_sem);
2430 ret = ali_allocate_other_states_resources(state, 6);
2432 up(&state->card->open_sem);
2433 unlock_set_fmt(state);
2436 state->card->multi_channel_use_count++;
2437 up(&state->card->open_sem);
2439 val = 2; /*yield to 2-channels */
2441 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2442 state->chans_num = val;
2444 if (file->f_mode & FMODE_READ) {
2448 if (!((file->f_mode & FMODE_WRITE) &&
2451 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2453 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2454 state->chans_num = val;
2456 unlock_set_fmt(state);
2458 ret = put_user(val, p);
2461 case SNDCTL_DSP_POST:
2462 /* Cause the working fragment to be output */
2465 case SNDCTL_DSP_SUBDIVIDE:
2466 if (dmabuf->subdivision) {
2470 if (get_user(val, p)) {
2474 if (val != 1 && val != 2 && val != 4) {
2478 dmabuf->subdivision = val;
2481 case SNDCTL_DSP_SETFRAGMENT:
2482 if (get_user(val, p)) {
2487 dmabuf->ossfragshift = val & 0xffff;
2488 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2489 if (dmabuf->ossfragshift < 4)
2490 dmabuf->ossfragshift = 4;
2491 if (dmabuf->ossfragshift > 15)
2492 dmabuf->ossfragshift = 15;
2493 if (dmabuf->ossmaxfrags < 4)
2494 dmabuf->ossmaxfrags = 4;
2498 case SNDCTL_DSP_GETOSPACE:
2499 if (!(file->f_mode & FMODE_WRITE)) {
2503 if (!dmabuf->ready && (val = prog_dmabuf_playback(state)) != 0) {
2507 spin_lock_irqsave(&state->card->lock, flags);
2508 trident_update_ptr(state);
2509 abinfo.fragsize = dmabuf->fragsize;
2510 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2511 abinfo.fragstotal = dmabuf->numfrag;
2512 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2513 spin_unlock_irqrestore(&state->card->lock, flags);
2514 ret = copy_to_user(argp, &abinfo, sizeof (abinfo)) ?
2518 case SNDCTL_DSP_GETISPACE:
2519 if (!(file->f_mode & FMODE_READ)) {
2523 if (!dmabuf->ready && (val = prog_dmabuf_record(state)) != 0) {
2527 spin_lock_irqsave(&state->card->lock, flags);
2528 trident_update_ptr(state);
2529 abinfo.fragsize = dmabuf->fragsize;
2530 abinfo.bytes = dmabuf->count;
2531 abinfo.fragstotal = dmabuf->numfrag;
2532 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2533 spin_unlock_irqrestore(&state->card->lock, flags);
2534 ret = copy_to_user(argp, &abinfo, sizeof (abinfo)) ?
2538 case SNDCTL_DSP_NONBLOCK:
2539 file->f_flags |= O_NONBLOCK;
2542 case SNDCTL_DSP_GETCAPS:
2543 ret = put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2544 DSP_CAP_MMAP | DSP_CAP_BIND, p);
2547 case SNDCTL_DSP_GETTRIGGER:
2549 if ((file->f_mode & FMODE_READ) && dmabuf->enable)
2550 val |= PCM_ENABLE_INPUT;
2551 if ((file->f_mode & FMODE_WRITE) && dmabuf->enable)
2552 val |= PCM_ENABLE_OUTPUT;
2553 ret = put_user(val, p);
2556 case SNDCTL_DSP_SETTRIGGER:
2557 if (get_user(val, p)) {
2561 if (file->f_mode & FMODE_READ) {
2562 if (val & PCM_ENABLE_INPUT) {
2563 if (!dmabuf->ready &&
2564 (ret = prog_dmabuf_record(state)))
2570 if (file->f_mode & FMODE_WRITE) {
2571 if (val & PCM_ENABLE_OUTPUT) {
2572 if (!dmabuf->ready &&
2573 (ret = prog_dmabuf_playback(state)))
2581 case SNDCTL_DSP_GETIPTR:
2582 if (!(file->f_mode & FMODE_READ)) {
2586 if (!dmabuf->ready && (val = prog_dmabuf_record(state))
2591 spin_lock_irqsave(&state->card->lock, flags);
2592 trident_update_ptr(state);
2593 cinfo.bytes = dmabuf->total_bytes;
2594 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2595 cinfo.ptr = dmabuf->hwptr;
2597 dmabuf->count &= dmabuf->fragsize - 1;
2598 spin_unlock_irqrestore(&state->card->lock, flags);
2599 ret = copy_to_user(argp, &cinfo, sizeof (cinfo)) ?
2603 case SNDCTL_DSP_GETOPTR:
2604 if (!(file->f_mode & FMODE_WRITE)) {
2608 if (!dmabuf->ready && (val = prog_dmabuf_playback(state))
2614 spin_lock_irqsave(&state->card->lock, flags);
2615 trident_update_ptr(state);
2616 cinfo.bytes = dmabuf->total_bytes;
2617 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2618 cinfo.ptr = dmabuf->hwptr;
2620 dmabuf->count &= dmabuf->fragsize - 1;
2621 spin_unlock_irqrestore(&state->card->lock, flags);
2622 ret = copy_to_user(argp, &cinfo, sizeof (cinfo)) ?
2626 case SNDCTL_DSP_SETDUPLEX:
2630 case SNDCTL_DSP_GETODELAY:
2631 if (!(file->f_mode & FMODE_WRITE)) {
2635 if (!dmabuf->ready && (val = prog_dmabuf_playback(state)) != 0) {
2639 spin_lock_irqsave(&state->card->lock, flags);
2640 trident_update_ptr(state);
2641 val = dmabuf->count;
2642 spin_unlock_irqrestore(&state->card->lock, flags);
2643 ret = put_user(val, p);
2646 case SOUND_PCM_READ_RATE:
2647 ret = put_user(dmabuf->rate, p);
2650 case SOUND_PCM_READ_CHANNELS:
2651 ret = put_user((dmabuf->fmt & TRIDENT_FMT_STEREO) ? 2 : 1,
2655 case SOUND_PCM_READ_BITS:
2656 ret = put_user((dmabuf->fmt & TRIDENT_FMT_16BIT) ? AFMT_S16_LE :
2660 case SNDCTL_DSP_GETCHANNELMASK:
2661 ret = put_user(DSP_BIND_FRONT | DSP_BIND_SURR |
2662 DSP_BIND_CENTER_LFE, p);
2665 case SNDCTL_DSP_BIND_CHANNEL:
2666 if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
2671 if (get_user(val, p)) {
2675 if (val == DSP_BIND_QUERY) {
2676 val = dmabuf->channel->attribute | 0x3c00;
2677 val = attr2mask[val >> 8];
2680 if (file->f_mode & FMODE_READ)
2681 dmabuf->channel->attribute = (CHANNEL_REC |
2683 if (file->f_mode & FMODE_WRITE)
2684 dmabuf->channel->attribute = (CHANNEL_SPC_PB |
2686 dmabuf->channel->attribute |= mask2attr[ffs(val)];
2688 ret = put_user(val, p);
2691 case SNDCTL_DSP_MAPINBUF:
2692 case SNDCTL_DSP_MAPOUTBUF:
2693 case SNDCTL_DSP_SETSYNCRO:
2694 case SOUND_PCM_WRITE_FILTER:
2695 case SOUND_PCM_READ_FILTER:
2705 trident_open(struct inode *inode, struct file *file)
2708 int minor = iminor(inode);
2709 struct trident_card *card = devs;
2710 struct trident_state *state = NULL;
2711 struct dmabuf *dmabuf = NULL;
2713 /* Added by Matt Wu 01-05-2001 */
2714 /* TODO: there's some redundacy here wrt the check below */
2715 /* for multi_use_count > 0. Should we return -EBUSY or find */
2716 /* a different card? for now, don't break current behaviour */
2718 if (file->f_mode & FMODE_READ) {
2719 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2720 if (card->multi_channel_use_count > 0)
2725 /* find an available virtual channel (instance of /dev/dsp) */
2726 while (card != NULL) {
2727 down(&card->open_sem);
2728 if (file->f_mode & FMODE_READ) {
2729 /* Skip opens on cards that are in 6 channel mode */
2730 if (card->multi_channel_use_count > 0) {
2731 up(&card->open_sem);
2736 for (i = 0; i < NR_HW_CH; i++) {
2737 if (card->states[i] == NULL) {
2738 state = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
2739 if (state == NULL) {
2740 up(&card->open_sem);
2743 memset(state, 0, sizeof(*state));
2744 init_MUTEX(&state->sem);
2745 dmabuf = &state->dmabuf;
2749 up(&card->open_sem);
2752 /* no more virtual channel avaiable */
2757 /* found a free virtual channel, allocate hardware channels */
2758 if (file->f_mode & FMODE_READ)
2759 dmabuf->channel = card->alloc_rec_pcm_channel(card);
2761 dmabuf->channel = card->alloc_pcm_channel(card);
2763 if (dmabuf->channel == NULL) {
2764 kfree(card->states[i]);
2765 card->states[i] = NULL;
2769 /* initialize the virtual channel */
2772 state->magic = TRIDENT_STATE_MAGIC;
2773 init_waitqueue_head(&dmabuf->wait);
2774 file->private_data = state;
2776 /* set default sample format. According to OSS Programmer's */
2777 /* Guide /dev/dsp should be default to unsigned 8-bits, mono, */
2778 /* with sample rate 8kHz and /dev/dspW will accept 16-bits sample */
2779 if (file->f_mode & FMODE_WRITE) {
2780 dmabuf->fmt &= ~TRIDENT_FMT_MASK;
2781 if ((minor & 0x0f) == SND_DEV_DSP16)
2782 dmabuf->fmt |= TRIDENT_FMT_16BIT;
2783 dmabuf->ossfragshift = 0;
2784 dmabuf->ossmaxfrags = 0;
2785 dmabuf->subdivision = 0;
2786 if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
2787 /* set default channel attribute to normal playback */
2788 dmabuf->channel->attribute = CHANNEL_PB;
2790 trident_set_dac_rate(state, 8000);
2793 if (file->f_mode & FMODE_READ) {
2794 /* FIXME: Trident 4d can only record in signed 16-bits stereo, */
2795 /* 48kHz sample, to be dealed with in trident_set_adc_rate() ?? */
2796 dmabuf->fmt &= ~TRIDENT_FMT_MASK;
2797 if ((minor & 0x0f) == SND_DEV_DSP16)
2798 dmabuf->fmt |= TRIDENT_FMT_16BIT;
2799 dmabuf->ossfragshift = 0;
2800 dmabuf->ossmaxfrags = 0;
2801 dmabuf->subdivision = 0;
2802 if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
2803 /* set default channel attribute to 0x8a80, record from
2804 PCM L/R FIFO and mono = (left + right + 1)/2 */
2805 dmabuf->channel->attribute = (CHANNEL_REC | PCM_LR |
2808 trident_set_adc_rate(state, 8000);
2810 /* Added by Matt Wu 01-05-2001 */
2811 if (card->pci_id == PCI_DEVICE_ID_ALI_5451)
2812 card->rec_channel_use_count++;
2815 state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2816 up(&card->open_sem);
2818 pr_debug("trident: open virtual channel %d, hard channel %d\n",
2819 state->virt, dmabuf->channel->num);
2821 return nonseekable_open(inode, file);
2825 trident_release(struct inode *inode, struct file *file)
2827 struct trident_state *state = (struct trident_state *)file->private_data;
2828 struct trident_card *card;
2829 struct dmabuf *dmabuf;
2831 VALIDATE_STATE(state);
2834 dmabuf = &state->dmabuf;
2836 if (file->f_mode & FMODE_WRITE) {
2837 trident_clear_tail(state);
2838 drain_dac(state, file->f_flags & O_NONBLOCK);
2841 pr_debug("trident: closing virtual channel %d, hard channel %d\n",
2842 state->virt, dmabuf->channel->num);
2844 /* stop DMA state machine and free DMA buffers/channels */
2845 down(&card->open_sem);
2847 if (file->f_mode & FMODE_WRITE) {
2849 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
2850 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
2852 /* Added by Matt Wu */
2853 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2854 if (state->chans_num > 2) {
2855 if (card->multi_channel_use_count-- < 0)
2856 card->multi_channel_use_count = 0;
2857 if (card->multi_channel_use_count == 0)
2858 ali_close_multi_channels();
2859 ali_free_other_states_resources(state);
2863 if (file->f_mode & FMODE_READ) {
2865 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
2866 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
2868 /* Added by Matt Wu */
2869 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2870 if (card->rec_channel_use_count-- < 0)
2871 card->rec_channel_use_count = 0;
2875 card->states[state->virt] = NULL;
2878 /* we're covered by the open_sem */
2879 up(&card->open_sem);
2884 static /*const */ struct file_operations trident_audio_fops = {
2885 .owner = THIS_MODULE,
2886 .llseek = no_llseek,
2887 .read = trident_read,
2888 .write = trident_write,
2889 .poll = trident_poll,
2890 .ioctl = trident_ioctl,
2891 .mmap = trident_mmap,
2892 .open = trident_open,
2893 .release = trident_release,
2896 /* trident specific AC97 functions */
2897 /* Write AC97 codec registers */
2899 trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val)
2901 struct trident_card *card = (struct trident_card *)codec->private_data;
2902 unsigned int address, mask, busy;
2903 unsigned short count = 0xffff;
2904 unsigned long flags;
2907 data = ((u32) val) << 16;
2909 switch (card->pci_id) {
2911 case PCI_DEVICE_ID_SI_7018:
2912 address = SI_AC97_WRITE;
2913 mask = SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY;
2915 mask |= SI_AC97_SECONDARY;
2916 busy = SI_AC97_BUSY_WRITE;
2918 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
2919 address = DX_ACR0_AC97_W;
2920 mask = busy = DX_AC97_BUSY_WRITE;
2922 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
2923 address = NX_ACR1_AC97_W;
2924 mask = NX_AC97_BUSY_WRITE;
2926 mask |= NX_AC97_WRITE_SECONDARY;
2927 busy = NX_AC97_BUSY_WRITE;
2929 case PCI_DEVICE_ID_INTERG_5050:
2930 address = SI_AC97_WRITE;
2931 mask = busy = SI_AC97_BUSY_WRITE;
2933 mask |= SI_AC97_SECONDARY;
2937 spin_lock_irqsave(&card->lock, flags);
2939 if ((inw(TRID_REG(card, address)) & busy) == 0)
2943 data |= (mask | (reg & AC97_REG_ADDR));
2946 printk(KERN_ERR "trident: AC97 CODEC write timed out.\n");
2947 spin_unlock_irqrestore(&card->lock, flags);
2951 outl(data, TRID_REG(card, address));
2952 spin_unlock_irqrestore(&card->lock, flags);
2955 /* Read AC97 codec registers */
2957 trident_ac97_get(struct ac97_codec *codec, u8 reg)
2959 struct trident_card *card = (struct trident_card *)codec->private_data;
2960 unsigned int address, mask, busy;
2961 unsigned short count = 0xffff;
2962 unsigned long flags;
2965 switch (card->pci_id) {
2967 case PCI_DEVICE_ID_SI_7018:
2968 address = SI_AC97_READ;
2969 mask = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY;
2971 mask |= SI_AC97_SECONDARY;
2972 busy = SI_AC97_BUSY_READ;
2974 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
2975 address = DX_ACR1_AC97_R;
2976 mask = busy = DX_AC97_BUSY_READ;
2978 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
2980 address = NX_ACR3_AC97_R_SECONDARY;
2982 address = NX_ACR2_AC97_R_PRIMARY;
2983 mask = NX_AC97_BUSY_READ;
2984 busy = NX_AC97_BUSY_READ | NX_AC97_BUSY_DATA;
2986 case PCI_DEVICE_ID_INTERG_5050:
2987 address = SI_AC97_READ;
2988 mask = busy = SI_AC97_BUSY_READ;
2990 mask |= SI_AC97_SECONDARY;
2994 data = (mask | (reg & AC97_REG_ADDR));
2996 spin_lock_irqsave(&card->lock, flags);
2997 outl(data, TRID_REG(card, address));
2999 data = inl(TRID_REG(card, address));
3000 if ((data & busy) == 0)
3003 spin_unlock_irqrestore(&card->lock, flags);
3006 printk(KERN_ERR "trident: AC97 CODEC read timed out.\n");
3009 return ((u16) (data >> 16));
3012 /* rewrite ac97 read and write mixer register by hulei for ALI*/
3014 acquirecodecaccess(struct trident_card *card)
3016 u16 wsemamask = 0x6000; /* bit 14..13 */
3022 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3023 wsemabits = wcontrol & wsemamask;
3025 if (wsemabits == 0x4000)
3026 return 1; /* 0x4000 is audio ,then success */
3029 if (wsemabits == 0) {
3031 outl(((u32) (wcontrol & 0x1eff) | 0x00004000),
3032 TRID_REG(card, ALI_AC97_WRITE));
3038 pr_debug("accesscodecsemaphore: try unlock\n");
3046 releasecodecaccess(struct trident_card *card)
3048 unsigned long wcontrol;
3049 wcontrol = inl(TRID_REG(card, ALI_AC97_WRITE));
3050 outl((wcontrol & 0xffff1eff), TRID_REG(card, ALI_AC97_WRITE));
3054 waitforstimertick(struct trident_card *card)
3056 unsigned long chk1, chk2;
3057 unsigned int wcount = 0xffff;
3058 chk1 = inl(TRID_REG(card, ALI_STIMER));
3061 chk2 = inl(TRID_REG(card, ALI_STIMER));
3062 if ((wcount > 0) && chk1 != chk2)
3071 /* Read AC97 codec registers for ALi*/
3073 ali_ac97_get(struct trident_card *card, int secondary, u8 reg)
3075 unsigned int address, mask;
3076 unsigned int ncount;
3077 unsigned long aud_reg;
3080 unsigned long flags;
3085 address = ALI_AC97_READ;
3086 if (card->revision == ALI_5451_V02) {
3087 address = ALI_AC97_WRITE;
3089 mask = ALI_AC97_READ_ACTION | ALI_AC97_AUDIO_BUSY;
3091 mask |= ALI_AC97_SECONDARY;
3093 spin_lock_irqsave(&card->lock, flags);
3095 if (!acquirecodecaccess(card))
3096 printk(KERN_ERR "access codec fail\n");
3098 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3100 wcontrol |= (0x8000 | reg);
3101 outw(wcontrol, TRID_REG(card, ALI_AC97_WRITE));
3103 data = (mask | (reg & AC97_REG_ADDR));
3105 if (!waitforstimertick(card)) {
3106 printk(KERN_ERR "ali_ac97_read: BIT_CLOCK is dead\n");
3115 if ((inw(TRID_REG(card, ALI_AC97_WRITE)) & ALI_AC97_BUSY_READ)
3120 if (ncount-- == 1) {
3121 pr_debug("ali_ac97_read :try clear busy flag\n");
3122 aud_reg = inl(TRID_REG(card, ALI_AC97_WRITE));
3123 outl((aud_reg & 0xffff7fff),
3124 TRID_REG(card, ALI_AC97_WRITE));
3129 data = inl(TRID_REG(card, address));
3131 spin_unlock_irqrestore(&card->lock, flags);
3133 return ((u16) (data >> 16));
3136 releasecodecaccess(card);
3137 spin_unlock_irqrestore(&card->lock, flags);
3138 printk(KERN_ERR "ali_ac97_read: AC97 CODEC read timed out.\n");
3142 /* Write AC97 codec registers for hulei*/
3144 ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val)
3146 unsigned int address, mask;
3147 unsigned int ncount;
3150 unsigned long flags;
3152 data = ((u32) val) << 16;
3157 address = ALI_AC97_WRITE;
3158 mask = ALI_AC97_WRITE_ACTION | ALI_AC97_AUDIO_BUSY;
3160 mask |= ALI_AC97_SECONDARY;
3161 if (card->revision == ALI_5451_V02)
3162 mask |= ALI_AC97_WRITE_MIXER_REGISTER;
3164 spin_lock_irqsave(&card->lock, flags);
3165 if (!acquirecodecaccess(card))
3166 printk(KERN_ERR "ali_ac97_write: access codec fail\n");
3168 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3170 wcontrol |= (0x8100 | reg); /* bit 8=1: (ali1535 )reserved/ */
3171 /* ali1535+ write */
3172 outl((data | wcontrol), TRID_REG(card, ALI_AC97_WRITE));
3174 if (!waitforstimertick(card)) {
3175 printk(KERN_ERR "BIT_CLOCK is dead\n");
3181 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3182 if (!(wcontrol & 0x8000))
3186 if (ncount-- == 1) {
3187 pr_debug("ali_ac97_set :try clear busy flag!!\n");
3188 outw(wcontrol & 0x7fff,
3189 TRID_REG(card, ALI_AC97_WRITE));
3195 releasecodecaccess(card);
3196 spin_unlock_irqrestore(&card->lock, flags);
3201 ali_enable_special_channel(struct trident_state *stat)
3203 struct trident_card *card = stat->card;
3204 unsigned long s_channels;
3206 s_channels = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3207 s_channels |= (1 << stat->dmabuf.channel->num);
3208 outl(s_channels, TRID_REG(card, ALI_GLOBAL_CONTROL));
3212 ali_ac97_read(struct ac97_codec *codec, u8 reg)
3216 struct trident_card *card = NULL;
3218 /* Added by Matt Wu */
3222 card = (struct trident_card *) codec->private_data;
3224 if (!card->mixer_regs_ready)
3225 return ali_ac97_get(card, codec->id, reg);
3228 * FIXME: need to stop this caching some registers
3235 data = card->mixer_regs[reg / 2][id];
3240 ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val)
3243 struct trident_card *card;
3245 /* Added by Matt Wu */
3249 card = (struct trident_card *) codec->private_data;
3251 if (!card->mixer_regs_ready) {
3252 ali_ac97_set(card, codec->id, reg, val);
3261 card->mixer_regs[reg / 2][id] = val;
3262 ali_ac97_set(card, codec->id, reg, val);
3266 flag: ALI_SPDIF_OUT_TO_SPDIF_OUT
3267 ALI_PCM_TO_SPDIF_OUT
3271 ali_setup_spdif_out(struct trident_card *card, int flag)
3273 unsigned long spdif;
3277 struct pci_dev *pci_dev = NULL;
3279 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3281 if (pci_dev == NULL)
3283 pci_read_config_byte(pci_dev, 0x61, &temp);
3285 pci_write_config_byte(pci_dev, 0x61, temp);
3286 pci_read_config_byte(pci_dev, 0x7d, &temp);
3288 pci_write_config_byte(pci_dev, 0x7d, temp);
3289 pci_read_config_byte(pci_dev, 0x7e, &temp);
3292 pci_write_config_byte(pci_dev, 0x7e, temp);
3294 ch = inb(TRID_REG(card, ALI_SCTRL));
3295 outb(ch | ALI_SPDIF_OUT_ENABLE, TRID_REG(card, ALI_SCTRL));
3296 ch = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3297 outb(ch & ALI_SPDIF_OUT_CH_STATUS, TRID_REG(card, ALI_SPDIF_CTRL));
3299 if (flag & ALI_SPDIF_OUT_TO_SPDIF_OUT) {
3300 spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
3301 spdif |= ALI_SPDIF_OUT_CH_ENABLE;
3302 spdif &= ALI_SPDIF_OUT_SEL_SPDIF;
3303 outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3304 spdif = inw(TRID_REG(card, ALI_SPDIF_CS));
3305 if (flag & ALI_SPDIF_OUT_NON_PCM)
3309 outw(spdif, TRID_REG(card, ALI_SPDIF_CS));
3311 spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
3312 spdif |= ALI_SPDIF_OUT_SEL_PCM;
3313 outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3318 ali_disable_special_channel(struct trident_card *card, int ch)
3322 sc = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3324 outl(sc, TRID_REG(card, ALI_GLOBAL_CONTROL));
3328 ali_disable_spdif_in(struct trident_card *card)
3330 unsigned long spdif;
3332 spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3333 spdif &= (~ALI_SPDIF_IN_SUPPORT);
3334 outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3336 ali_disable_special_channel(card, ALI_SPDIF_IN_CHANNEL);
3340 ali_setup_spdif_in(struct trident_card *card)
3342 unsigned long spdif;
3344 //Set SPDIF IN Supported
3345 spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3346 spdif |= ALI_SPDIF_IN_SUPPORT;
3347 outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3350 spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3351 spdif |= ALI_SPDIF_IN_CH_ENABLE;
3352 outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3354 spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3355 spdif |= ALI_SPDIF_IN_CH_STATUS;
3356 outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3358 spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3359 spdif |= ALI_SPDIF_IN_FUNC_ENABLE;
3360 outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3365 ali_delay(struct trident_card *card, int interval)
3367 unsigned long begintimer, currenttimer;
3369 begintimer = inl(TRID_REG(card, ALI_STIMER));
3370 currenttimer = inl(TRID_REG(card, ALI_STIMER));
3372 while (currenttimer < begintimer + interval)
3373 currenttimer = inl(TRID_REG(card, ALI_STIMER));
3377 ali_detect_spdif_rate(struct trident_card *card)
3381 u8 bval = 0, R1 = 0, R2 = 0;
3383 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3385 outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
3387 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3389 outb(bval, TRID_REG(card, ALI_SPDIF_CTRL + 1));
3391 while (((R1 < 0x0B) || (R1 > 0x0E)) && (R1 != 0x12) &&
3397 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3401 if (count > 50000) {
3402 printk(KERN_WARNING "trident: Error in "
3403 "ali_detect_spdif_rate!\n");
3409 while (count <= 50000) {
3414 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3423 if (count > 50000) {
3424 printk(KERN_WARNING "trident: Error in "
3425 "ali_detect_spdif_rate!\n");
3434 wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
3436 wval |= (u16) 0x09 << 8 | (u16) 0x05;
3437 outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
3439 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
3440 outb(bval | 0x02, TRID_REG(card, ALI_SPDIF_CS + 3));
3444 wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
3446 wval |= (u16) 0x0E << 8 | (u16) 0x08;
3447 outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
3449 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
3450 outb(bval | 0x03, TRID_REG(card, ALI_SPDIF_CS + 3));
3460 ali_get_spdif_in_rate(struct trident_card *card)
3465 ali_detect_spdif_rate(card);
3467 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3470 outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
3472 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3));
3495 ali_close_multi_channels(void)
3498 struct pci_dev *pci_dev = NULL;
3500 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3502 if (pci_dev == NULL)
3504 pci_read_config_byte(pci_dev, 0x59, &temp);
3506 pci_write_config_byte(pci_dev, 0x59, temp);
3508 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
3510 if (pci_dev == NULL)
3513 pci_read_config_byte(pci_dev, 0xB8, &temp);
3515 pci_write_config_byte(pci_dev, 0xB8, temp);
3521 ali_setup_multi_channels(struct trident_card *card, int chan_nums)
3523 unsigned long dwValue;
3525 struct pci_dev *pci_dev = NULL;
3527 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3529 if (pci_dev == NULL)
3531 pci_read_config_byte(pci_dev, 0x59, &temp);
3533 pci_write_config_byte(pci_dev, 0x59, temp);
3535 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
3537 if (pci_dev == NULL)
3539 pci_read_config_byte(pci_dev, (int) 0xB8, &temp);
3541 pci_write_config_byte(pci_dev, (int) 0xB8, (u8) temp);
3542 if (chan_nums == 6) {
3543 dwValue = inl(TRID_REG(card, ALI_SCTRL)) | 0x000f0000;
3544 outl(dwValue, TRID_REG(card, ALI_SCTRL));
3546 dwValue = inl(TRID_REG(card, ALI_SCTRL));
3547 if (dwValue & 0x2000000) {
3548 ali_ac97_write(card->ac97_codec[0], 0x02, 8080);
3549 ali_ac97_write(card->ac97_codec[0], 0x36, 0);
3550 ali_ac97_write(card->ac97_codec[0], 0x38, 0);
3552 * On a board with a single codec you won't get the
3553 * surround. On other boards configure it.
3555 if (card->ac97_codec[1] != NULL) {
3556 ali_ac97_write(card->ac97_codec[1], 0x36, 0);
3557 ali_ac97_write(card->ac97_codec[1], 0x38, 0);
3558 ali_ac97_write(card->ac97_codec[1], 0x02, 0x0606);
3559 ali_ac97_write(card->ac97_codec[1], 0x18, 0x0303);
3560 ali_ac97_write(card->ac97_codec[1], 0x74, 0x3);
3569 ali_free_pcm_channel(struct trident_card *card, unsigned int channel)
3576 bank = channel >> 5;
3577 channel = channel & 0x1f;
3579 card->banks[bank].bitmap &= ~(1 << (channel));
3583 ali_allocate_other_states_resources(struct trident_state *state, int chan_nums)
3585 struct trident_card *card = state->card;
3586 struct trident_state *s;
3587 int i, state_count = 0;
3588 struct trident_pcm_bank *bank;
3589 struct trident_channel *channel;
3592 bank = &card->banks[BANK_A];
3597 for (i = 0; (i < ALI_CHANNELS) && (state_count != 4); i++) {
3598 if (card->states[i])
3601 num = ali_multi_channels_5_1[state_count];
3602 if (!(bank->bitmap & (1 << num))) {
3603 bank->bitmap |= 1 << num;
3604 channel = &bank->channels[num];
3608 for (; state_count >= 0; state_count--) {
3609 kfree(state->other_states[state_count]);
3610 num = ali_multi_channels_5_1[state_count];
3611 ali_free_pcm_channel(card, num);
3615 s = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
3617 num = ali_multi_channels_5_1[state_count];
3618 ali_free_pcm_channel(card, num);
3620 for (; state_count >= 0; state_count--) {
3621 num = ali_multi_channels_5_1[state_count];
3622 ali_free_pcm_channel(card, num);
3623 kfree(state->other_states[state_count]);
3627 memset(s, 0, sizeof(*state));
3629 s->dmabuf.channel = channel;
3630 s->dmabuf.ossfragshift = s->dmabuf.ossmaxfrags =
3631 s->dmabuf.subdivision = 0;
3632 init_waitqueue_head(&s->dmabuf.wait);
3633 s->magic = card->magic;
3636 ali_enable_special_channel(s);
3637 state->other_states[state_count++] = s;
3640 if (state_count != 4) {
3642 for (; state_count >= 0; state_count--) {
3643 kfree(state->other_states[state_count]);
3644 num = ali_multi_channels_5_1[state_count];
3645 ali_free_pcm_channel(card, num);
3653 ali_save_regs(struct trident_card *card)
3655 unsigned long flags;
3658 spin_lock_irqsave(&card->lock, flags);
3660 ali_registers.global_regs[0x2c] = inl(TRID_REG(card, T4D_MISCINT));
3661 //ali_registers.global_regs[0x20] = inl(TRID_REG(card,T4D_START_A));
3662 ali_registers.global_regs[0x21] = inl(TRID_REG(card, T4D_STOP_A));
3664 //disable all IRQ bits
3665 outl(ALI_DISABLE_ALL_IRQ, TRID_REG(card, T4D_MISCINT));
3667 for (i = 1; i < ALI_MIXER_REGS; i++)
3668 ali_registers.mixer_regs[i] = ali_ac97_read(card->ac97_codec[0],
3671 for (i = 0; i < ALI_GLOBAL_REGS; i++) {
3672 if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A))
3674 ali_registers.global_regs[i] = inl(TRID_REG(card, i * 4));
3677 for (i = 0; i < ALI_CHANNELS; i++) {
3678 outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
3679 for (j = 0; j < ALI_CHANNEL_REGS; j++)
3680 ali_registers.channel_regs[i][j] = inl(TRID_REG(card,
3684 //Stop all HW channel
3685 outl(ALI_STOP_ALL_CHANNELS, TRID_REG(card, T4D_STOP_A));
3687 spin_unlock_irqrestore(&card->lock, flags);
3691 ali_restore_regs(struct trident_card *card)
3693 unsigned long flags;
3696 spin_lock_irqsave(&card->lock, flags);
3698 for (i = 1; i < ALI_MIXER_REGS; i++)
3699 ali_ac97_write(card->ac97_codec[0], i * 2,
3700 ali_registers.mixer_regs[i]);
3702 for (i = 0; i < ALI_CHANNELS; i++) {
3703 outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
3704 for (j = 0; j < ALI_CHANNEL_REGS; j++)
3705 outl(ali_registers.channel_regs[i][j],
3706 TRID_REG(card, j * 4 + 0xe0));
3709 for (i = 0; i < ALI_GLOBAL_REGS; i++) {
3710 if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A) ||
3711 (i * 4 == T4D_START_A))
3713 outl(ali_registers.global_regs[i], TRID_REG(card, i * 4));
3717 outl(ali_registers.global_regs[0x20], TRID_REG(card, T4D_START_A));
3718 //restore IRQ enable bits
3719 outl(ali_registers.global_regs[0x2c], TRID_REG(card, T4D_MISCINT));
3721 spin_unlock_irqrestore(&card->lock, flags);
3725 trident_suspend(struct pci_dev *dev, u32 unused)
3727 struct trident_card *card = pci_get_drvdata(dev);
3729 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
3730 ali_save_regs(card);
3736 trident_resume(struct pci_dev *dev)
3738 struct trident_card *card = pci_get_drvdata(dev);
3740 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
3741 ali_restore_regs(card);
3746 static struct trident_channel *
3747 ali_alloc_pcm_channel(struct trident_card *card)
3749 struct trident_pcm_bank *bank;
3752 bank = &card->banks[BANK_A];
3754 if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) &
3755 (ALI_SPDIF_OUT_CH_ENABLE)) {
3756 idx = ALI_SPDIF_OUT_CHANNEL;
3757 if (!(bank->bitmap & (1 << idx))) {
3758 struct trident_channel *channel = &bank->channels[idx];
3759 bank->bitmap |= 1 << idx;
3765 for (idx = ALI_PCM_OUT_CHANNEL_FIRST; idx <= ALI_PCM_OUT_CHANNEL_LAST;
3767 if (!(bank->bitmap & (1 << idx))) {
3768 struct trident_channel *channel = &bank->channels[idx];
3769 bank->bitmap |= 1 << idx;
3775 /* no more free channels avaliable */
3777 printk(KERN_ERR "ali: no more channels available on Bank A.\n");
3782 static struct trident_channel *
3783 ali_alloc_rec_pcm_channel(struct trident_card *card)
3785 struct trident_pcm_bank *bank;
3788 if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) & ALI_SPDIF_IN_SUPPORT)
3789 idx = ALI_SPDIF_IN_CHANNEL;
3791 idx = ALI_PCM_IN_CHANNEL;
3793 bank = &card->banks[BANK_A];
3795 if (!(bank->bitmap & (1 << idx))) {
3796 struct trident_channel *channel = &bank->channels[idx];
3797 bank->bitmap |= 1 << idx;
3802 /* no free recordable channels avaliable */
3804 printk(KERN_ERR "ali: no recordable channels available on Bank A.\n");
3810 ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate)
3812 unsigned char ch_st_sel;
3813 unsigned short status_rate;
3820 status_rate = 0x300;
3824 status_rate = 0x200;
3828 /* select spdif_out */
3829 ch_st_sel = inb(TRID_REG(card, ALI_SPDIF_CTRL)) & ALI_SPDIF_OUT_CH_STATUS;
3831 ch_st_sel |= 0x80; /* select right */
3832 outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
3833 outb(status_rate | 0x20, TRID_REG(card, ALI_SPDIF_CS + 2));
3835 ch_st_sel &= (~0x80); /* select left */
3836 outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
3837 outw(status_rate | 0x10, TRID_REG(card, ALI_SPDIF_CS + 2));
3841 ali_address_interrupt(struct trident_card *card)
3844 struct trident_state *state;
3845 u32 mask, channel_mask;
3847 mask = trident_get_interrupt_mask(card, 0);
3848 for (i = 0; i < NR_HW_CH; i++) {
3849 if ((state = card->states[i]) == NULL)
3851 channel = state->dmabuf.channel->num;
3852 if ((channel_mask = 1 << channel) & mask) {
3853 mask &= ~channel_mask;
3854 trident_ack_channel_interrupt(card, channel);
3856 state->dmabuf.update_flag |= ALI_ADDRESS_INT_UPDATE;
3857 trident_update_ptr(state);
3861 for (i = 0; i < NR_HW_CH; i++) {
3862 if (mask & (1 << i)) {
3863 printk("ali: spurious channel irq %d.\n", i);
3864 trident_ack_channel_interrupt(card, i);
3865 trident_stop_voice(card, i);
3866 trident_disable_voice_irq(card, i);
3872 /* Updating the values of counters of other_states' DMAs without lock
3873 protection is no harm because all DMAs of multi-channels and interrupt
3874 depend on a master state's DMA, and changing the counters of the master
3875 state DMA is protected by a spinlock.
3878 ali_write_5_1(struct trident_state *state, const char __user *buf,
3879 int cnt_for_multi_channel, unsigned int *copy_count,
3880 unsigned int *state_cnt)
3883 struct dmabuf *dmabuf = &state->dmabuf;
3884 struct dmabuf *dmabuf_temp;
3885 const char __user *buffer = buf;
3886 unsigned swptr, other_dma_nums, sample_s;
3887 unsigned int i, loop;
3890 sample_s = sample_size[dmabuf->fmt] >> 1;
3891 swptr = dmabuf->swptr;
3893 if ((i = state->multi_channels_adjust_count) > 0) {
3895 if (copy_from_user(dmabuf->rawbuf + swptr,
3898 seek_offset(swptr, buffer, cnt_for_multi_channel,
3899 sample_s, *copy_count);
3901 (*state_cnt) += sample_s;
3902 state->multi_channels_adjust_count++;
3904 i = i - (state->chans_num - other_dma_nums);
3905 for (; (i < other_dma_nums) && (cnt_for_multi_channel > 0); i++) {
3906 dmabuf_temp = &state->other_states[i]->dmabuf;
3907 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3910 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3911 sample_s, *copy_count);
3913 if (cnt_for_multi_channel == 0)
3914 state->multi_channels_adjust_count += i;
3916 if (cnt_for_multi_channel > 0) {
3917 loop = cnt_for_multi_channel / (state->chans_num * sample_s);
3918 for (i = 0; i < loop; i++) {
3919 if (copy_from_user(dmabuf->rawbuf + swptr, buffer,
3922 seek_offset(swptr, buffer, cnt_for_multi_channel,
3923 sample_s * 2, *copy_count);
3924 (*state_cnt) += (sample_s * 2);
3926 dmabuf_temp = &state->other_states[0]->dmabuf;
3927 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3930 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3931 sample_s, *copy_count);
3933 dmabuf_temp = &state->other_states[1]->dmabuf;
3934 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3937 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3938 sample_s, *copy_count);
3940 dmabuf_temp = &state->other_states[2]->dmabuf;
3941 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3944 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3945 sample_s, *copy_count);
3947 dmabuf_temp = &state->other_states[3]->dmabuf;
3948 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3951 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3952 sample_s, *copy_count);
3955 if (cnt_for_multi_channel > 0) {
3956 state->multi_channels_adjust_count = cnt_for_multi_channel / sample_s;
3958 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, sample_s))
3960 seek_offset(swptr, buffer, cnt_for_multi_channel,
3961 sample_s, *copy_count);
3962 (*state_cnt) += sample_s;
3964 if (cnt_for_multi_channel > 0) {
3965 if (copy_from_user(dmabuf->rawbuf + swptr,
3968 seek_offset(swptr, buffer, cnt_for_multi_channel,
3969 sample_s, *copy_count);
3970 (*state_cnt) += sample_s;
3972 if (cnt_for_multi_channel > 0) {
3973 int diff = state->chans_num - other_dma_nums;
3974 loop = state->multi_channels_adjust_count - diff;
3975 for (i = 0; i < loop; i++) {
3976 dmabuf_temp = &state->other_states[i]->dmabuf;
3977 if (copy_from_user(dmabuf_temp->rawbuf +
3981 seek_offset(dmabuf_temp->swptr, buffer,
3982 cnt_for_multi_channel,
3983 sample_s, *copy_count);
3988 state->multi_channels_adjust_count = 0;
3990 for (i = 0; i < other_dma_nums; i++) {
3991 dmabuf_temp = &state->other_states[i]->dmabuf;
3992 dmabuf_temp->swptr = dmabuf_temp->swptr % dmabuf_temp->dmasize;
3998 ali_free_other_states_resources(struct trident_state *state)
4001 struct trident_card *card = state->card;
4002 struct trident_state *s;
4003 unsigned other_states_count;
4005 other_states_count = state->chans_num - 2; /* except PCM L/R channels */
4006 for (i = 0; i < other_states_count; i++) {
4007 s = state->other_states[i];
4008 dealloc_dmabuf(&s->dmabuf, card->pci_dev);
4009 ali_disable_special_channel(s->card, s->dmabuf.channel->num);
4010 state->card->free_pcm_channel(s->card, s->dmabuf.channel->num);
4011 card->states[s->virt] = NULL;
4016 struct proc_dir_entry *res;
4018 ali_write_proc(struct file *file, const char __user *buffer, unsigned long count, void *data)
4020 struct trident_card *card = (struct trident_card *) data;
4021 unsigned long flags;
4028 if (get_user(c, buffer))
4031 spin_lock_irqsave(&card->lock, flags);
4034 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4035 ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
4038 ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
4042 ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
4043 ALI_SPDIF_OUT_NON_PCM);
4046 ali_disable_spdif_in(card); //default
4049 ali_setup_spdif_in(card);
4052 spin_unlock_irqrestore(&card->lock, flags);
4057 /* OSS /dev/mixer file operation methods */
4059 trident_open_mixdev(struct inode *inode, struct file *file)
4062 int minor = iminor(inode);
4063 struct trident_card *card = devs;
4065 for (card = devs; card != NULL; card = card->next)
4066 for (i = 0; i < NR_AC97; i++)
4067 if (card->ac97_codec[i] != NULL &&
4068 card->ac97_codec[i]->dev_mixer == minor)
4075 file->private_data = card->ac97_codec[i];
4077 return nonseekable_open(inode, file);
4081 trident_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4084 struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
4086 return codec->mixer_ioctl(codec, cmd, arg);
4089 static /*const */ struct file_operations trident_mixer_fops = {
4090 .owner = THIS_MODULE,
4091 .llseek = no_llseek,
4092 .ioctl = trident_ioctl_mixdev,
4093 .open = trident_open_mixdev,
4097 ali_reset_5451(struct trident_card *card)
4099 struct pci_dev *pci_dev = NULL;
4101 unsigned short wCount, wReg;
4103 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
4105 if (pci_dev == NULL)
4108 pci_read_config_dword(pci_dev, 0x7c, &dwVal);
4109 pci_write_config_dword(pci_dev, 0x7c, dwVal | 0x08000000);
4111 pci_read_config_dword(pci_dev, 0x7c, &dwVal);
4112 pci_write_config_dword(pci_dev, 0x7c, dwVal & 0xf7ffffff);
4115 pci_dev = card->pci_dev;
4116 if (pci_dev == NULL)
4119 pci_read_config_dword(pci_dev, 0x44, &dwVal);
4120 pci_write_config_dword(pci_dev, 0x44, dwVal | 0x000c0000);
4122 pci_read_config_dword(pci_dev, 0x44, &dwVal);
4123 pci_write_config_dword(pci_dev, 0x44, dwVal & 0xfffbffff);
4126 /* TODO: recognize if we have a PM capable codec and only do this */
4127 /* if the codec is PM capable */
4130 wReg = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
4131 if ((wReg & 0x000f) == 0x000f)
4135 /* This is non fatal if you have a non PM capable codec.. */
4139 /* AC97 codec initialisation. */
4140 static int __devinit
4141 trident_ac97_init(struct trident_card *card)
4144 unsigned long ready_2nd = 0;
4145 struct ac97_codec *codec;
4148 /* initialize controller side of AC link, and find out if secondary codes
4150 switch (card->pci_id) {
4151 case PCI_DEVICE_ID_ALI_5451:
4152 if (ali_reset_5451(card)) {
4153 printk(KERN_ERR "trident_ac97_init: error "
4154 "resetting 5451.\n");
4157 outl(0x80000001, TRID_REG(card, ALI_GLOBAL_CONTROL));
4158 outl(0x00000000, TRID_REG(card, T4D_AINTEN_A));
4159 outl(0xffffffff, TRID_REG(card, T4D_AINT_A));
4160 outl(0x00000000, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
4161 outb(0x10, TRID_REG(card, ALI_MPUR2));
4162 ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
4163 ready_2nd &= 0x3fff;
4164 outl(ready_2nd | PCMOUT | 0x8000, TRID_REG(card, ALI_SCTRL));
4165 ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
4166 ready_2nd &= SI_AC97_SECONDARY_READY;
4167 if (card->revision < ALI_5451_V02)
4170 case PCI_DEVICE_ID_SI_7018:
4171 /* disable AC97 GPIO interrupt */
4172 outl(0x00, TRID_REG(card, SI_AC97_GPIO));
4173 /* when power up the AC link is in cold reset mode so stop it */
4174 outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT | SECONDARY_ID,
4175 TRID_REG(card, SI_SERIAL_INTF_CTRL));
4176 /* it take a long time to recover from a cold reset */
4177 /* (especially when you have more than one codec) */
4179 ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
4180 ready_2nd &= SI_AC97_SECONDARY_READY;
4182 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
4184 outl(DX_AC97_PLAYBACK, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
4186 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
4187 /* enable AC97 Output Slot 3,4 (PCM Left/Right Playback) */
4188 outl(NX_AC97_PCM_OUTPUT, TRID_REG(card, NX_ACR0_AC97_COM_STAT));
4189 ready_2nd = inl(TRID_REG(card, NX_ACR0_AC97_COM_STAT));
4190 ready_2nd &= NX_AC97_SECONDARY_READY;
4192 case PCI_DEVICE_ID_INTERG_5050:
4193 /* disable AC97 GPIO interrupt */
4194 outl(0x00, TRID_REG(card, SI_AC97_GPIO));
4195 /* when power up, the AC link is in cold reset mode, so stop it */
4196 outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT,
4197 TRID_REG(card, SI_SERIAL_INTF_CTRL));
4198 /* it take a long time to recover from a cold reset (especially */
4199 /* when you have more than one codec) */
4201 ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
4202 ready_2nd &= SI_AC97_SECONDARY_READY;
4206 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4207 if ((codec = ac97_alloc_codec()) == NULL)
4210 /* initialize some basic codec information, other fields */
4211 /* will be filled in ac97_probe_codec */
4212 codec->private_data = card;
4213 codec->id = num_ac97;
4215 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4216 codec->codec_read = ali_ac97_read;
4217 codec->codec_write = ali_ac97_write;
4219 codec->codec_read = trident_ac97_get;
4220 codec->codec_write = trident_ac97_set;
4223 if (ac97_probe_codec(codec) == 0)
4226 codec->dev_mixer = register_sound_mixer(&trident_mixer_fops, -1);
4227 if (codec->dev_mixer < 0) {
4228 printk(KERN_ERR "trident: couldn't register mixer!\n");
4229 ac97_release_codec(codec);
4233 card->ac97_codec[num_ac97] = codec;
4235 /* if there is no secondary codec at all, don't probe any more */
4240 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4241 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4242 if (card->ac97_codec[num_ac97] == NULL)
4244 for (i = 0; i < 64; i++) {
4245 u16 reg = ali_ac97_get(card, num_ac97, i * 2);
4246 card->mixer_regs[i][num_ac97] = reg;
4250 return num_ac97 + 1;
4253 /* Gameport functions for the cards ADC gameport */
4255 static unsigned char
4256 trident_game_read(struct gameport *gameport)
4258 struct trident_card *card = gameport->driver;
4259 return inb(TRID_REG(card, T4D_GAME_LEG));
4263 trident_game_trigger(struct gameport *gameport)
4265 struct trident_card *card = gameport->driver;
4266 outb(0xff, TRID_REG(card, T4D_GAME_LEG));
4270 trident_game_cooked_read(struct gameport *gameport, int *axes, int *buttons)
4272 struct trident_card *card = gameport->driver;
4275 *buttons = (~inb(TRID_REG(card, T4D_GAME_LEG)) >> 4) & 0xf;
4277 for (i = 0; i < 4; i++) {
4278 axes[i] = inw(TRID_REG(card, T4D_GAME_AXD) + i * sizeof (u16));
4279 if (axes[i] == 0xffff)
4287 trident_game_open(struct gameport *gameport, int mode)
4289 struct trident_card *card = gameport->driver;
4292 case GAMEPORT_MODE_COOKED:
4293 outb(0x80, TRID_REG(card, T4D_GAME_CR));
4296 case GAMEPORT_MODE_RAW:
4297 outb(0x00, TRID_REG(card, T4D_GAME_CR));
4306 /* install the driver, we do not allocate hardware channel nor DMA buffer */
4307 /* now, they are defered until "ACCESS" time (in prog_dmabuf called by */
4308 /* open/read/write/ioctl/mmap) */
4309 static int __devinit
4310 trident_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
4312 unsigned long iobase;
4313 struct trident_card *card;
4318 struct pci_dev *pci_dev_m1533 = NULL;
4322 if (pci_enable_device(pci_dev))
4325 if (pci_dev->device == PCI_DEVICE_ID_ALI_5451)
4326 dma_mask = ALI_DMA_MASK;
4328 dma_mask = TRIDENT_DMA_MASK;
4329 if (pci_set_dma_mask(pci_dev, dma_mask)) {
4330 printk(KERN_ERR "trident: architecture does not support"
4331 " %s PCI busmaster DMA\n",
4332 pci_dev->device == PCI_DEVICE_ID_ALI_5451 ?
4333 "32-bit" : "30-bit");
4336 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
4338 if (pci_id->device == PCI_DEVICE_ID_INTERG_5050)
4339 iobase = pci_resource_start(pci_dev, 1);
4341 iobase = pci_resource_start(pci_dev, 0);
4343 if (!request_region(iobase, 256, card_names[pci_id->driver_data])) {
4344 printk(KERN_ERR "trident: can't allocate I/O space at "
4345 "0x%4.4lx\n", iobase);
4350 if ((card = kmalloc(sizeof(*card), GFP_KERNEL)) == NULL) {
4351 printk(KERN_ERR "trident: out of memory\n");
4352 goto out_release_region;
4354 memset(card, 0, sizeof (*card));
4356 init_timer(&card->timer);
4357 card->iobase = iobase;
4358 card->pci_dev = pci_dev;
4359 card->pci_id = pci_id->device;
4360 card->revision = revision;
4361 card->irq = pci_dev->irq;
4363 card->magic = TRIDENT_CARD_MAGIC;
4364 card->banks[BANK_A].addresses = &bank_a_addrs;
4365 card->banks[BANK_A].bitmap = 0UL;
4366 card->banks[BANK_B].addresses = &bank_b_addrs;
4367 card->banks[BANK_B].bitmap = 0UL;
4369 card->gameport.driver = card;
4370 card->gameport.fuzz = 64;
4371 card->gameport.read = trident_game_read;
4372 card->gameport.trigger = trident_game_trigger;
4373 card->gameport.cooked_read = trident_game_cooked_read;
4374 card->gameport.open = trident_game_open;
4376 init_MUTEX(&card->open_sem);
4377 spin_lock_init(&card->lock);
4378 init_timer(&card->timer);
4382 pci_set_master(pci_dev);
4384 printk(KERN_INFO "trident: %s found at IO 0x%04lx, IRQ %d\n",
4385 card_names[pci_id->driver_data], card->iobase, card->irq);
4387 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4388 /* ALi channel Management */
4389 card->alloc_pcm_channel = ali_alloc_pcm_channel;
4390 card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
4391 card->free_pcm_channel = ali_free_pcm_channel;
4393 card->address_interrupt = ali_address_interrupt;
4395 /* Added by Matt Wu 01-05-2001 for spdif in */
4396 card->multi_channel_use_count = 0;
4397 card->rec_channel_use_count = 0;
4399 /* ALi SPDIF OUT function */
4400 if (card->revision == ALI_5451_V02) {
4401 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4402 res = create_proc_entry("ALi5451", 0, NULL);
4404 res->write_proc = ali_write_proc;
4409 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4411 pci_dev_m1533 = pci_find_device(PCI_VENDOR_ID_AL,
4412 PCI_DEVICE_ID_AL_M1533,
4415 if (pci_dev_m1533 == NULL)
4417 pci_read_config_byte(pci_dev_m1533, 0x63, &bits);
4418 if (bits & (1 << 5))
4420 if (card->hwvolctl) {
4421 /* Clear m1533 pci cfg 78h bit 30 to zero, which makes
4422 GPIO11/12/13 work as ACGP_UP/DOWN/MUTE. */
4423 pci_read_config_byte(pci_dev_m1533, 0x7b, &bits);
4424 bits &= 0xbf; /*clear bit 6 */
4425 pci_write_config_byte(pci_dev_m1533, 0x7b, bits);
4427 } else if (card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
4428 card->alloc_pcm_channel = cyber_alloc_pcm_channel;
4429 card->alloc_rec_pcm_channel = cyber_alloc_pcm_channel;
4430 card->free_pcm_channel = cyber_free_pcm_channel;
4431 card->address_interrupt = cyber_address_interrupt;
4432 cyber_init_ritual(card);
4434 card->alloc_pcm_channel = trident_alloc_pcm_channel;
4435 card->alloc_rec_pcm_channel = trident_alloc_pcm_channel;
4436 card->free_pcm_channel = trident_free_pcm_channel;
4437 card->address_interrupt = trident_address_interrupt;
4442 if (request_irq(card->irq, &trident_interrupt, SA_SHIRQ,
4443 card_names[pci_id->driver_data], card)) {
4444 printk(KERN_ERR "trident: unable to allocate irq %d\n",
4448 /* register /dev/dsp */
4449 if ((card->dev_audio = register_sound_dsp(&trident_audio_fops, -1)) < 0) {
4450 printk(KERN_ERR "trident: couldn't register DSP device!\n");
4453 card->mixer_regs_ready = 0;
4454 /* initialize AC97 codec and register /dev/mixer */
4455 if (trident_ac97_init(card) <= 0) {
4456 /* unregister audio devices */
4457 for (i = 0; i < NR_AC97; i++) {
4458 if (card->ac97_codec[i] != NULL) {
4459 struct ac97_codec* codec = card->ac97_codec[i];
4460 unregister_sound_mixer(codec->dev_mixer);
4461 ac97_release_codec(codec);
4464 goto out_unregister_sound_dsp;
4466 card->mixer_regs_ready = 1;
4467 outl(0x00, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
4469 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4470 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4471 if (card->hwvolctl) {
4472 /* Enable GPIO IRQ (MISCINT bit 18h) */
4473 temp = inw(TRID_REG(card, T4D_MISCINT + 2));
4475 outw(temp, TRID_REG(card, T4D_MISCINT + 2));
4477 /* Enable H/W Volume Control GLOVAL CONTROL bit 0 */
4478 temp = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
4480 outw(temp, TRID_REG(card, ALI_GLOBAL_CONTROL));
4483 if (card->revision == ALI_5451_V02)
4484 ali_close_multi_channels();
4485 /* edited by HMSEO for GT sound */
4486 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
4489 extern struct hwrpb_struct *hwrpb;
4491 if ((hwrpb->sys_type) == 201) {
4492 printk(KERN_INFO "trident: Running on Alpha system "
4494 ac97_data = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
4495 ali_ac97_set(card, 0, AC97_POWER_CONTROL,
4496 ac97_data | ALI_EAPD_POWER_DOWN);
4499 #endif /* CONFIG_ALPHA_NAUTILUS || CONFIG_ALPHA_GENERIC */
4500 /* edited by HMSEO for GT sound */
4503 pci_set_drvdata(pci_dev, card);
4505 /* Enable Address Engine Interrupts */
4506 trident_enable_loop_interrupts(card);
4508 /* Register gameport */
4509 gameport_register_port(&card->gameport);
4514 out_unregister_sound_dsp:
4515 unregister_sound_dsp(card->dev_audio);
4517 free_irq(card->irq, card);
4520 remove_proc_entry("ALi5451", NULL);
4526 release_region(iobase, 256);
4530 static void __devexit
4531 trident_remove(struct pci_dev *pci_dev)
4534 struct trident_card *card = pci_get_drvdata(pci_dev);
4537 * Kill running timers before unload. We can't have them
4538 * going off after rmmod!
4541 del_timer_sync(&card->timer);
4543 /* ALi S/PDIF and Power Management */
4544 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4545 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4546 ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
4547 ali_disable_spdif_in(card);
4548 remove_proc_entry("ALi5451", NULL);
4551 /* Unregister gameport */
4552 gameport_unregister_port(&card->gameport);
4554 /* Kill interrupts, and SP/DIF */
4555 trident_disable_loop_interrupts(card);
4557 /* free hardware resources */
4558 free_irq(card->irq, card);
4559 release_region(card->iobase, 256);
4561 /* unregister audio devices */
4562 for (i = 0; i < NR_AC97; i++)
4563 if (card->ac97_codec[i] != NULL) {
4564 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
4565 ac97_release_codec(card->ac97_codec[i]);
4567 unregister_sound_dsp(card->dev_audio);
4571 pci_set_drvdata(pci_dev, NULL);
4574 MODULE_AUTHOR("Alan Cox, Aaron Holtzman, Ollie Lho, Ching Ling Lee, Muli Ben-Yehuda");
4575 MODULE_DESCRIPTION("Trident 4DWave/SiS 7018/ALi 5451 and Tvia/IGST CyberPro5050 PCI "
4577 MODULE_LICENSE("GPL");
4579 #define TRIDENT_MODULE_NAME "trident"
4581 static struct pci_driver trident_pci_driver = {
4582 .name = TRIDENT_MODULE_NAME,
4583 .id_table = trident_pci_tbl,
4584 .probe = trident_probe,
4585 .remove = __devexit_p(trident_remove),
4586 .suspend = trident_suspend,
4587 .resume = trident_resume
4591 trident_init_module(void)
4593 printk(KERN_INFO "Trident 4DWave/SiS 7018/ALi 5451,Tvia CyberPro "
4594 "5050 PCI Audio, version " DRIVER_VERSION ", " __TIME__ " "
4597 if (!pci_register_driver(&trident_pci_driver)) {
4598 pci_unregister_driver(&trident_pci_driver);
4605 trident_cleanup_module(void)
4607 pci_unregister_driver(&trident_pci_driver);
4610 module_init(trident_init_module);
4611 module_exit(trident_cleanup_module);