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>
220 #include <asm/hardirq.h>
224 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
225 #include <asm/hwrpb.h>
230 #define DRIVER_VERSION "0.14.10j-2.6"
232 /* magic numbers to protect our data structures */
233 #define TRIDENT_CARD_MAGIC 0x5072696E /* "Prin" */
234 #define TRIDENT_STATE_MAGIC 0x63657373 /* "cess" */
236 #define TRIDENT_DMA_MASK 0x3fffffff /* DMA buffer mask for pci_alloc_consist */
237 #define ALI_DMA_MASK 0x7fffffff /* ALI Tridents have 31-bit DMA. Wow. */
241 /* maximum number of AC97 codecs connected, AC97 2.0 defined 4, but 7018 and 4D-NX only
242 have 2 SDATA_IN lines (currently) */
245 /* minor number of /dev/swmodem (temporary, experimental) */
246 #define SND_DEV_SWMODEM 7
248 static const unsigned ali_multi_channels_5_1[] = {
249 /*ALI_SURR_LEFT_CHANNEL, ALI_SURR_RIGHT_CHANNEL, */
252 ALI_SURR_LEFT_CHANNEL,
253 ALI_SURR_RIGHT_CHANNEL
256 static const unsigned sample_size[] = { 1, 2, 2, 4 };
257 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
259 static const char invalid_magic[] = KERN_CRIT "trident: invalid magic value in %s\n";
269 static char *card_names[] = {
272 "SiS 7018 PCI Audio",
273 "ALi Audio Accelerator",
274 "Tvia/IGST CyberPro 5050"
277 static struct pci_device_id trident_pci_tbl[] = {
278 {PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_DX,
279 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TRIDENT_4D_DX},
280 {PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_NX,
281 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TRIDENT_4D_NX},
282 {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7018,
283 PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_7018},
284 {PCI_VENDOR_ID_ALI, PCI_DEVICE_ID_ALI_5451,
285 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ALI_5451},
286 {PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_5050,
287 PCI_ANY_ID, PCI_ANY_ID, 0, 0, CYBER5050},
291 MODULE_DEVICE_TABLE(pci, trident_pci_tbl);
293 /* "software" or virtual channel, an instance of opened /dev/dsp */
294 struct trident_state {
296 struct trident_card *card; /* Card info */
301 /* virtual channel number */
305 /* wave sample stuff */
307 unsigned char fmt, enable;
309 /* hardware channel */
310 struct trident_channel *channel;
312 /* OSS buffer management stuff */
314 dma_addr_t dma_handle;
319 /* our buffer acts like a circular ring */
320 unsigned hwptr; /* where dma last started, updated by update_ptr */
321 unsigned swptr; /* where driver last clear/filled, updated by read/write */
322 int count; /* bytes to be comsumed or been generated by dma machine */
323 unsigned total_bytes; /* total bytes dmaed by hardware */
325 unsigned error; /* number of over/underruns */
326 /* put process on wait queue when no more space in buffer */
327 wait_queue_head_t wait;
329 /* redundant, but makes calculations easier */
332 unsigned fragsamples;
337 unsigned endcleared:1;
338 unsigned update_flag;
339 unsigned ossfragshift;
341 unsigned subdivision;
346 struct trident_state *other_states[4];
347 int multi_channels_adjust_count;
349 unsigned long fmt_flag;
350 /* Guard against mmap/write/read races */
351 struct semaphore sem;
355 /* hardware channels */
356 struct trident_channel {
357 int num; /* channel number */
358 u32 lba; /* Loop Begine Address, where dma buffer starts */
359 u32 eso; /* End Sample Offset, wehre dma buffer ends */
360 /* (in the unit of samples) */
361 u32 delta; /* delta value, sample rate / 48k for playback, */
362 /* 48k/sample rate for recording */
363 u16 attribute; /* control where PCM data go and come */
365 u32 control; /* signed/unsigned, 8/16 bits, mono/stereo */
368 struct trident_pcm_bank_address {
375 static struct trident_pcm_bank_address bank_a_addrs = {
382 static struct trident_pcm_bank_address bank_b_addrs = {
389 struct trident_pcm_bank {
390 /* register addresses to control bank operations */
391 struct trident_pcm_bank_address *addresses;
392 /* each bank has 32 channels */
393 u32 bitmap; /* channel allocation bitmap */
394 struct trident_channel channels[32];
397 struct trident_card {
400 /* We keep trident cards in a linked list */
401 struct trident_card *next;
403 /* single open lock mechanism, only used for recording */
404 struct semaphore open_sem;
406 /* The trident has a certain amount of cross channel interaction
407 so we use a single per card lock */
410 /* PCI device stuff */
411 struct pci_dev *pci_dev;
415 /* soundcore stuff */
418 /* structures for abstraction of hardware facilities, codecs, */
419 /* banks and channels */
420 struct ac97_codec *ac97_codec[NR_AC97];
421 struct trident_pcm_bank banks[NR_BANKS];
422 struct trident_state *states[NR_HW_CH];
424 /* hardware resources */
425 unsigned long iobase;
428 /* Function support */
429 struct trident_channel *(*alloc_pcm_channel) (struct trident_card *);
430 struct trident_channel *(*alloc_rec_pcm_channel) (struct trident_card *);
431 void (*free_pcm_channel) (struct trident_card *, unsigned int chan);
432 void (*address_interrupt) (struct trident_card *);
434 /* Added by Matt Wu 01-05-2001 for spdif in */
435 int multi_channel_use_count;
436 int rec_channel_use_count;
437 u16 mixer_regs[64][NR_AC97]; /* Made card local by Alan */
438 int mixer_regs_ready;
440 /* Added for hardware volume control */
442 struct timer_list timer;
444 /* Game port support */
445 struct gameport gameport;
453 /* table to map from CHANNELMASK to channel attribute for SiS 7018 */
454 static u16 mask2attr[] = {
455 PCM_LR, PCM_LR, SURR_LR, CENTER_LFE,
456 HSET, MIC, MODEM_LINE1, MODEM_LINE2,
460 /* table to map from channel attribute to CHANNELMASK for SiS 7018 */
461 static int attr2mask[] = {
462 DSP_BIND_MODEM1, DSP_BIND_MODEM2, DSP_BIND_FRONT, DSP_BIND_HANDSET,
463 DSP_BIND_I2S, DSP_BIND_CENTER_LFE, DSP_BIND_SURR, DSP_BIND_SPDIF
466 /* Added by Matt Wu 01-05-2001 for spdif in */
467 static int ali_close_multi_channels(void);
468 static void ali_delay(struct trident_card *card, int interval);
469 static void ali_detect_spdif_rate(struct trident_card *card);
471 static void ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val);
472 static u16 ali_ac97_read(struct ac97_codec *codec, u8 reg);
474 static struct trident_card *devs;
476 static void trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val);
477 static u16 trident_ac97_get(struct ac97_codec *codec, u8 reg);
479 static int trident_open_mixdev(struct inode *inode, struct file *file);
480 static int trident_ioctl_mixdev(struct inode *inode, struct file *file,
481 unsigned int cmd, unsigned long arg);
483 static void ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val);
484 static u16 ali_ac97_get(struct trident_card *card, int secondary, u8 reg);
485 static void ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate);
486 static void ali_enable_special_channel(struct trident_state *stat);
487 static struct trident_channel *ali_alloc_rec_pcm_channel(struct trident_card *card);
488 static struct trident_channel *ali_alloc_pcm_channel(struct trident_card *card);
489 static void ali_restore_regs(struct trident_card *card);
490 static void ali_save_regs(struct trident_card *card);
491 static int trident_suspend(struct pci_dev *dev, u32 unused);
492 static int trident_resume(struct pci_dev *dev);
493 static void ali_free_pcm_channel(struct trident_card *card, unsigned int channel);
494 static int ali_setup_multi_channels(struct trident_card *card, int chan_nums);
495 static unsigned int ali_get_spdif_in_rate(struct trident_card *card);
496 static void ali_setup_spdif_in(struct trident_card *card);
497 static void ali_disable_spdif_in(struct trident_card *card);
498 static void ali_disable_special_channel(struct trident_card *card, int ch);
499 static void ali_setup_spdif_out(struct trident_card *card, int flag);
500 static int ali_write_5_1(struct trident_state *state,
501 const char __user *buffer,
502 int cnt_for_multi_channel, unsigned int *copy_count,
503 unsigned int *state_cnt);
504 static int ali_allocate_other_states_resources(struct trident_state *state,
506 static void ali_free_other_states_resources(struct trident_state *state);
508 /* save registers for ALi Power Management */
509 static struct ali_saved_registers {
510 unsigned long global_regs[ALI_GLOBAL_REGS];
511 unsigned long channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS];
512 unsigned mixer_regs[ALI_MIXER_REGS];
515 #define seek_offset(dma_ptr, buffer, cnt, offset, copy_count) do { \
516 (dma_ptr) += (offset); \
517 (buffer) += (offset); \
519 (copy_count) += (offset); \
522 static inline int lock_set_fmt(struct trident_state* state)
524 if (test_and_set_bit(0, &state->fmt_flag))
530 static inline void unlock_set_fmt(struct trident_state* state)
532 clear_bit(0, &state->fmt_flag);
536 trident_enable_loop_interrupts(struct trident_card *card)
540 global_control = inl(TRID_REG(card, T4D_LFO_GC_CIR));
542 switch (card->pci_id) {
543 case PCI_DEVICE_ID_SI_7018:
544 global_control |= (ENDLP_IE | MIDLP_IE | BANK_B_EN);
546 case PCI_DEVICE_ID_ALI_5451:
547 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
548 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
549 case PCI_DEVICE_ID_INTERG_5050:
550 global_control |= (ENDLP_IE | MIDLP_IE);
556 outl(global_control, TRID_REG(card, T4D_LFO_GC_CIR));
558 pr_debug("trident: Enable Loop Interrupts, globctl = 0x%08X\n",
559 inl(TRID_REG(card, T4D_LFO_GC_CIR)));
565 trident_disable_loop_interrupts(struct trident_card *card)
569 global_control = inl(TRID_REG(card, T4D_LFO_GC_CIR));
570 global_control &= ~(ENDLP_IE | MIDLP_IE);
571 outl(global_control, TRID_REG(card, T4D_LFO_GC_CIR));
573 pr_debug("trident: Disabled Loop Interrupts, globctl = 0x%08X\n",
580 trident_enable_voice_irq(struct trident_card *card, unsigned int channel)
582 unsigned int mask = 1 << (channel & 0x1f);
583 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
584 u32 reg, addr = bank->addresses->aint_en;
586 reg = inl(TRID_REG(card, addr));
588 outl(reg, TRID_REG(card, addr));
591 reg = inl(TRID_REG(card, addr));
592 pr_debug("trident: enabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
593 channel, addr == T4D_AINTEN_B ? "AINTEN_B" : "AINTEN_A",
599 trident_disable_voice_irq(struct trident_card *card, unsigned int channel)
601 unsigned int mask = 1 << (channel & 0x1f);
602 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
603 u32 reg, addr = bank->addresses->aint_en;
605 reg = inl(TRID_REG(card, addr));
607 outl(reg, TRID_REG(card, addr));
609 /* Ack the channel in case the interrupt was set before we disable it. */
610 outl(mask, TRID_REG(card, bank->addresses->aint));
613 reg = inl(TRID_REG(card, addr));
614 pr_debug("trident: disabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
615 channel, addr == T4D_AINTEN_B ? "AINTEN_B" : "AINTEN_A",
621 trident_start_voice(struct trident_card *card, unsigned int channel)
623 unsigned int mask = 1 << (channel & 0x1f);
624 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
625 u32 addr = bank->addresses->start;
631 outl(mask, TRID_REG(card, addr));
634 reg = inl(TRID_REG(card, addr));
635 pr_debug("trident: start voice on channel %d, %s = 0x%08x(addr:%X)\n",
636 channel, addr == T4D_START_B ? "START_B" : "START_A",
642 trident_stop_voice(struct trident_card *card, unsigned int channel)
644 unsigned int mask = 1 << (channel & 0x1f);
645 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
646 u32 addr = bank->addresses->stop;
652 outl(mask, TRID_REG(card, addr));
655 reg = inl(TRID_REG(card, addr));
656 pr_debug("trident: stop voice on channel %d, %s = 0x%08x(addr:%X)\n",
657 channel, addr == T4D_STOP_B ? "STOP_B" : "STOP_A",
663 trident_get_interrupt_mask(struct trident_card *card, unsigned int channel)
665 struct trident_pcm_bank *bank = &card->banks[channel];
666 u32 addr = bank->addresses->aint;
667 return inl(TRID_REG(card, addr));
671 trident_check_channel_interrupt(struct trident_card *card, unsigned int channel)
673 unsigned int mask = 1 << (channel & 0x1f);
674 u32 reg = trident_get_interrupt_mask(card, channel >> 5);
678 pr_debug("trident: channel %d has interrupt, %s = 0x%08x\n",
679 channel, reg == T4D_AINT_B ? "AINT_B" : "AINT_A",
682 return (reg & mask) ? 1 : 0;
686 trident_ack_channel_interrupt(struct trident_card *card, unsigned int channel)
688 unsigned int mask = 1 << (channel & 0x1f);
689 struct trident_pcm_bank *bank = &card->banks[channel >> 5];
690 u32 reg, addr = bank->addresses->aint;
692 reg = inl(TRID_REG(card, addr));
694 outl(reg, TRID_REG(card, addr));
697 reg = inl(TRID_REG(card, T4D_AINT_B));
698 pr_debug("trident: Ack channel %d interrupt, AINT_B = 0x%08x\n",
703 static struct trident_channel *
704 trident_alloc_pcm_channel(struct trident_card *card)
706 struct trident_pcm_bank *bank;
709 bank = &card->banks[BANK_B];
711 for (idx = 31; idx >= 0; idx--) {
712 if (!(bank->bitmap & (1 << idx))) {
713 struct trident_channel *channel = &bank->channels[idx];
714 bank->bitmap |= 1 << idx;
715 channel->num = idx + 32;
720 /* no more free channels available */
721 printk(KERN_ERR "trident: no more channels available on Bank B.\n");
726 trident_free_pcm_channel(struct trident_card *card, unsigned int channel)
731 if (channel < 31 || channel > 63)
734 if (card->pci_id == PCI_DEVICE_ID_TRIDENT_4DWAVE_DX ||
735 card->pci_id == PCI_DEVICE_ID_TRIDENT_4DWAVE_NX) {
736 b = inb(TRID_REG(card, T4D_REC_CH));
737 if ((b & ~0x80) == channel)
738 outb(0x0, TRID_REG(card, T4D_REC_CH));
742 channel = channel & 0x1f;
744 card->banks[bank].bitmap &= ~(1 << (channel));
747 static struct trident_channel *
748 cyber_alloc_pcm_channel(struct trident_card *card)
750 struct trident_pcm_bank *bank;
753 /* The cyberpro 5050 has only 32 voices and one bank */
754 /* .. at least they are not documented (if you want to call that
755 * crap documentation), perhaps broken ? */
757 bank = &card->banks[BANK_A];
759 for (idx = 31; idx >= 0; idx--) {
760 if (!(bank->bitmap & (1 << idx))) {
761 struct trident_channel *channel = &bank->channels[idx];
762 bank->bitmap |= 1 << idx;
768 /* no more free channels available */
769 printk(KERN_ERR "cyberpro5050: no more channels available on Bank A.\n");
774 cyber_free_pcm_channel(struct trident_card *card, unsigned int channel)
778 card->banks[BANK_A].bitmap &= ~(1 << (channel));
782 cyber_outidx(int port, int idx, int data)
785 outb(data, port + 1);
789 cyber_inidx(int port, int idx)
792 return inb(port + 1);
796 cyber_init_ritual(struct trident_card *card)
798 /* some black magic, taken from SDK samples */
799 /* remove this and nothing will work */
805 * Keep interrupts off for the configure - we don't want to
806 * clash with another cyberpro config event
809 spin_lock_irqsave(&card->lock, flags);
810 portDat = cyber_inidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE);
811 /* enable, if it was disabled */
812 if ((portDat & CYBER_BMSK_AUENZ) != CYBER_BMSK_AUENZ_ENABLE) {
813 printk(KERN_INFO "cyberpro5050: enabling audio controller\n");
814 cyber_outidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE,
815 portDat | CYBER_BMSK_AUENZ_ENABLE);
816 /* check again if hardware is enabled now */
817 portDat = cyber_inidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE);
819 if ((portDat & CYBER_BMSK_AUENZ) != CYBER_BMSK_AUENZ_ENABLE) {
820 printk(KERN_ERR "cyberpro5050: initAudioAccess: no success\n");
823 cyber_outidx(CYBER_PORT_AUDIO, CYBER_IDX_IRQ_ENABLE,
824 CYBER_BMSK_AUDIO_INT_ENABLE);
825 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x01);
826 cyber_outidx(CYBER_PORT_AUDIO, 0xba, 0x20);
827 cyber_outidx(CYBER_PORT_AUDIO, 0xbb, 0x08);
828 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x02);
829 cyber_outidx(CYBER_PORT_AUDIO, 0xb3, 0x06);
830 cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x00);
832 spin_unlock_irqrestore(&card->lock, flags);
836 /* called with spin lock held */
839 trident_load_channel_registers(struct trident_card *card, u32 * data,
840 unsigned int channel)
847 /* select hardware channel to write */
848 outb(channel, TRID_REG(card, T4D_LFO_GC_CIR));
850 /* Output the channel registers, but don't write register
851 three to an ALI chip. */
852 for (i = 0; i < CHANNEL_REGS; i++) {
853 if (i == 3 && card->pci_id == PCI_DEVICE_ID_ALI_5451)
855 outl(data[i], TRID_REG(card, CHANNEL_START + 4 * i));
857 if (card->pci_id == PCI_DEVICE_ID_ALI_5451 ||
858 card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
859 outl(ALI_EMOD_Still, TRID_REG(card, ALI_EBUF1));
860 outl(ALI_EMOD_Still, TRID_REG(card, ALI_EBUF2));
865 /* called with spin lock held */
867 trident_write_voice_regs(struct trident_state *state)
869 unsigned int data[CHANNEL_REGS + 1];
870 struct trident_channel *channel;
872 channel = state->dmabuf.channel;
874 data[1] = channel->lba;
875 data[4] = channel->control;
877 switch (state->card->pci_id) {
878 case PCI_DEVICE_ID_ALI_5451:
879 data[0] = 0; /* Current Sample Offset */
880 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
883 case PCI_DEVICE_ID_SI_7018:
884 case PCI_DEVICE_ID_INTERG_5050:
885 data[0] = 0; /* Current Sample Offset */
886 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
887 data[3] = (channel->attribute << 16) | (channel->fm_vol & 0xffff);
889 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
890 data[0] = 0; /* Current Sample Offset */
891 data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
892 data[3] = channel->fm_vol & 0xffff;
894 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
895 data[0] = (channel->delta << 24);
896 data[2] = ((channel->delta << 16) & 0xff000000) |
897 (channel->eso & 0x00ffffff);
898 data[3] = channel->fm_vol & 0xffff;
904 return trident_load_channel_registers(state->card, data, channel->num);
908 compute_rate_play(u32 rate)
911 /* We special case 44100 and 8000 since rounding with the equation
912 does not give us an accurate enough value. For 11025 and 22050
913 the equation gives us the best answer. All other frequencies will
914 also use the equation. JDW */
917 else if (rate == 8000)
919 else if (rate == 48000)
922 delta = (((rate << 12) + rate) / 48000) & 0x0000ffff;
927 compute_rate_rec(u32 rate)
933 else if (rate == 8000)
935 else if (rate == 48000)
938 delta = ((48000 << 12) / rate) & 0x0000ffff;
943 /* set playback sample rate */
945 trident_set_dac_rate(struct trident_state *state, unsigned int rate)
947 struct dmabuf *dmabuf = &state->dmabuf;
955 dmabuf->channel->delta = compute_rate_play(rate);
957 trident_write_voice_regs(state);
959 pr_debug("trident: called trident_set_dac_rate : rate = %d\n", rate);
964 /* set recording sample rate */
966 trident_set_adc_rate(struct trident_state *state, unsigned int rate)
968 struct dmabuf *dmabuf = &state->dmabuf;
976 dmabuf->channel->delta = compute_rate_rec(rate);
978 trident_write_voice_regs(state);
980 pr_debug("trident: called trident_set_adc_rate : rate = %d\n", rate);
985 /* prepare channel attributes for playback */
987 trident_play_setup(struct trident_state *state)
989 struct dmabuf *dmabuf = &state->dmabuf;
990 struct trident_channel *channel = dmabuf->channel;
992 channel->lba = dmabuf->dma_handle;
993 channel->delta = compute_rate_play(dmabuf->rate);
995 channel->eso = dmabuf->dmasize >> sample_shift[dmabuf->fmt];
998 if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
999 channel->attribute = 0;
1000 if (state->card->pci_id == PCI_DEVICE_ID_ALI_5451) {
1001 if ((channel->num == ALI_SPDIF_IN_CHANNEL) ||
1002 (channel->num == ALI_PCM_IN_CHANNEL))
1003 ali_disable_special_channel(state->card, channel->num);
1004 else if ((inl(TRID_REG(state->card, ALI_GLOBAL_CONTROL))
1005 & ALI_SPDIF_OUT_CH_ENABLE)
1006 && (channel->num == ALI_SPDIF_OUT_CHANNEL)) {
1007 ali_set_spdif_out_rate(state->card,
1008 state->dmabuf.rate);
1009 state->dmabuf.channel->delta = 0x1000;
1014 channel->fm_vol = 0x0;
1016 channel->control = CHANNEL_LOOP;
1017 if (dmabuf->fmt & TRIDENT_FMT_16BIT) {
1019 channel->control |= CHANNEL_16BITS;
1021 channel->control |= CHANNEL_SIGNED;
1023 if (dmabuf->fmt & TRIDENT_FMT_STEREO)
1025 channel->control |= CHANNEL_STEREO;
1027 pr_debug("trident: trident_play_setup, LBA = 0x%08x, Delta = 0x%08x, "
1028 "ESO = 0x%08x, Control = 0x%08x\n", channel->lba,
1029 channel->delta, channel->eso, channel->control);
1031 trident_write_voice_regs(state);
1034 /* prepare channel attributes for recording */
1036 trident_rec_setup(struct trident_state *state)
1041 struct trident_card *card = state->card;
1042 struct dmabuf *dmabuf = &state->dmabuf;
1043 struct trident_channel *channel = dmabuf->channel;
1046 /* Enable AC-97 ADC (capture) */
1047 switch (card->pci_id) {
1048 case PCI_DEVICE_ID_ALI_5451:
1049 ali_enable_special_channel(state);
1051 case PCI_DEVICE_ID_SI_7018:
1052 /* for 7018, the ac97 is always in playback/record (duplex) mode */
1054 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
1055 w = inb(TRID_REG(card, DX_ACR2_AC97_COM_STAT));
1056 outb(w | 0x48, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
1057 /* enable and set record channel */
1058 outb(0x80 | channel->num, TRID_REG(card, T4D_REC_CH));
1060 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
1061 w = inw(TRID_REG(card, T4D_MISCINT));
1062 outw(w | 0x1000, TRID_REG(card, T4D_MISCINT));
1063 /* enable and set record channel */
1064 outb(0x80 | channel->num, TRID_REG(card, T4D_REC_CH));
1066 case PCI_DEVICE_ID_INTERG_5050:
1067 /* don't know yet, using special channel 22 in GC1(0xd4)? */
1073 channel->lba = dmabuf->dma_handle;
1074 channel->delta = compute_rate_rec(dmabuf->rate);
1075 if ((card->pci_id == PCI_DEVICE_ID_ALI_5451) &&
1076 (channel->num == ALI_SPDIF_IN_CHANNEL)) {
1077 rate = ali_get_spdif_in_rate(card);
1079 printk(KERN_WARNING "trident: ALi 5451 "
1080 "S/PDIF input setup error!\n");
1083 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
1085 outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
1086 printk(KERN_WARNING "trident: cleared ALi "
1087 "5451 S/PDIF parity error flag.\n");
1091 channel->delta = ((rate << 12) / dmabuf->rate) & 0x0000ffff;
1094 channel->eso = dmabuf->dmasize >> sample_shift[dmabuf->fmt];
1097 if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
1098 channel->attribute = 0;
1101 channel->fm_vol = 0x0;
1103 channel->control = CHANNEL_LOOP;
1104 if (dmabuf->fmt & TRIDENT_FMT_16BIT) {
1106 channel->control |= CHANNEL_16BITS;
1108 channel->control |= CHANNEL_SIGNED;
1110 if (dmabuf->fmt & TRIDENT_FMT_STEREO)
1112 channel->control |= CHANNEL_STEREO;
1114 pr_debug("trident: trident_rec_setup, LBA = 0x%08x, Delat = 0x%08x, "
1115 "ESO = 0x%08x, Control = 0x%08x\n", channel->lba,
1116 channel->delta, channel->eso, channel->control);
1118 trident_write_voice_regs(state);
1121 /* get current playback/recording dma buffer pointer (byte offset from LBA),
1122 called with spinlock held! */
1123 static inline unsigned
1124 trident_get_dma_addr(struct trident_state *state)
1126 struct dmabuf *dmabuf = &state->dmabuf;
1129 if (!dmabuf->enable)
1132 outb(dmabuf->channel->num, TRID_REG(state->card, T4D_LFO_GC_CIR));
1134 switch (state->card->pci_id) {
1135 case PCI_DEVICE_ID_ALI_5451:
1136 case PCI_DEVICE_ID_SI_7018:
1137 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
1138 case PCI_DEVICE_ID_INTERG_5050:
1139 /* 16 bits ESO, CSO for 7018 and DX */
1140 cso = inw(TRID_REG(state->card, CH_DX_CSO_ALPHA_FMS + 2));
1142 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
1143 /* 24 bits ESO, CSO for NX */
1144 cso = inl(TRID_REG(state->card, CH_NX_DELTA_CSO)) & 0x00ffffff;
1150 pr_debug("trident: trident_get_dma_addr: chip reported channel: %d, "
1151 "cso = 0x%04x\n", dmabuf->channel->num, cso);
1153 /* ESO and CSO are in units of Samples, convert to byte offset */
1154 cso <<= sample_shift[dmabuf->fmt];
1156 return (cso % dmabuf->dmasize);
1159 /* Stop recording (lock held) */
1161 __stop_adc(struct trident_state *state)
1163 struct dmabuf *dmabuf = &state->dmabuf;
1164 unsigned int chan_num = dmabuf->channel->num;
1165 struct trident_card *card = state->card;
1167 dmabuf->enable &= ~ADC_RUNNING;
1168 trident_stop_voice(card, chan_num);
1169 trident_disable_voice_irq(card, chan_num);
1173 stop_adc(struct trident_state *state)
1175 struct trident_card *card = state->card;
1176 unsigned long flags;
1178 spin_lock_irqsave(&card->lock, flags);
1180 spin_unlock_irqrestore(&card->lock, flags);
1184 start_adc(struct trident_state *state)
1186 struct dmabuf *dmabuf = &state->dmabuf;
1187 unsigned int chan_num = dmabuf->channel->num;
1188 struct trident_card *card = state->card;
1189 unsigned long flags;
1191 spin_lock_irqsave(&card->lock, flags);
1192 if ((dmabuf->mapped ||
1193 dmabuf->count < (signed) dmabuf->dmasize) &&
1195 dmabuf->enable |= ADC_RUNNING;
1196 trident_enable_voice_irq(card, chan_num);
1197 trident_start_voice(card, chan_num);
1199 spin_unlock_irqrestore(&card->lock, flags);
1202 /* stop playback (lock held) */
1204 __stop_dac(struct trident_state *state)
1206 struct dmabuf *dmabuf = &state->dmabuf;
1207 unsigned int chan_num = dmabuf->channel->num;
1208 struct trident_card *card = state->card;
1210 dmabuf->enable &= ~DAC_RUNNING;
1211 trident_stop_voice(card, chan_num);
1212 if (state->chans_num == 6) {
1213 trident_stop_voice(card, state->other_states[0]->
1214 dmabuf.channel->num);
1215 trident_stop_voice(card, state->other_states[1]->
1216 dmabuf.channel->num);
1217 trident_stop_voice(card, state->other_states[2]->
1218 dmabuf.channel->num);
1219 trident_stop_voice(card, state->other_states[3]->
1220 dmabuf.channel->num);
1222 trident_disable_voice_irq(card, chan_num);
1226 stop_dac(struct trident_state *state)
1228 struct trident_card *card = state->card;
1229 unsigned long flags;
1231 spin_lock_irqsave(&card->lock, flags);
1233 spin_unlock_irqrestore(&card->lock, flags);
1237 start_dac(struct trident_state *state)
1239 struct dmabuf *dmabuf = &state->dmabuf;
1240 unsigned int chan_num = dmabuf->channel->num;
1241 struct trident_card *card = state->card;
1242 unsigned long flags;
1244 spin_lock_irqsave(&card->lock, flags);
1245 if ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) {
1246 dmabuf->enable |= DAC_RUNNING;
1247 trident_enable_voice_irq(card, chan_num);
1248 trident_start_voice(card, chan_num);
1249 if (state->chans_num == 6) {
1250 trident_start_voice(card, state->other_states[0]->
1251 dmabuf.channel->num);
1252 trident_start_voice(card, state->other_states[1]->
1253 dmabuf.channel->num);
1254 trident_start_voice(card, state->other_states[2]->
1255 dmabuf.channel->num);
1256 trident_start_voice(card, state->other_states[3]->
1257 dmabuf.channel->num);
1260 spin_unlock_irqrestore(&card->lock, flags);
1263 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
1264 #define DMABUF_MINORDER 1
1266 /* alloc a DMA buffer of with a buffer of this order */
1268 alloc_dmabuf(struct dmabuf *dmabuf, struct pci_dev *pci_dev, int order)
1270 void *rawbuf = NULL;
1271 struct page *page, *pend;
1273 if (!(rawbuf = pci_alloc_consistent(pci_dev, PAGE_SIZE << order,
1274 &dmabuf->dma_handle)))
1277 pr_debug("trident: allocated %ld (order = %d) bytes at %p\n",
1278 PAGE_SIZE << order, order, rawbuf);
1280 dmabuf->ready = dmabuf->mapped = 0;
1281 dmabuf->rawbuf = rawbuf;
1282 dmabuf->buforder = order;
1284 /* now mark the pages as reserved; otherwise */
1285 /* remap_page_range doesn't do what we want */
1286 pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
1287 for (page = virt_to_page(rawbuf); page <= pend; page++)
1288 SetPageReserved(page);
1293 /* allocate the main DMA buffer, playback and recording buffer should be */
1294 /* allocated separately */
1296 alloc_main_dmabuf(struct trident_state *state)
1298 struct dmabuf *dmabuf = &state->dmabuf;
1302 /* alloc as big a chunk as we can, FIXME: is this necessary ?? */
1303 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
1304 if (!(ret = alloc_dmabuf(dmabuf, state->card->pci_dev, order)))
1306 /* else try again */
1311 /* deallocate a DMA buffer */
1313 dealloc_dmabuf(struct dmabuf *dmabuf, struct pci_dev *pci_dev)
1315 struct page *page, *pend;
1317 if (dmabuf->rawbuf) {
1318 /* undo marking the pages as reserved */
1319 pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
1320 for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
1321 ClearPageReserved(page);
1322 pci_free_consistent(pci_dev, PAGE_SIZE << dmabuf->buforder,
1323 dmabuf->rawbuf, dmabuf->dma_handle);
1324 dmabuf->rawbuf = NULL;
1326 dmabuf->mapped = dmabuf->ready = 0;
1330 prog_dmabuf(struct trident_state *state, enum dmabuf_mode rec)
1332 struct dmabuf *dmabuf = &state->dmabuf;
1333 unsigned bytepersec;
1334 struct trident_state *s = state;
1335 unsigned bufsize, dma_nums;
1336 unsigned long flags;
1339 if ((ret = lock_set_fmt(state)) < 0)
1342 if (state->chans_num == 6)
1347 for (i = 0; i < dma_nums; i++) {
1349 s = state->other_states[i - 1];
1350 dmabuf = &s->dmabuf;
1351 dmabuf->fmt = state->dmabuf.fmt;
1352 dmabuf->rate = state->dmabuf.rate;
1355 spin_lock_irqsave(&s->card->lock, flags);
1356 dmabuf->hwptr = dmabuf->swptr = dmabuf->total_bytes = 0;
1357 dmabuf->count = dmabuf->error = 0;
1358 spin_unlock_irqrestore(&s->card->lock, flags);
1360 /* allocate DMA buffer if not allocated yet */
1361 if (!dmabuf->rawbuf) {
1363 if ((ret = alloc_main_dmabuf(state))) {
1364 unlock_set_fmt(state);
1369 order = state->dmabuf.buforder - 1;
1370 if (order >= DMABUF_MINORDER) {
1371 ret = alloc_dmabuf(dmabuf,
1372 state->card->pci_dev,
1376 /* release the main DMA buffer */
1377 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
1378 /* release the auxiliary DMA buffers */
1379 for (i -= 2; i >= 0; i--)
1380 dealloc_dmabuf(&state->other_states[i]->dmabuf,
1381 state->card->pci_dev);
1382 unlock_set_fmt(state);
1387 /* FIXME: figure out all this OSS fragment stuff */
1388 bytepersec = dmabuf->rate << sample_shift[dmabuf->fmt];
1389 bufsize = PAGE_SIZE << dmabuf->buforder;
1390 if (dmabuf->ossfragshift) {
1391 if ((1000 << dmabuf->ossfragshift) < bytepersec)
1392 dmabuf->fragshift = ld2(bytepersec / 1000);
1394 dmabuf->fragshift = dmabuf->ossfragshift;
1396 /* lets hand out reasonable big ass buffers by default */
1397 dmabuf->fragshift = (dmabuf->buforder + PAGE_SHIFT - 2);
1399 dmabuf->numfrag = bufsize >> dmabuf->fragshift;
1400 while (dmabuf->numfrag < 4 && dmabuf->fragshift > 3) {
1401 dmabuf->fragshift--;
1402 dmabuf->numfrag = bufsize >> dmabuf->fragshift;
1404 dmabuf->fragsize = 1 << dmabuf->fragshift;
1405 if (dmabuf->ossmaxfrags >= 4 && dmabuf->ossmaxfrags < dmabuf->numfrag)
1406 dmabuf->numfrag = dmabuf->ossmaxfrags;
1407 dmabuf->fragsamples = dmabuf->fragsize >> sample_shift[dmabuf->fmt];
1408 dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
1410 memset(dmabuf->rawbuf, (dmabuf->fmt & TRIDENT_FMT_16BIT) ? 0 : 0x80,
1413 spin_lock_irqsave(&s->card->lock, flags);
1414 if (rec == DM_RECORD)
1415 trident_rec_setup(s);
1416 else /* DM_PLAYBACK */
1417 trident_play_setup(s);
1419 spin_unlock_irqrestore(&s->card->lock, flags);
1421 /* set the ready flag for the dma buffer */
1424 pr_debug("trident: prog_dmabuf(%d), sample rate = %d, "
1425 "format = %d, numfrag = %d, fragsize = %d "
1426 "dmasize = %d\n", dmabuf->channel->num,
1427 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1428 dmabuf->fragsize, dmabuf->dmasize);
1430 unlock_set_fmt(state);
1435 static inline int prog_dmabuf_record(struct trident_state* state)
1437 return prog_dmabuf(state, DM_RECORD);
1440 static inline int prog_dmabuf_playback(struct trident_state* state)
1442 return prog_dmabuf(state, DM_PLAYBACK);
1445 /* we are doing quantum mechanics here, the buffer can only be empty, half or full filled i.e.
1446 |------------|------------| or |xxxxxxxxxxxx|------------| or |xxxxxxxxxxxx|xxxxxxxxxxxx|
1447 but we almost always get this
1448 |xxxxxx------|------------| or |xxxxxxxxxxxx|xxxxx-------|
1449 so we have to clear the tail space to "silence"
1450 |xxxxxx000000|------------| or |xxxxxxxxxxxx|xxxxxx000000|
1453 trident_clear_tail(struct trident_state *state)
1455 struct dmabuf *dmabuf = &state->dmabuf;
1457 unsigned char silence = (dmabuf->fmt & TRIDENT_FMT_16BIT) ? 0 : 0x80;
1459 unsigned long flags;
1461 spin_lock_irqsave(&state->card->lock, flags);
1462 swptr = dmabuf->swptr;
1463 spin_unlock_irqrestore(&state->card->lock, flags);
1465 if (swptr == 0 || swptr == dmabuf->dmasize / 2 ||
1466 swptr == dmabuf->dmasize)
1469 if (swptr < dmabuf->dmasize / 2)
1470 len = dmabuf->dmasize / 2 - swptr;
1472 len = dmabuf->dmasize - swptr;
1474 memset(dmabuf->rawbuf + swptr, silence, len);
1475 if (state->card->pci_id != PCI_DEVICE_ID_ALI_5451) {
1476 spin_lock_irqsave(&state->card->lock, flags);
1477 dmabuf->swptr += len;
1478 dmabuf->count += len;
1479 spin_unlock_irqrestore(&state->card->lock, flags);
1482 /* restart the dma machine in case it is halted */
1487 drain_dac(struct trident_state *state, int nonblock)
1489 DECLARE_WAITQUEUE(wait, current);
1490 struct dmabuf *dmabuf = &state->dmabuf;
1491 unsigned long flags;
1494 unsigned long diff = 0;
1496 if (dmabuf->mapped || !dmabuf->ready)
1499 add_wait_queue(&dmabuf->wait, &wait);
1501 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1502 every time to make the process really go to sleep */
1503 set_current_state(TASK_INTERRUPTIBLE);
1505 spin_lock_irqsave(&state->card->lock, flags);
1506 count = dmabuf->count;
1507 spin_unlock_irqrestore(&state->card->lock, flags);
1512 if (signal_pending(current))
1516 remove_wait_queue(&dmabuf->wait, &wait);
1517 set_current_state(TASK_RUNNING);
1521 /* No matter how much data is left in the buffer, we have to wait until
1522 CSO == ESO/2 or CSO == ESO when address engine interrupts */
1523 if (state->card->pci_id == PCI_DEVICE_ID_ALI_5451 ||
1524 state->card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
1525 diff = dmabuf->swptr - trident_get_dma_addr(state) + dmabuf->dmasize;
1526 diff = diff % (dmabuf->dmasize);
1527 tmo = (diff * HZ) / dmabuf->rate;
1529 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1531 tmo >>= sample_shift[dmabuf->fmt];
1532 if (!schedule_timeout(tmo ? tmo : 1) && tmo) {
1536 remove_wait_queue(&dmabuf->wait, &wait);
1537 set_current_state(TASK_RUNNING);
1538 if (signal_pending(current))
1539 return -ERESTARTSYS;
1544 /* update buffer manangement pointers, especially, */
1545 /* dmabuf->count and dmabuf->hwptr */
1547 trident_update_ptr(struct trident_state *state)
1549 struct dmabuf *dmabuf = &state->dmabuf;
1550 unsigned hwptr, swptr;
1553 unsigned char silence;
1554 unsigned half_dmasize;
1556 /* update hardware pointer */
1557 hwptr = trident_get_dma_addr(state);
1558 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1559 dmabuf->hwptr = hwptr;
1560 dmabuf->total_bytes += diff;
1562 /* error handling and process wake up for ADC */
1563 if (dmabuf->enable == ADC_RUNNING) {
1564 if (dmabuf->mapped) {
1565 dmabuf->count -= diff;
1566 if (dmabuf->count >= (signed) dmabuf->fragsize)
1567 wake_up(&dmabuf->wait);
1569 dmabuf->count += diff;
1571 if (dmabuf->count < 0 ||
1572 dmabuf->count > dmabuf->dmasize) {
1573 /* buffer underrun or buffer overrun, */
1574 /* we have no way to recover it here, just */
1575 /* stop the machine and let the process */
1576 /* force hwptr and swptr to sync */
1580 if (dmabuf->count < (signed) dmabuf->dmasize / 2)
1581 wake_up(&dmabuf->wait);
1585 /* error handling and process wake up for DAC */
1586 if (dmabuf->enable == DAC_RUNNING) {
1587 if (dmabuf->mapped) {
1588 dmabuf->count += diff;
1589 if (dmabuf->count >= (signed) dmabuf->fragsize)
1590 wake_up(&dmabuf->wait);
1592 dmabuf->count -= diff;
1594 if (dmabuf->count < 0 ||
1595 dmabuf->count > dmabuf->dmasize) {
1596 /* buffer underrun or buffer overrun, we have no way to recover
1597 it here, just stop the machine and let the process force hwptr
1598 and swptr to sync */
1601 } else if (!dmabuf->endcleared) {
1602 swptr = dmabuf->swptr;
1603 silence = (dmabuf->fmt & TRIDENT_FMT_16BIT ? 0 : 0x80);
1604 if (dmabuf->update_flag & ALI_ADDRESS_INT_UPDATE) {
1605 /* We must clear end data of 1/2 dmabuf if needed.
1606 According to 1/2 algorithm of Address Engine Interrupt,
1607 check the validation of the data of half dmasize. */
1608 half_dmasize = dmabuf->dmasize / 2;
1609 if ((diff = hwptr - half_dmasize) < 0)
1611 if ((dmabuf->count + diff) < half_dmasize) {
1612 //there is invalid data in the end of half buffer
1613 if ((clear_cnt = half_dmasize - swptr) < 0)
1614 clear_cnt += half_dmasize;
1615 //clear the invalid data
1616 memset(dmabuf->rawbuf + swptr, silence, clear_cnt);
1617 if (state->chans_num == 6) {
1618 clear_cnt = clear_cnt / 2;
1620 memset(state->other_states[0]->dmabuf.rawbuf + swptr,
1621 silence, clear_cnt);
1622 memset(state->other_states[1]->dmabuf.rawbuf + swptr,
1623 silence, clear_cnt);
1624 memset(state->other_states[2]->dmabuf.rawbuf + swptr,
1625 silence, clear_cnt);
1626 memset(state->other_states[3]->dmabuf.rawbuf + swptr,
1627 silence, clear_cnt);
1629 dmabuf->endcleared = 1;
1631 } else if (dmabuf->count < (signed) dmabuf->fragsize) {
1632 clear_cnt = dmabuf->fragsize;
1633 if ((swptr + clear_cnt) > dmabuf->dmasize)
1634 clear_cnt = dmabuf->dmasize - swptr;
1635 memset(dmabuf->rawbuf + swptr, silence, clear_cnt);
1636 if (state->chans_num == 6) {
1637 clear_cnt = clear_cnt / 2;
1639 memset(state->other_states[0]->dmabuf.rawbuf + swptr,
1640 silence, clear_cnt);
1641 memset(state->other_states[1]->dmabuf.rawbuf + swptr,
1642 silence, clear_cnt);
1643 memset(state->other_states[2]->dmabuf.rawbuf + swptr,
1644 silence, clear_cnt);
1645 memset(state->other_states[3]->dmabuf.rawbuf + swptr,
1646 silence, clear_cnt);
1648 dmabuf->endcleared = 1;
1651 /* trident_update_ptr is called by interrupt handler or by process via
1652 ioctl/poll, we only wake up the waiting process when we have more
1653 than 1/2 buffer free (always true for interrupt handler) */
1654 if (dmabuf->count < (signed) dmabuf->dmasize / 2)
1655 wake_up(&dmabuf->wait);
1658 dmabuf->update_flag &= ~ALI_ADDRESS_INT_UPDATE;
1662 trident_address_interrupt(struct trident_card *card)
1665 struct trident_state *state;
1666 unsigned int channel;
1668 /* Update the pointers for all channels we are running. */
1669 /* FIXME: should read interrupt status only once */
1670 for (i = 0; i < NR_HW_CH; i++) {
1672 if (trident_check_channel_interrupt(card, channel)) {
1673 trident_ack_channel_interrupt(card, channel);
1674 if ((state = card->states[i]) != NULL) {
1675 trident_update_ptr(state);
1677 printk(KERN_WARNING "trident: spurious channel "
1678 "irq %d.\n", channel);
1679 trident_stop_voice(card, channel);
1680 trident_disable_voice_irq(card, channel);
1687 ali_hwvol_control(struct trident_card *card, int opt)
1689 u16 dwTemp, volume[2], mute, diff, *pVol[2];
1691 dwTemp = ali_ac97_read(card->ac97_codec[0], 0x02);
1692 mute = dwTemp & 0x8000;
1693 volume[0] = dwTemp & 0x001f;
1694 volume[1] = (dwTemp & 0x1f00) >> 8;
1695 if (volume[0] < volume[1]) {
1696 pVol[0] = &volume[0];
1697 pVol[1] = &volume[1];
1699 pVol[1] = &volume[0];
1700 pVol[0] = &volume[1];
1702 diff = *(pVol[1]) - *(pVol[0]);
1704 if (opt == 1) { // MUTE
1706 ali_ac97_write(card->ac97_codec[0],
1708 } else if (opt == 2) { // Down
1711 if (*(pVol[1]) < 0x001f) {
1713 *(pVol[0]) = *(pVol[1]) - diff;
1716 dwTemp |= (volume[0]) | (volume[1] << 8);
1717 ali_ac97_write(card->ac97_codec[0], 0x02, dwTemp);
1718 card->ac97_codec[0]->mixer_state[0] = ((32 - volume[0]) * 25 / 8) |
1719 (((32 - volume[1]) * 25 / 8) << 8);
1720 } else if (opt == 4) { // Up
1723 if (*(pVol[0]) > 0) {
1725 *(pVol[1]) = *(pVol[0]) + diff;
1728 dwTemp |= (volume[0]) | (volume[1] << 8);
1729 ali_ac97_write(card->ac97_codec[0], 0x02, dwTemp);
1730 card->ac97_codec[0]->mixer_state[0] = ((32 - volume[0]) * 25 / 8) |
1731 (((32 - volume[1]) * 25 / 8) << 8);
1733 /* Nothing needs doing */
1738 * Re-enable reporting of vol change after 0.1 seconds
1742 ali_timeout(unsigned long ptr)
1744 struct trident_card *card = (struct trident_card *) ptr;
1747 /* Enable GPIO IRQ (MISCINT bit 18h) */
1748 temp = inw(TRID_REG(card, T4D_MISCINT + 2));
1750 outw(temp, TRID_REG(card, T4D_MISCINT + 2));
1754 * Set up the timer to clear the vol change notification
1758 ali_set_timer(struct trident_card *card)
1760 /* Add Timer Routine to Enable GPIO IRQ */
1761 del_timer(&card->timer); /* Never queue twice */
1762 card->timer.function = ali_timeout;
1763 card->timer.data = (unsigned long) card;
1764 card->timer.expires = jiffies + HZ / 10;
1765 add_timer(&card->timer);
1769 * Process a GPIO event
1773 ali_queue_task(struct trident_card *card, int opt)
1777 /* Disable GPIO IRQ (MISCINT bit 18h) */
1778 temp = inw(TRID_REG(card, T4D_MISCINT + 2));
1779 temp &= (u16) (~0x0004);
1780 outw(temp, TRID_REG(card, T4D_MISCINT + 2));
1782 /* Adjust the volume */
1783 ali_hwvol_control(card, opt);
1785 /* Set the timer for 1/10th sec */
1786 ali_set_timer(card);
1790 cyber_address_interrupt(struct trident_card *card)
1793 struct trident_state *state;
1794 unsigned int channel;
1796 /* Update the pointers for all channels we are running. */
1797 /* FIXED: read interrupt status only once */
1798 irq_status = inl(TRID_REG(card, T4D_AINT_A));
1800 pr_debug("cyber_address_interrupt: irq_status 0x%X\n", irq_status);
1802 for (i = 0; i < NR_HW_CH; i++) {
1804 if (irq_status & (1 << channel)) {
1805 /* clear bit by writing a 1, zeroes are ignored */
1806 outl((1 << channel), TRID_REG(card, T4D_AINT_A));
1808 pr_debug("cyber_interrupt: channel %d\n", channel);
1810 if ((state = card->states[i]) != NULL) {
1811 trident_update_ptr(state);
1813 printk(KERN_WARNING "cyber5050: spurious "
1814 "channel irq %d.\n", channel);
1815 trident_stop_voice(card, channel);
1816 trident_disable_voice_irq(card, channel);
1823 trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1825 struct trident_card *card = (struct trident_card *) dev_id;
1829 spin_lock(&card->lock);
1830 event = inl(TRID_REG(card, T4D_MISCINT));
1832 pr_debug("trident: trident_interrupt called, MISCINT = 0x%08x\n",
1835 if (event & ADDRESS_IRQ) {
1836 card->address_interrupt(card);
1839 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
1840 /* GPIO IRQ (H/W Volume Control) */
1841 event = inl(TRID_REG(card, T4D_MISCINT));
1842 if (event & (1 << 25)) {
1843 gpio = inl(TRID_REG(card, ALI_GPIO));
1844 if (!timer_pending(&card->timer))
1845 ali_queue_task(card, gpio & 0x07);
1847 event = inl(TRID_REG(card, T4D_MISCINT));
1848 outl(event | (ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
1849 TRID_REG(card, T4D_MISCINT));
1850 spin_unlock(&card->lock);
1854 /* manually clear interrupt status, bad hardware design, blame T^2 */
1855 outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
1856 TRID_REG(card, T4D_MISCINT));
1857 spin_unlock(&card->lock);
1861 /* in this loop, dmabuf.count signifies the amount of data that is waiting */
1862 /* to be copied to the user's buffer. it is filled by the dma machine and */
1863 /* drained by this loop. */
1865 trident_read(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
1867 struct trident_state *state = (struct trident_state *)file->private_data;
1868 struct dmabuf *dmabuf = &state->dmabuf;
1870 unsigned long flags;
1874 pr_debug("trident: trident_read called, count = %d\n", count);
1876 VALIDATE_STATE(state);
1880 if (!access_ok(VERIFY_WRITE, buffer, count))
1884 if (!dmabuf->ready && (ret = prog_dmabuf_record(state)))
1888 spin_lock_irqsave(&state->card->lock, flags);
1889 if (dmabuf->count > (signed) dmabuf->dmasize) {
1890 /* buffer overrun, we are recovering from */
1891 /* sleep_on_timeout, resync hwptr and swptr, */
1892 /* make process flush the buffer */
1893 dmabuf->count = dmabuf->dmasize;
1894 dmabuf->swptr = dmabuf->hwptr;
1896 swptr = dmabuf->swptr;
1897 cnt = dmabuf->dmasize - swptr;
1898 if (dmabuf->count < cnt)
1899 cnt = dmabuf->count;
1900 spin_unlock_irqrestore(&state->card->lock, flags);
1906 /* buffer is empty, start the dma machine and */
1907 /* wait for data to be recorded */
1909 if (file->f_flags & O_NONBLOCK) {
1916 /* No matter how much space left in the buffer, */
1917 /* we have to wait until CSO == ESO/2 or CSO == ESO */
1918 /* when address engine interrupts */
1919 tmo = (dmabuf->dmasize * HZ) / (dmabuf->rate * 2);
1920 tmo >>= sample_shift[dmabuf->fmt];
1921 /* There are two situations when sleep_on_timeout returns, one is when
1922 the interrupt is serviced correctly and the process is waked up by
1923 ISR ON TIME. Another is when timeout is expired, which means that
1924 either interrupt is NOT serviced correctly (pending interrupt) or it
1925 is TOO LATE for the process to be scheduled to run (scheduler latency)
1926 which results in a (potential) buffer overrun. And worse, there is
1927 NOTHING we can do to prevent it. */
1928 if (!interruptible_sleep_on_timeout(&dmabuf->wait, tmo)) {
1929 pr_debug(KERN_ERR "trident: recording schedule timeout, "
1930 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1931 dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
1932 dmabuf->hwptr, dmabuf->swptr);
1934 /* a buffer overrun, we delay the recovery until next time the
1935 while loop begin and we REALLY have space to record */
1937 if (signal_pending(current)) {
1943 if (dmabuf->mapped) {
1951 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1957 swptr = (swptr + cnt) % dmabuf->dmasize;
1959 spin_lock_irqsave(&state->card->lock, flags);
1960 dmabuf->swptr = swptr;
1961 dmabuf->count -= cnt;
1962 spin_unlock_irqrestore(&state->card->lock, flags);
1974 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1975 the soundcard. it is drained by the dma machine and filled by this loop. */
1978 trident_write(struct file *file, const char __user *buffer, size_t count, loff_t * ppos)
1980 struct trident_state *state = (struct trident_state *)file->private_data;
1981 struct dmabuf *dmabuf = &state->dmabuf;
1983 unsigned long flags;
1986 unsigned int state_cnt;
1987 unsigned int copy_count;
1988 int lret; /* for lock_set_fmt */
1990 pr_debug("trident: trident_write called, count = %d\n", count);
1992 VALIDATE_STATE(state);
1995 * Guard against an mmap or ioctl while writing
2000 if (dmabuf->mapped) {
2004 if (!dmabuf->ready && (ret = prog_dmabuf_playback(state)))
2007 if (!access_ok(VERIFY_READ, buffer, count)) {
2015 spin_lock_irqsave(&state->card->lock, flags);
2016 if (dmabuf->count < 0) {
2017 /* buffer underrun, we are recovering from */
2018 /* sleep_on_timeout, resync hwptr and swptr */
2020 dmabuf->swptr = dmabuf->hwptr;
2022 swptr = dmabuf->swptr;
2023 cnt = dmabuf->dmasize - swptr;
2024 if (dmabuf->count + cnt > dmabuf->dmasize)
2025 cnt = dmabuf->dmasize - dmabuf->count;
2026 spin_unlock_irqrestore(&state->card->lock, flags);
2032 /* buffer is full, start the dma machine and */
2033 /* wait for data to be played */
2035 if (file->f_flags & O_NONBLOCK) {
2040 /* No matter how much data left in the buffer, */
2041 /* we have to wait until CSO == ESO/2 or CSO == ESO */
2042 /* when address engine interrupts */
2043 lock_set_fmt(state);
2044 tmo = (dmabuf->dmasize * HZ) / (dmabuf->rate * 2);
2045 tmo >>= sample_shift[dmabuf->fmt];
2046 unlock_set_fmt(state);
2049 /* There are two situations when sleep_on_timeout */
2050 /* returns, one is when the interrupt is serviced */
2051 /* correctly and the process is waked up by ISR */
2052 /* ON TIME. Another is when timeout is expired, which */
2053 /* means that either interrupt is NOT serviced */
2054 /* correctly (pending interrupt) or it is TOO LATE */
2055 /* for the process to be scheduled to run */
2056 /* (scheduler latency) which results in a (potential) */
2057 /* buffer underrun. And worse, there is NOTHING we */
2058 /* can do to prevent it. */
2059 if (!interruptible_sleep_on_timeout(&dmabuf->wait, tmo)) {
2060 pr_debug(KERN_ERR "trident: playback schedule "
2061 "timeout, dmasz %u fragsz %u count %i "
2062 "hwptr %u swptr %u\n", dmabuf->dmasize,
2063 dmabuf->fragsize, dmabuf->count,
2064 dmabuf->hwptr, dmabuf->swptr);
2066 /* a buffer underrun, we delay the recovery */
2067 /* until next time the while loop begin and */
2068 /* we REALLY have data to play */
2070 if (signal_pending(current)) {
2076 if (dmabuf->mapped) {
2083 if ((lret = lock_set_fmt(state)) < 0) {
2088 if (state->chans_num == 6) {
2091 if (ali_write_5_1(state, buffer, cnt, ©_count,
2092 &state_cnt) == -EFAULT) {
2094 swptr = (swptr + state_cnt) % dmabuf->dmasize;
2095 spin_lock_irqsave(&state->card->lock, flags);
2096 dmabuf->swptr = swptr;
2097 dmabuf->count += state_cnt;
2098 dmabuf->endcleared = 0;
2099 spin_unlock_irqrestore(&state->card->lock, flags);
2104 unlock_set_fmt(state);
2108 if (copy_from_user(dmabuf->rawbuf + swptr,
2112 unlock_set_fmt(state);
2117 unlock_set_fmt(state);
2119 swptr = (swptr + state_cnt) % dmabuf->dmasize;
2121 spin_lock_irqsave(&state->card->lock, flags);
2122 dmabuf->swptr = swptr;
2123 dmabuf->count += state_cnt;
2124 dmabuf->endcleared = 0;
2125 spin_unlock_irqrestore(&state->card->lock, flags);
2138 /* No kernel lock - we have our own spinlock */
2140 trident_poll(struct file *file, struct poll_table_struct *wait)
2142 struct trident_state *state = (struct trident_state *)file->private_data;
2143 struct dmabuf *dmabuf = &state->dmabuf;
2144 unsigned long flags;
2145 unsigned int mask = 0;
2147 VALIDATE_STATE(state);
2150 * Guard against a parallel poll and write causing multiple
2151 * prog_dmabuf events
2156 if (file->f_mode & FMODE_WRITE) {
2157 if (!dmabuf->ready && prog_dmabuf_playback(state)) {
2161 poll_wait(file, &dmabuf->wait, wait);
2163 if (file->f_mode & FMODE_READ) {
2164 if (!dmabuf->ready && prog_dmabuf_record(state)) {
2168 poll_wait(file, &dmabuf->wait, wait);
2173 spin_lock_irqsave(&state->card->lock, flags);
2174 trident_update_ptr(state);
2175 if (file->f_mode & FMODE_READ) {
2176 if (dmabuf->count >= (signed) dmabuf->fragsize)
2177 mask |= POLLIN | POLLRDNORM;
2179 if (file->f_mode & FMODE_WRITE) {
2180 if (dmabuf->mapped) {
2181 if (dmabuf->count >= (signed) dmabuf->fragsize)
2182 mask |= POLLOUT | POLLWRNORM;
2184 if ((signed) dmabuf->dmasize >= dmabuf->count +
2185 (signed) dmabuf->fragsize)
2186 mask |= POLLOUT | POLLWRNORM;
2189 spin_unlock_irqrestore(&state->card->lock, flags);
2195 trident_mmap(struct file *file, struct vm_area_struct *vma)
2197 struct trident_state *state = (struct trident_state *)file->private_data;
2198 struct dmabuf *dmabuf = &state->dmabuf;
2202 VALIDATE_STATE(state);
2205 * Lock against poll read write or mmap creating buffers. Also lock
2206 * a read or write against an mmap.
2211 if (vma->vm_flags & VM_WRITE) {
2212 if ((ret = prog_dmabuf_playback(state)) != 0)
2214 } else if (vma->vm_flags & VM_READ) {
2215 if ((ret = prog_dmabuf_record(state)) != 0)
2221 if (vma->vm_pgoff != 0)
2223 size = vma->vm_end - vma->vm_start;
2224 if (size > (PAGE_SIZE << dmabuf->buforder))
2227 if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf),
2228 size, vma->vm_page_prot))
2238 trident_ioctl(struct inode *inode, struct file *file,
2239 unsigned int cmd, unsigned long arg)
2241 struct trident_state *state = (struct trident_state *)file->private_data;
2242 struct dmabuf *dmabuf = &state->dmabuf;
2243 unsigned long flags;
2244 audio_buf_info abinfo;
2246 int val, mapped, ret = 0;
2247 struct trident_card *card = state->card;
2248 void __user *argp = (void __user *)arg;
2249 int __user *p = argp;
2251 VALIDATE_STATE(state);
2254 mapped = ((file->f_mode & (FMODE_WRITE | FMODE_READ)) && dmabuf->mapped);
2256 pr_debug("trident: trident_ioctl, command = %2d, arg = 0x%08x\n",
2257 _IOC_NR(cmd), arg ? *p : 0);
2260 case OSS_GETVERSION:
2261 ret = put_user(SOUND_VERSION, p);
2264 case SNDCTL_DSP_RESET:
2265 /* FIXME: spin_lock ? */
2266 if (file->f_mode & FMODE_WRITE) {
2268 synchronize_irq(card->irq);
2270 dmabuf->swptr = dmabuf->hwptr = 0;
2271 dmabuf->count = dmabuf->total_bytes = 0;
2273 if (file->f_mode & FMODE_READ) {
2275 synchronize_irq(card->irq);
2277 dmabuf->swptr = dmabuf->hwptr = 0;
2278 dmabuf->count = dmabuf->total_bytes = 0;
2282 case SNDCTL_DSP_SYNC:
2283 if (file->f_mode & FMODE_WRITE)
2284 ret = drain_dac(state, file->f_flags & O_NONBLOCK);
2287 case SNDCTL_DSP_SPEED: /* set smaple rate */
2288 if (get_user(val, p)) {
2293 if (file->f_mode & FMODE_WRITE) {
2296 spin_lock_irqsave(&state->card->lock, flags);
2297 trident_set_dac_rate(state, val);
2298 spin_unlock_irqrestore(&state->card->lock, flags);
2300 if (file->f_mode & FMODE_READ) {
2303 spin_lock_irqsave(&state->card->lock, flags);
2304 trident_set_adc_rate(state, val);
2305 spin_unlock_irqrestore(&state->card->lock, flags);
2308 ret = put_user(dmabuf->rate, p);
2311 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2312 if (get_user(val, p)) {
2316 if ((ret = lock_set_fmt(state)) < 0)
2319 if (file->f_mode & FMODE_WRITE) {
2323 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2325 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2327 if (file->f_mode & FMODE_READ) {
2331 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2333 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2335 unlock_set_fmt(state);
2338 case SNDCTL_DSP_GETBLKSIZE:
2339 if (file->f_mode & FMODE_WRITE) {
2340 if ((val = prog_dmabuf_playback(state)))
2343 ret = put_user(dmabuf->fragsize, p);
2346 if (file->f_mode & FMODE_READ) {
2347 if ((val = prog_dmabuf_record(state)))
2350 ret = put_user(dmabuf->fragsize, p);
2353 /* neither READ nor WRITE? is this even possible? */
2358 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format */
2359 ret = put_user(AFMT_S16_LE | AFMT_U16_LE | AFMT_S8 |
2363 case SNDCTL_DSP_SETFMT: /* Select sample format */
2364 if (get_user(val, p)) {
2368 if ((ret = lock_set_fmt(state)) < 0)
2371 if (val != AFMT_QUERY) {
2372 if (file->f_mode & FMODE_WRITE) {
2375 if (val == AFMT_S16_LE)
2376 dmabuf->fmt |= TRIDENT_FMT_16BIT;
2378 dmabuf->fmt &= ~TRIDENT_FMT_16BIT;
2380 if (file->f_mode & FMODE_READ) {
2383 if (val == AFMT_S16_LE)
2384 dmabuf->fmt |= TRIDENT_FMT_16BIT;
2386 dmabuf->fmt &= ~TRIDENT_FMT_16BIT;
2389 unlock_set_fmt(state);
2390 ret = put_user((dmabuf->fmt & TRIDENT_FMT_16BIT) ? AFMT_S16_LE :
2394 case SNDCTL_DSP_CHANNELS:
2395 if (get_user(val, p)) {
2400 if ((ret = lock_set_fmt(state)) < 0)
2403 if (file->f_mode & FMODE_WRITE) {
2407 //prevent from memory leak
2408 if ((state->chans_num > 2) && (state->chans_num != val)) {
2409 ali_free_other_states_resources(state);
2410 state->chans_num = 1;
2415 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2416 if ((val == 6) && (state->card->pci_id == PCI_DEVICE_ID_ALI_5451)) {
2417 if (card->rec_channel_use_count > 0) {
2418 printk(KERN_ERR "trident: Record is "
2419 "working on the card!\n");
2421 unlock_set_fmt(state);
2425 ret = ali_setup_multi_channels(state->card, 6);
2427 unlock_set_fmt(state);
2430 down(&state->card->open_sem);
2431 ret = ali_allocate_other_states_resources(state, 6);
2433 up(&state->card->open_sem);
2434 unlock_set_fmt(state);
2437 state->card->multi_channel_use_count++;
2438 up(&state->card->open_sem);
2440 val = 2; /*yield to 2-channels */
2442 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2443 state->chans_num = val;
2445 if (file->f_mode & FMODE_READ) {
2449 if (!((file->f_mode & FMODE_WRITE) &&
2452 dmabuf->fmt |= TRIDENT_FMT_STEREO;
2454 dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
2455 state->chans_num = val;
2457 unlock_set_fmt(state);
2459 ret = put_user(val, p);
2462 case SNDCTL_DSP_POST:
2463 /* Cause the working fragment to be output */
2466 case SNDCTL_DSP_SUBDIVIDE:
2467 if (dmabuf->subdivision) {
2471 if (get_user(val, p)) {
2475 if (val != 1 && val != 2 && val != 4) {
2479 dmabuf->subdivision = val;
2482 case SNDCTL_DSP_SETFRAGMENT:
2483 if (get_user(val, p)) {
2488 dmabuf->ossfragshift = val & 0xffff;
2489 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2490 if (dmabuf->ossfragshift < 4)
2491 dmabuf->ossfragshift = 4;
2492 if (dmabuf->ossfragshift > 15)
2493 dmabuf->ossfragshift = 15;
2494 if (dmabuf->ossmaxfrags < 4)
2495 dmabuf->ossmaxfrags = 4;
2499 case SNDCTL_DSP_GETOSPACE:
2500 if (!(file->f_mode & FMODE_WRITE)) {
2504 if (!dmabuf->ready && (val = prog_dmabuf_playback(state)) != 0) {
2508 spin_lock_irqsave(&state->card->lock, flags);
2509 trident_update_ptr(state);
2510 abinfo.fragsize = dmabuf->fragsize;
2511 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2512 abinfo.fragstotal = dmabuf->numfrag;
2513 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2514 spin_unlock_irqrestore(&state->card->lock, flags);
2515 ret = copy_to_user(argp, &abinfo, sizeof (abinfo)) ?
2519 case SNDCTL_DSP_GETISPACE:
2520 if (!(file->f_mode & FMODE_READ)) {
2524 if (!dmabuf->ready && (val = prog_dmabuf_record(state)) != 0) {
2528 spin_lock_irqsave(&state->card->lock, flags);
2529 trident_update_ptr(state);
2530 abinfo.fragsize = dmabuf->fragsize;
2531 abinfo.bytes = dmabuf->count;
2532 abinfo.fragstotal = dmabuf->numfrag;
2533 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2534 spin_unlock_irqrestore(&state->card->lock, flags);
2535 ret = copy_to_user(argp, &abinfo, sizeof (abinfo)) ?
2539 case SNDCTL_DSP_NONBLOCK:
2540 file->f_flags |= O_NONBLOCK;
2543 case SNDCTL_DSP_GETCAPS:
2544 ret = put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2545 DSP_CAP_MMAP | DSP_CAP_BIND, p);
2548 case SNDCTL_DSP_GETTRIGGER:
2550 if ((file->f_mode & FMODE_READ) && dmabuf->enable)
2551 val |= PCM_ENABLE_INPUT;
2552 if ((file->f_mode & FMODE_WRITE) && dmabuf->enable)
2553 val |= PCM_ENABLE_OUTPUT;
2554 ret = put_user(val, p);
2557 case SNDCTL_DSP_SETTRIGGER:
2558 if (get_user(val, p)) {
2562 if (file->f_mode & FMODE_READ) {
2563 if (val & PCM_ENABLE_INPUT) {
2564 if (!dmabuf->ready &&
2565 (ret = prog_dmabuf_record(state)))
2571 if (file->f_mode & FMODE_WRITE) {
2572 if (val & PCM_ENABLE_OUTPUT) {
2573 if (!dmabuf->ready &&
2574 (ret = prog_dmabuf_playback(state)))
2582 case SNDCTL_DSP_GETIPTR:
2583 if (!(file->f_mode & FMODE_READ)) {
2587 if (!dmabuf->ready && (val = prog_dmabuf_record(state))
2592 spin_lock_irqsave(&state->card->lock, flags);
2593 trident_update_ptr(state);
2594 cinfo.bytes = dmabuf->total_bytes;
2595 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2596 cinfo.ptr = dmabuf->hwptr;
2598 dmabuf->count &= dmabuf->fragsize - 1;
2599 spin_unlock_irqrestore(&state->card->lock, flags);
2600 ret = copy_to_user(argp, &cinfo, sizeof (cinfo)) ?
2604 case SNDCTL_DSP_GETOPTR:
2605 if (!(file->f_mode & FMODE_WRITE)) {
2609 if (!dmabuf->ready && (val = prog_dmabuf_playback(state))
2615 spin_lock_irqsave(&state->card->lock, flags);
2616 trident_update_ptr(state);
2617 cinfo.bytes = dmabuf->total_bytes;
2618 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2619 cinfo.ptr = dmabuf->hwptr;
2621 dmabuf->count &= dmabuf->fragsize - 1;
2622 spin_unlock_irqrestore(&state->card->lock, flags);
2623 ret = copy_to_user(argp, &cinfo, sizeof (cinfo)) ?
2627 case SNDCTL_DSP_SETDUPLEX:
2631 case SNDCTL_DSP_GETODELAY:
2632 if (!(file->f_mode & FMODE_WRITE)) {
2636 if (!dmabuf->ready && (val = prog_dmabuf_playback(state)) != 0) {
2640 spin_lock_irqsave(&state->card->lock, flags);
2641 trident_update_ptr(state);
2642 val = dmabuf->count;
2643 spin_unlock_irqrestore(&state->card->lock, flags);
2644 ret = put_user(val, p);
2647 case SOUND_PCM_READ_RATE:
2648 ret = put_user(dmabuf->rate, p);
2651 case SOUND_PCM_READ_CHANNELS:
2652 ret = put_user((dmabuf->fmt & TRIDENT_FMT_STEREO) ? 2 : 1,
2656 case SOUND_PCM_READ_BITS:
2657 ret = put_user((dmabuf->fmt & TRIDENT_FMT_16BIT) ? AFMT_S16_LE :
2661 case SNDCTL_DSP_GETCHANNELMASK:
2662 ret = put_user(DSP_BIND_FRONT | DSP_BIND_SURR |
2663 DSP_BIND_CENTER_LFE, p);
2666 case SNDCTL_DSP_BIND_CHANNEL:
2667 if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
2672 if (get_user(val, p)) {
2676 if (val == DSP_BIND_QUERY) {
2677 val = dmabuf->channel->attribute | 0x3c00;
2678 val = attr2mask[val >> 8];
2681 if (file->f_mode & FMODE_READ)
2682 dmabuf->channel->attribute = (CHANNEL_REC |
2684 if (file->f_mode & FMODE_WRITE)
2685 dmabuf->channel->attribute = (CHANNEL_SPC_PB |
2687 dmabuf->channel->attribute |= mask2attr[ffs(val)];
2689 ret = put_user(val, p);
2692 case SNDCTL_DSP_MAPINBUF:
2693 case SNDCTL_DSP_MAPOUTBUF:
2694 case SNDCTL_DSP_SETSYNCRO:
2695 case SOUND_PCM_WRITE_FILTER:
2696 case SOUND_PCM_READ_FILTER:
2706 trident_open(struct inode *inode, struct file *file)
2709 int minor = iminor(inode);
2710 struct trident_card *card = devs;
2711 struct trident_state *state = NULL;
2712 struct dmabuf *dmabuf = NULL;
2714 /* Added by Matt Wu 01-05-2001 */
2715 /* TODO: there's some redundacy here wrt the check below */
2716 /* for multi_use_count > 0. Should we return -EBUSY or find */
2717 /* a different card? for now, don't break current behaviour */
2719 if (file->f_mode & FMODE_READ) {
2720 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2721 if (card->multi_channel_use_count > 0)
2726 /* find an available virtual channel (instance of /dev/dsp) */
2727 while (card != NULL) {
2728 down(&card->open_sem);
2729 if (file->f_mode & FMODE_READ) {
2730 /* Skip opens on cards that are in 6 channel mode */
2731 if (card->multi_channel_use_count > 0) {
2732 up(&card->open_sem);
2737 for (i = 0; i < NR_HW_CH; i++) {
2738 if (card->states[i] == NULL) {
2739 state = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
2740 if (state == NULL) {
2741 up(&card->open_sem);
2744 memset(state, 0, sizeof(*state));
2745 init_MUTEX(&state->sem);
2746 dmabuf = &state->dmabuf;
2750 up(&card->open_sem);
2753 /* no more virtual channel avaiable */
2758 /* found a free virtual channel, allocate hardware channels */
2759 if (file->f_mode & FMODE_READ)
2760 dmabuf->channel = card->alloc_rec_pcm_channel(card);
2762 dmabuf->channel = card->alloc_pcm_channel(card);
2764 if (dmabuf->channel == NULL) {
2765 kfree(card->states[i]);
2766 card->states[i] = NULL;
2770 /* initialize the virtual channel */
2773 state->magic = TRIDENT_STATE_MAGIC;
2774 init_waitqueue_head(&dmabuf->wait);
2775 file->private_data = state;
2777 /* set default sample format. According to OSS Programmer's */
2778 /* Guide /dev/dsp should be default to unsigned 8-bits, mono, */
2779 /* with sample rate 8kHz and /dev/dspW will accept 16-bits sample */
2780 if (file->f_mode & FMODE_WRITE) {
2781 dmabuf->fmt &= ~TRIDENT_FMT_MASK;
2782 if ((minor & 0x0f) == SND_DEV_DSP16)
2783 dmabuf->fmt |= TRIDENT_FMT_16BIT;
2784 dmabuf->ossfragshift = 0;
2785 dmabuf->ossmaxfrags = 0;
2786 dmabuf->subdivision = 0;
2787 if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
2788 /* set default channel attribute to normal playback */
2789 dmabuf->channel->attribute = CHANNEL_PB;
2791 trident_set_dac_rate(state, 8000);
2794 if (file->f_mode & FMODE_READ) {
2795 /* FIXME: Trident 4d can only record in signed 16-bits stereo, */
2796 /* 48kHz sample, to be dealed with in trident_set_adc_rate() ?? */
2797 dmabuf->fmt &= ~TRIDENT_FMT_MASK;
2798 if ((minor & 0x0f) == SND_DEV_DSP16)
2799 dmabuf->fmt |= TRIDENT_FMT_16BIT;
2800 dmabuf->ossfragshift = 0;
2801 dmabuf->ossmaxfrags = 0;
2802 dmabuf->subdivision = 0;
2803 if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
2804 /* set default channel attribute to 0x8a80, record from
2805 PCM L/R FIFO and mono = (left + right + 1)/2 */
2806 dmabuf->channel->attribute = (CHANNEL_REC | PCM_LR |
2809 trident_set_adc_rate(state, 8000);
2811 /* Added by Matt Wu 01-05-2001 */
2812 if (card->pci_id == PCI_DEVICE_ID_ALI_5451)
2813 card->rec_channel_use_count++;
2816 state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2817 up(&card->open_sem);
2819 pr_debug("trident: open virtual channel %d, hard channel %d\n",
2820 state->virt, dmabuf->channel->num);
2822 return nonseekable_open(inode, file);
2826 trident_release(struct inode *inode, struct file *file)
2828 struct trident_state *state = (struct trident_state *)file->private_data;
2829 struct trident_card *card;
2830 struct dmabuf *dmabuf;
2832 VALIDATE_STATE(state);
2835 dmabuf = &state->dmabuf;
2837 if (file->f_mode & FMODE_WRITE) {
2838 trident_clear_tail(state);
2839 drain_dac(state, file->f_flags & O_NONBLOCK);
2842 pr_debug("trident: closing virtual channel %d, hard channel %d\n",
2843 state->virt, dmabuf->channel->num);
2845 /* stop DMA state machine and free DMA buffers/channels */
2846 down(&card->open_sem);
2848 if (file->f_mode & FMODE_WRITE) {
2850 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
2851 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
2853 /* Added by Matt Wu */
2854 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2855 if (state->chans_num > 2) {
2856 if (card->multi_channel_use_count-- < 0)
2857 card->multi_channel_use_count = 0;
2858 if (card->multi_channel_use_count == 0)
2859 ali_close_multi_channels();
2860 ali_free_other_states_resources(state);
2864 if (file->f_mode & FMODE_READ) {
2866 dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
2867 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
2869 /* Added by Matt Wu */
2870 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
2871 if (card->rec_channel_use_count-- < 0)
2872 card->rec_channel_use_count = 0;
2876 card->states[state->virt] = NULL;
2879 /* we're covered by the open_sem */
2880 up(&card->open_sem);
2885 static /*const */ struct file_operations trident_audio_fops = {
2886 .owner = THIS_MODULE,
2887 .llseek = no_llseek,
2888 .read = trident_read,
2889 .write = trident_write,
2890 .poll = trident_poll,
2891 .ioctl = trident_ioctl,
2892 .mmap = trident_mmap,
2893 .open = trident_open,
2894 .release = trident_release,
2897 /* trident specific AC97 functions */
2898 /* Write AC97 codec registers */
2900 trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val)
2902 struct trident_card *card = (struct trident_card *)codec->private_data;
2903 unsigned int address, mask, busy;
2904 unsigned short count = 0xffff;
2905 unsigned long flags;
2908 data = ((u32) val) << 16;
2910 switch (card->pci_id) {
2912 case PCI_DEVICE_ID_SI_7018:
2913 address = SI_AC97_WRITE;
2914 mask = SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY;
2916 mask |= SI_AC97_SECONDARY;
2917 busy = SI_AC97_BUSY_WRITE;
2919 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
2920 address = DX_ACR0_AC97_W;
2921 mask = busy = DX_AC97_BUSY_WRITE;
2923 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
2924 address = NX_ACR1_AC97_W;
2925 mask = NX_AC97_BUSY_WRITE;
2927 mask |= NX_AC97_WRITE_SECONDARY;
2928 busy = NX_AC97_BUSY_WRITE;
2930 case PCI_DEVICE_ID_INTERG_5050:
2931 address = SI_AC97_WRITE;
2932 mask = busy = SI_AC97_BUSY_WRITE;
2934 mask |= SI_AC97_SECONDARY;
2938 spin_lock_irqsave(&card->lock, flags);
2940 if ((inw(TRID_REG(card, address)) & busy) == 0)
2944 data |= (mask | (reg & AC97_REG_ADDR));
2947 printk(KERN_ERR "trident: AC97 CODEC write timed out.\n");
2948 spin_unlock_irqrestore(&card->lock, flags);
2952 outl(data, TRID_REG(card, address));
2953 spin_unlock_irqrestore(&card->lock, flags);
2956 /* Read AC97 codec registers */
2958 trident_ac97_get(struct ac97_codec *codec, u8 reg)
2960 struct trident_card *card = (struct trident_card *)codec->private_data;
2961 unsigned int address, mask, busy;
2962 unsigned short count = 0xffff;
2963 unsigned long flags;
2966 switch (card->pci_id) {
2968 case PCI_DEVICE_ID_SI_7018:
2969 address = SI_AC97_READ;
2970 mask = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY;
2972 mask |= SI_AC97_SECONDARY;
2973 busy = SI_AC97_BUSY_READ;
2975 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
2976 address = DX_ACR1_AC97_R;
2977 mask = busy = DX_AC97_BUSY_READ;
2979 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
2981 address = NX_ACR3_AC97_R_SECONDARY;
2983 address = NX_ACR2_AC97_R_PRIMARY;
2984 mask = NX_AC97_BUSY_READ;
2985 busy = NX_AC97_BUSY_READ | NX_AC97_BUSY_DATA;
2987 case PCI_DEVICE_ID_INTERG_5050:
2988 address = SI_AC97_READ;
2989 mask = busy = SI_AC97_BUSY_READ;
2991 mask |= SI_AC97_SECONDARY;
2995 data = (mask | (reg & AC97_REG_ADDR));
2997 spin_lock_irqsave(&card->lock, flags);
2998 outl(data, TRID_REG(card, address));
3000 data = inl(TRID_REG(card, address));
3001 if ((data & busy) == 0)
3004 spin_unlock_irqrestore(&card->lock, flags);
3007 printk(KERN_ERR "trident: AC97 CODEC read timed out.\n");
3010 return ((u16) (data >> 16));
3013 /* rewrite ac97 read and write mixer register by hulei for ALI*/
3015 acquirecodecaccess(struct trident_card *card)
3017 u16 wsemamask = 0x6000; /* bit 14..13 */
3023 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3024 wsemabits = wcontrol & wsemamask;
3026 if (wsemabits == 0x4000)
3027 return 1; /* 0x4000 is audio ,then success */
3030 if (wsemabits == 0) {
3032 outl(((u32) (wcontrol & 0x1eff) | 0x00004000),
3033 TRID_REG(card, ALI_AC97_WRITE));
3039 pr_debug("accesscodecsemaphore: try unlock\n");
3047 releasecodecaccess(struct trident_card *card)
3049 unsigned long wcontrol;
3050 wcontrol = inl(TRID_REG(card, ALI_AC97_WRITE));
3051 outl((wcontrol & 0xffff1eff), TRID_REG(card, ALI_AC97_WRITE));
3055 waitforstimertick(struct trident_card *card)
3057 unsigned long chk1, chk2;
3058 unsigned int wcount = 0xffff;
3059 chk1 = inl(TRID_REG(card, ALI_STIMER));
3062 chk2 = inl(TRID_REG(card, ALI_STIMER));
3063 if ((wcount > 0) && chk1 != chk2)
3072 /* Read AC97 codec registers for ALi*/
3074 ali_ac97_get(struct trident_card *card, int secondary, u8 reg)
3076 unsigned int address, mask;
3077 unsigned int ncount;
3078 unsigned long aud_reg;
3081 unsigned long flags;
3086 address = ALI_AC97_READ;
3087 if (card->revision == ALI_5451_V02) {
3088 address = ALI_AC97_WRITE;
3090 mask = ALI_AC97_READ_ACTION | ALI_AC97_AUDIO_BUSY;
3092 mask |= ALI_AC97_SECONDARY;
3094 spin_lock_irqsave(&card->lock, flags);
3096 if (!acquirecodecaccess(card))
3097 printk(KERN_ERR "access codec fail\n");
3099 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3101 wcontrol |= (0x8000 | reg);
3102 outw(wcontrol, TRID_REG(card, ALI_AC97_WRITE));
3104 data = (mask | (reg & AC97_REG_ADDR));
3106 if (!waitforstimertick(card)) {
3107 printk(KERN_ERR "ali_ac97_read: BIT_CLOCK is dead\n");
3116 if ((inw(TRID_REG(card, ALI_AC97_WRITE)) & ALI_AC97_BUSY_READ)
3121 if (ncount-- == 1) {
3122 pr_debug("ali_ac97_read :try clear busy flag\n");
3123 aud_reg = inl(TRID_REG(card, ALI_AC97_WRITE));
3124 outl((aud_reg & 0xffff7fff),
3125 TRID_REG(card, ALI_AC97_WRITE));
3130 data = inl(TRID_REG(card, address));
3132 spin_unlock_irqrestore(&card->lock, flags);
3134 return ((u16) (data >> 16));
3137 releasecodecaccess(card);
3138 spin_unlock_irqrestore(&card->lock, flags);
3139 printk(KERN_ERR "ali_ac97_read: AC97 CODEC read timed out.\n");
3143 /* Write AC97 codec registers for hulei*/
3145 ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val)
3147 unsigned int address, mask;
3148 unsigned int ncount;
3151 unsigned long flags;
3153 data = ((u32) val) << 16;
3158 address = ALI_AC97_WRITE;
3159 mask = ALI_AC97_WRITE_ACTION | ALI_AC97_AUDIO_BUSY;
3161 mask |= ALI_AC97_SECONDARY;
3162 if (card->revision == ALI_5451_V02)
3163 mask |= ALI_AC97_WRITE_MIXER_REGISTER;
3165 spin_lock_irqsave(&card->lock, flags);
3166 if (!acquirecodecaccess(card))
3167 printk(KERN_ERR "ali_ac97_write: access codec fail\n");
3169 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3171 wcontrol |= (0x8100 | reg); /* bit 8=1: (ali1535 )reserved/ */
3172 /* ali1535+ write */
3173 outl((data | wcontrol), TRID_REG(card, ALI_AC97_WRITE));
3175 if (!waitforstimertick(card)) {
3176 printk(KERN_ERR "BIT_CLOCK is dead\n");
3182 wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
3183 if (!(wcontrol & 0x8000))
3187 if (ncount-- == 1) {
3188 pr_debug("ali_ac97_set :try clear busy flag!!\n");
3189 outw(wcontrol & 0x7fff,
3190 TRID_REG(card, ALI_AC97_WRITE));
3196 releasecodecaccess(card);
3197 spin_unlock_irqrestore(&card->lock, flags);
3202 ali_enable_special_channel(struct trident_state *stat)
3204 struct trident_card *card = stat->card;
3205 unsigned long s_channels;
3207 s_channels = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3208 s_channels |= (1 << stat->dmabuf.channel->num);
3209 outl(s_channels, TRID_REG(card, ALI_GLOBAL_CONTROL));
3213 ali_ac97_read(struct ac97_codec *codec, u8 reg)
3217 struct trident_card *card = NULL;
3219 /* Added by Matt Wu */
3223 card = (struct trident_card *) codec->private_data;
3225 if (!card->mixer_regs_ready)
3226 return ali_ac97_get(card, codec->id, reg);
3229 * FIXME: need to stop this caching some registers
3236 data = card->mixer_regs[reg / 2][id];
3241 ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val)
3244 struct trident_card *card;
3246 /* Added by Matt Wu */
3250 card = (struct trident_card *) codec->private_data;
3252 if (!card->mixer_regs_ready) {
3253 ali_ac97_set(card, codec->id, reg, val);
3262 card->mixer_regs[reg / 2][id] = val;
3263 ali_ac97_set(card, codec->id, reg, val);
3267 flag: ALI_SPDIF_OUT_TO_SPDIF_OUT
3268 ALI_PCM_TO_SPDIF_OUT
3272 ali_setup_spdif_out(struct trident_card *card, int flag)
3274 unsigned long spdif;
3278 struct pci_dev *pci_dev = NULL;
3280 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3282 if (pci_dev == NULL)
3284 pci_read_config_byte(pci_dev, 0x61, &temp);
3286 pci_write_config_byte(pci_dev, 0x61, temp);
3287 pci_read_config_byte(pci_dev, 0x7d, &temp);
3289 pci_write_config_byte(pci_dev, 0x7d, temp);
3290 pci_read_config_byte(pci_dev, 0x7e, &temp);
3293 pci_write_config_byte(pci_dev, 0x7e, temp);
3295 ch = inb(TRID_REG(card, ALI_SCTRL));
3296 outb(ch | ALI_SPDIF_OUT_ENABLE, TRID_REG(card, ALI_SCTRL));
3297 ch = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3298 outb(ch & ALI_SPDIF_OUT_CH_STATUS, TRID_REG(card, ALI_SPDIF_CTRL));
3300 if (flag & ALI_SPDIF_OUT_TO_SPDIF_OUT) {
3301 spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
3302 spdif |= ALI_SPDIF_OUT_CH_ENABLE;
3303 spdif &= ALI_SPDIF_OUT_SEL_SPDIF;
3304 outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3305 spdif = inw(TRID_REG(card, ALI_SPDIF_CS));
3306 if (flag & ALI_SPDIF_OUT_NON_PCM)
3310 outw(spdif, TRID_REG(card, ALI_SPDIF_CS));
3312 spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
3313 spdif |= ALI_SPDIF_OUT_SEL_PCM;
3314 outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3319 ali_disable_special_channel(struct trident_card *card, int ch)
3323 sc = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3325 outl(sc, TRID_REG(card, ALI_GLOBAL_CONTROL));
3329 ali_disable_spdif_in(struct trident_card *card)
3331 unsigned long spdif;
3333 spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3334 spdif &= (~ALI_SPDIF_IN_SUPPORT);
3335 outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3337 ali_disable_special_channel(card, ALI_SPDIF_IN_CHANNEL);
3341 ali_setup_spdif_in(struct trident_card *card)
3343 unsigned long spdif;
3345 //Set SPDIF IN Supported
3346 spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3347 spdif |= ALI_SPDIF_IN_SUPPORT;
3348 outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3351 spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
3352 spdif |= ALI_SPDIF_IN_CH_ENABLE;
3353 outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
3355 spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3356 spdif |= ALI_SPDIF_IN_CH_STATUS;
3357 outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3359 spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3360 spdif |= ALI_SPDIF_IN_FUNC_ENABLE;
3361 outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3366 ali_delay(struct trident_card *card, int interval)
3368 unsigned long begintimer, currenttimer;
3370 begintimer = inl(TRID_REG(card, ALI_STIMER));
3371 currenttimer = inl(TRID_REG(card, ALI_STIMER));
3373 while (currenttimer < begintimer + interval)
3374 currenttimer = inl(TRID_REG(card, ALI_STIMER));
3378 ali_detect_spdif_rate(struct trident_card *card)
3382 u8 bval = 0, R1 = 0, R2 = 0;
3384 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3386 outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
3388 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3390 outb(bval, TRID_REG(card, ALI_SPDIF_CTRL + 1));
3392 while (((R1 < 0x0B) || (R1 > 0x0E)) && (R1 != 0x12) &&
3398 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3402 if (count > 50000) {
3403 printk(KERN_WARNING "trident: Error in "
3404 "ali_detect_spdif_rate!\n");
3410 while (count <= 50000) {
3415 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
3424 if (count > 50000) {
3425 printk(KERN_WARNING "trident: Error in "
3426 "ali_detect_spdif_rate!\n");
3435 wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
3437 wval |= (u16) 0x09 << 8 | (u16) 0x05;
3438 outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
3440 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
3441 outb(bval | 0x02, TRID_REG(card, ALI_SPDIF_CS + 3));
3445 wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
3447 wval |= (u16) 0x0E << 8 | (u16) 0x08;
3448 outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
3450 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
3451 outb(bval | 0x03, TRID_REG(card, ALI_SPDIF_CS + 3));
3461 ali_get_spdif_in_rate(struct trident_card *card)
3466 ali_detect_spdif_rate(card);
3468 bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3471 outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
3473 bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3));
3496 ali_close_multi_channels(void)
3499 struct pci_dev *pci_dev = NULL;
3501 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3503 if (pci_dev == NULL)
3505 pci_read_config_byte(pci_dev, 0x59, &temp);
3507 pci_write_config_byte(pci_dev, 0x59, temp);
3509 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
3511 if (pci_dev == NULL)
3514 pci_read_config_byte(pci_dev, 0xB8, &temp);
3516 pci_write_config_byte(pci_dev, 0xB8, temp);
3522 ali_setup_multi_channels(struct trident_card *card, int chan_nums)
3524 unsigned long dwValue;
3526 struct pci_dev *pci_dev = NULL;
3528 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
3530 if (pci_dev == NULL)
3532 pci_read_config_byte(pci_dev, 0x59, &temp);
3534 pci_write_config_byte(pci_dev, 0x59, temp);
3536 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
3538 if (pci_dev == NULL)
3540 pci_read_config_byte(pci_dev, (int) 0xB8, &temp);
3542 pci_write_config_byte(pci_dev, (int) 0xB8, (u8) temp);
3543 if (chan_nums == 6) {
3544 dwValue = inl(TRID_REG(card, ALI_SCTRL)) | 0x000f0000;
3545 outl(dwValue, TRID_REG(card, ALI_SCTRL));
3547 dwValue = inl(TRID_REG(card, ALI_SCTRL));
3548 if (dwValue & 0x2000000) {
3549 ali_ac97_write(card->ac97_codec[0], 0x02, 8080);
3550 ali_ac97_write(card->ac97_codec[0], 0x36, 0);
3551 ali_ac97_write(card->ac97_codec[0], 0x38, 0);
3553 * On a board with a single codec you won't get the
3554 * surround. On other boards configure it.
3556 if (card->ac97_codec[1] != NULL) {
3557 ali_ac97_write(card->ac97_codec[1], 0x36, 0);
3558 ali_ac97_write(card->ac97_codec[1], 0x38, 0);
3559 ali_ac97_write(card->ac97_codec[1], 0x02, 0x0606);
3560 ali_ac97_write(card->ac97_codec[1], 0x18, 0x0303);
3561 ali_ac97_write(card->ac97_codec[1], 0x74, 0x3);
3570 ali_free_pcm_channel(struct trident_card *card, unsigned int channel)
3577 bank = channel >> 5;
3578 channel = channel & 0x1f;
3580 card->banks[bank].bitmap &= ~(1 << (channel));
3584 ali_allocate_other_states_resources(struct trident_state *state, int chan_nums)
3586 struct trident_card *card = state->card;
3587 struct trident_state *s;
3588 int i, state_count = 0;
3589 struct trident_pcm_bank *bank;
3590 struct trident_channel *channel;
3593 bank = &card->banks[BANK_A];
3598 for (i = 0; (i < ALI_CHANNELS) && (state_count != 4); i++) {
3599 if (card->states[i])
3602 num = ali_multi_channels_5_1[state_count];
3603 if (!(bank->bitmap & (1 << num))) {
3604 bank->bitmap |= 1 << num;
3605 channel = &bank->channels[num];
3609 for (; state_count >= 0; state_count--) {
3610 kfree(state->other_states[state_count]);
3611 num = ali_multi_channels_5_1[state_count];
3612 ali_free_pcm_channel(card, num);
3616 s = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
3618 num = ali_multi_channels_5_1[state_count];
3619 ali_free_pcm_channel(card, num);
3621 for (; state_count >= 0; state_count--) {
3622 num = ali_multi_channels_5_1[state_count];
3623 ali_free_pcm_channel(card, num);
3624 kfree(state->other_states[state_count]);
3628 memset(s, 0, sizeof(*state));
3630 s->dmabuf.channel = channel;
3631 s->dmabuf.ossfragshift = s->dmabuf.ossmaxfrags =
3632 s->dmabuf.subdivision = 0;
3633 init_waitqueue_head(&s->dmabuf.wait);
3634 s->magic = card->magic;
3637 ali_enable_special_channel(s);
3638 state->other_states[state_count++] = s;
3641 if (state_count != 4) {
3643 for (; state_count >= 0; state_count--) {
3644 kfree(state->other_states[state_count]);
3645 num = ali_multi_channels_5_1[state_count];
3646 ali_free_pcm_channel(card, num);
3654 ali_save_regs(struct trident_card *card)
3656 unsigned long flags;
3659 spin_lock_irqsave(&card->lock, flags);
3661 ali_registers.global_regs[0x2c] = inl(TRID_REG(card, T4D_MISCINT));
3662 //ali_registers.global_regs[0x20] = inl(TRID_REG(card,T4D_START_A));
3663 ali_registers.global_regs[0x21] = inl(TRID_REG(card, T4D_STOP_A));
3665 //disable all IRQ bits
3666 outl(ALI_DISABLE_ALL_IRQ, TRID_REG(card, T4D_MISCINT));
3668 for (i = 1; i < ALI_MIXER_REGS; i++)
3669 ali_registers.mixer_regs[i] = ali_ac97_read(card->ac97_codec[0],
3672 for (i = 0; i < ALI_GLOBAL_REGS; i++) {
3673 if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A))
3675 ali_registers.global_regs[i] = inl(TRID_REG(card, i * 4));
3678 for (i = 0; i < ALI_CHANNELS; i++) {
3679 outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
3680 for (j = 0; j < ALI_CHANNEL_REGS; j++)
3681 ali_registers.channel_regs[i][j] = inl(TRID_REG(card,
3685 //Stop all HW channel
3686 outl(ALI_STOP_ALL_CHANNELS, TRID_REG(card, T4D_STOP_A));
3688 spin_unlock_irqrestore(&card->lock, flags);
3692 ali_restore_regs(struct trident_card *card)
3694 unsigned long flags;
3697 spin_lock_irqsave(&card->lock, flags);
3699 for (i = 1; i < ALI_MIXER_REGS; i++)
3700 ali_ac97_write(card->ac97_codec[0], i * 2,
3701 ali_registers.mixer_regs[i]);
3703 for (i = 0; i < ALI_CHANNELS; i++) {
3704 outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
3705 for (j = 0; j < ALI_CHANNEL_REGS; j++)
3706 outl(ali_registers.channel_regs[i][j],
3707 TRID_REG(card, j * 4 + 0xe0));
3710 for (i = 0; i < ALI_GLOBAL_REGS; i++) {
3711 if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A) ||
3712 (i * 4 == T4D_START_A))
3714 outl(ali_registers.global_regs[i], TRID_REG(card, i * 4));
3718 outl(ali_registers.global_regs[0x20], TRID_REG(card, T4D_START_A));
3719 //restore IRQ enable bits
3720 outl(ali_registers.global_regs[0x2c], TRID_REG(card, T4D_MISCINT));
3722 spin_unlock_irqrestore(&card->lock, flags);
3726 trident_suspend(struct pci_dev *dev, u32 unused)
3728 struct trident_card *card = pci_get_drvdata(dev);
3730 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
3731 ali_save_regs(card);
3737 trident_resume(struct pci_dev *dev)
3739 struct trident_card *card = pci_get_drvdata(dev);
3741 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
3742 ali_restore_regs(card);
3747 static struct trident_channel *
3748 ali_alloc_pcm_channel(struct trident_card *card)
3750 struct trident_pcm_bank *bank;
3753 bank = &card->banks[BANK_A];
3755 if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) &
3756 (ALI_SPDIF_OUT_CH_ENABLE)) {
3757 idx = ALI_SPDIF_OUT_CHANNEL;
3758 if (!(bank->bitmap & (1 << idx))) {
3759 struct trident_channel *channel = &bank->channels[idx];
3760 bank->bitmap |= 1 << idx;
3766 for (idx = ALI_PCM_OUT_CHANNEL_FIRST; idx <= ALI_PCM_OUT_CHANNEL_LAST;
3768 if (!(bank->bitmap & (1 << idx))) {
3769 struct trident_channel *channel = &bank->channels[idx];
3770 bank->bitmap |= 1 << idx;
3776 /* no more free channels avaliable */
3778 printk(KERN_ERR "ali: no more channels available on Bank A.\n");
3783 static struct trident_channel *
3784 ali_alloc_rec_pcm_channel(struct trident_card *card)
3786 struct trident_pcm_bank *bank;
3789 if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) & ALI_SPDIF_IN_SUPPORT)
3790 idx = ALI_SPDIF_IN_CHANNEL;
3792 idx = ALI_PCM_IN_CHANNEL;
3794 bank = &card->banks[BANK_A];
3796 if (!(bank->bitmap & (1 << idx))) {
3797 struct trident_channel *channel = &bank->channels[idx];
3798 bank->bitmap |= 1 << idx;
3803 /* no free recordable channels avaliable */
3805 printk(KERN_ERR "ali: no recordable channels available on Bank A.\n");
3811 ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate)
3813 unsigned char ch_st_sel;
3814 unsigned short status_rate;
3821 status_rate = 0x300;
3825 status_rate = 0x200;
3829 /* select spdif_out */
3830 ch_st_sel = inb(TRID_REG(card, ALI_SPDIF_CTRL)) & ALI_SPDIF_OUT_CH_STATUS;
3832 ch_st_sel |= 0x80; /* select right */
3833 outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
3834 outb(status_rate | 0x20, TRID_REG(card, ALI_SPDIF_CS + 2));
3836 ch_st_sel &= (~0x80); /* select left */
3837 outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
3838 outw(status_rate | 0x10, TRID_REG(card, ALI_SPDIF_CS + 2));
3842 ali_address_interrupt(struct trident_card *card)
3845 struct trident_state *state;
3846 u32 mask, channel_mask;
3848 mask = trident_get_interrupt_mask(card, 0);
3849 for (i = 0; i < NR_HW_CH; i++) {
3850 if ((state = card->states[i]) == NULL)
3852 channel = state->dmabuf.channel->num;
3853 if ((channel_mask = 1 << channel) & mask) {
3854 mask &= ~channel_mask;
3855 trident_ack_channel_interrupt(card, channel);
3857 state->dmabuf.update_flag |= ALI_ADDRESS_INT_UPDATE;
3858 trident_update_ptr(state);
3862 for (i = 0; i < NR_HW_CH; i++) {
3863 if (mask & (1 << i)) {
3864 printk("ali: spurious channel irq %d.\n", i);
3865 trident_ack_channel_interrupt(card, i);
3866 trident_stop_voice(card, i);
3867 trident_disable_voice_irq(card, i);
3873 /* Updating the values of counters of other_states' DMAs without lock
3874 protection is no harm because all DMAs of multi-channels and interrupt
3875 depend on a master state's DMA, and changing the counters of the master
3876 state DMA is protected by a spinlock.
3879 ali_write_5_1(struct trident_state *state, const char __user *buf,
3880 int cnt_for_multi_channel, unsigned int *copy_count,
3881 unsigned int *state_cnt)
3884 struct dmabuf *dmabuf = &state->dmabuf;
3885 struct dmabuf *dmabuf_temp;
3886 const char __user *buffer = buf;
3887 unsigned swptr, other_dma_nums, sample_s;
3888 unsigned int i, loop;
3891 sample_s = sample_size[dmabuf->fmt] >> 1;
3892 swptr = dmabuf->swptr;
3894 if ((i = state->multi_channels_adjust_count) > 0) {
3896 if (copy_from_user(dmabuf->rawbuf + swptr,
3899 seek_offset(swptr, buffer, cnt_for_multi_channel,
3900 sample_s, *copy_count);
3902 (*state_cnt) += sample_s;
3903 state->multi_channels_adjust_count++;
3905 i = i - (state->chans_num - other_dma_nums);
3906 for (; (i < other_dma_nums) && (cnt_for_multi_channel > 0); i++) {
3907 dmabuf_temp = &state->other_states[i]->dmabuf;
3908 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3911 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3912 sample_s, *copy_count);
3914 if (cnt_for_multi_channel == 0)
3915 state->multi_channels_adjust_count += i;
3917 if (cnt_for_multi_channel > 0) {
3918 loop = cnt_for_multi_channel / (state->chans_num * sample_s);
3919 for (i = 0; i < loop; i++) {
3920 if (copy_from_user(dmabuf->rawbuf + swptr, buffer,
3923 seek_offset(swptr, buffer, cnt_for_multi_channel,
3924 sample_s * 2, *copy_count);
3925 (*state_cnt) += (sample_s * 2);
3927 dmabuf_temp = &state->other_states[0]->dmabuf;
3928 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3931 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3932 sample_s, *copy_count);
3934 dmabuf_temp = &state->other_states[1]->dmabuf;
3935 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3938 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3939 sample_s, *copy_count);
3941 dmabuf_temp = &state->other_states[2]->dmabuf;
3942 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3945 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3946 sample_s, *copy_count);
3948 dmabuf_temp = &state->other_states[3]->dmabuf;
3949 if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
3952 seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
3953 sample_s, *copy_count);
3956 if (cnt_for_multi_channel > 0) {
3957 state->multi_channels_adjust_count = cnt_for_multi_channel / sample_s;
3959 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, sample_s))
3961 seek_offset(swptr, buffer, cnt_for_multi_channel,
3962 sample_s, *copy_count);
3963 (*state_cnt) += sample_s;
3965 if (cnt_for_multi_channel > 0) {
3966 if (copy_from_user(dmabuf->rawbuf + swptr,
3969 seek_offset(swptr, buffer, cnt_for_multi_channel,
3970 sample_s, *copy_count);
3971 (*state_cnt) += sample_s;
3973 if (cnt_for_multi_channel > 0) {
3974 int diff = state->chans_num - other_dma_nums;
3975 loop = state->multi_channels_adjust_count - diff;
3976 for (i = 0; i < loop; i++) {
3977 dmabuf_temp = &state->other_states[i]->dmabuf;
3978 if (copy_from_user(dmabuf_temp->rawbuf +
3982 seek_offset(dmabuf_temp->swptr, buffer,
3983 cnt_for_multi_channel,
3984 sample_s, *copy_count);
3989 state->multi_channels_adjust_count = 0;
3991 for (i = 0; i < other_dma_nums; i++) {
3992 dmabuf_temp = &state->other_states[i]->dmabuf;
3993 dmabuf_temp->swptr = dmabuf_temp->swptr % dmabuf_temp->dmasize;
3999 ali_free_other_states_resources(struct trident_state *state)
4002 struct trident_card *card = state->card;
4003 struct trident_state *s;
4004 unsigned other_states_count;
4006 other_states_count = state->chans_num - 2; /* except PCM L/R channels */
4007 for (i = 0; i < other_states_count; i++) {
4008 s = state->other_states[i];
4009 dealloc_dmabuf(&s->dmabuf, card->pci_dev);
4010 ali_disable_special_channel(s->card, s->dmabuf.channel->num);
4011 state->card->free_pcm_channel(s->card, s->dmabuf.channel->num);
4012 card->states[s->virt] = NULL;
4017 struct proc_dir_entry *res;
4019 ali_write_proc(struct file *file, const char __user *buffer, unsigned long count, void *data)
4021 struct trident_card *card = (struct trident_card *) data;
4022 unsigned long flags;
4029 if (get_user(c, buffer))
4032 spin_lock_irqsave(&card->lock, flags);
4035 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4036 ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
4039 ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
4043 ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
4044 ALI_SPDIF_OUT_NON_PCM);
4047 ali_disable_spdif_in(card); //default
4050 ali_setup_spdif_in(card);
4053 spin_unlock_irqrestore(&card->lock, flags);
4058 /* OSS /dev/mixer file operation methods */
4060 trident_open_mixdev(struct inode *inode, struct file *file)
4063 int minor = iminor(inode);
4064 struct trident_card *card = devs;
4066 for (card = devs; card != NULL; card = card->next)
4067 for (i = 0; i < NR_AC97; i++)
4068 if (card->ac97_codec[i] != NULL &&
4069 card->ac97_codec[i]->dev_mixer == minor)
4076 file->private_data = card->ac97_codec[i];
4078 return nonseekable_open(inode, file);
4082 trident_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4085 struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
4087 return codec->mixer_ioctl(codec, cmd, arg);
4090 static /*const */ struct file_operations trident_mixer_fops = {
4091 .owner = THIS_MODULE,
4092 .llseek = no_llseek,
4093 .ioctl = trident_ioctl_mixdev,
4094 .open = trident_open_mixdev,
4098 ali_reset_5451(struct trident_card *card)
4100 struct pci_dev *pci_dev = NULL;
4102 unsigned short wCount, wReg;
4104 pci_dev = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
4106 if (pci_dev == NULL)
4109 pci_read_config_dword(pci_dev, 0x7c, &dwVal);
4110 pci_write_config_dword(pci_dev, 0x7c, dwVal | 0x08000000);
4112 pci_read_config_dword(pci_dev, 0x7c, &dwVal);
4113 pci_write_config_dword(pci_dev, 0x7c, dwVal & 0xf7ffffff);
4116 pci_dev = card->pci_dev;
4117 if (pci_dev == NULL)
4120 pci_read_config_dword(pci_dev, 0x44, &dwVal);
4121 pci_write_config_dword(pci_dev, 0x44, dwVal | 0x000c0000);
4123 pci_read_config_dword(pci_dev, 0x44, &dwVal);
4124 pci_write_config_dword(pci_dev, 0x44, dwVal & 0xfffbffff);
4127 /* TODO: recognize if we have a PM capable codec and only do this */
4128 /* if the codec is PM capable */
4131 wReg = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
4132 if ((wReg & 0x000f) == 0x000f)
4136 /* This is non fatal if you have a non PM capable codec.. */
4140 /* AC97 codec initialisation. */
4141 static int __devinit
4142 trident_ac97_init(struct trident_card *card)
4145 unsigned long ready_2nd = 0;
4146 struct ac97_codec *codec;
4149 /* initialize controller side of AC link, and find out if secondary codes
4151 switch (card->pci_id) {
4152 case PCI_DEVICE_ID_ALI_5451:
4153 if (ali_reset_5451(card)) {
4154 printk(KERN_ERR "trident_ac97_init: error "
4155 "resetting 5451.\n");
4158 outl(0x80000001, TRID_REG(card, ALI_GLOBAL_CONTROL));
4159 outl(0x00000000, TRID_REG(card, T4D_AINTEN_A));
4160 outl(0xffffffff, TRID_REG(card, T4D_AINT_A));
4161 outl(0x00000000, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
4162 outb(0x10, TRID_REG(card, ALI_MPUR2));
4163 ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
4164 ready_2nd &= 0x3fff;
4165 outl(ready_2nd | PCMOUT | 0x8000, TRID_REG(card, ALI_SCTRL));
4166 ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
4167 ready_2nd &= SI_AC97_SECONDARY_READY;
4168 if (card->revision < ALI_5451_V02)
4171 case PCI_DEVICE_ID_SI_7018:
4172 /* disable AC97 GPIO interrupt */
4173 outl(0x00, TRID_REG(card, SI_AC97_GPIO));
4174 /* when power up the AC link is in cold reset mode so stop it */
4175 outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT | SECONDARY_ID,
4176 TRID_REG(card, SI_SERIAL_INTF_CTRL));
4177 /* it take a long time to recover from a cold reset */
4178 /* (especially when you have more than one codec) */
4180 ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
4181 ready_2nd &= SI_AC97_SECONDARY_READY;
4183 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
4185 outl(DX_AC97_PLAYBACK, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
4187 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
4188 /* enable AC97 Output Slot 3,4 (PCM Left/Right Playback) */
4189 outl(NX_AC97_PCM_OUTPUT, TRID_REG(card, NX_ACR0_AC97_COM_STAT));
4190 ready_2nd = inl(TRID_REG(card, NX_ACR0_AC97_COM_STAT));
4191 ready_2nd &= NX_AC97_SECONDARY_READY;
4193 case PCI_DEVICE_ID_INTERG_5050:
4194 /* disable AC97 GPIO interrupt */
4195 outl(0x00, TRID_REG(card, SI_AC97_GPIO));
4196 /* when power up, the AC link is in cold reset mode, so stop it */
4197 outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT,
4198 TRID_REG(card, SI_SERIAL_INTF_CTRL));
4199 /* it take a long time to recover from a cold reset (especially */
4200 /* when you have more than one codec) */
4202 ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
4203 ready_2nd &= SI_AC97_SECONDARY_READY;
4207 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4208 if ((codec = ac97_alloc_codec()) == NULL)
4211 /* initialize some basic codec information, other fields */
4212 /* will be filled in ac97_probe_codec */
4213 codec->private_data = card;
4214 codec->id = num_ac97;
4216 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4217 codec->codec_read = ali_ac97_read;
4218 codec->codec_write = ali_ac97_write;
4220 codec->codec_read = trident_ac97_get;
4221 codec->codec_write = trident_ac97_set;
4224 if (ac97_probe_codec(codec) == 0)
4227 codec->dev_mixer = register_sound_mixer(&trident_mixer_fops, -1);
4228 if (codec->dev_mixer < 0) {
4229 printk(KERN_ERR "trident: couldn't register mixer!\n");
4230 ac97_release_codec(codec);
4234 card->ac97_codec[num_ac97] = codec;
4236 /* if there is no secondary codec at all, don't probe any more */
4241 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4242 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4243 if (card->ac97_codec[num_ac97] == NULL)
4245 for (i = 0; i < 64; i++) {
4246 u16 reg = ali_ac97_get(card, num_ac97, i * 2);
4247 card->mixer_regs[i][num_ac97] = reg;
4251 return num_ac97 + 1;
4254 /* Gameport functions for the cards ADC gameport */
4256 static unsigned char
4257 trident_game_read(struct gameport *gameport)
4259 struct trident_card *card = gameport->driver;
4260 return inb(TRID_REG(card, T4D_GAME_LEG));
4264 trident_game_trigger(struct gameport *gameport)
4266 struct trident_card *card = gameport->driver;
4267 outb(0xff, TRID_REG(card, T4D_GAME_LEG));
4271 trident_game_cooked_read(struct gameport *gameport, int *axes, int *buttons)
4273 struct trident_card *card = gameport->driver;
4276 *buttons = (~inb(TRID_REG(card, T4D_GAME_LEG)) >> 4) & 0xf;
4278 for (i = 0; i < 4; i++) {
4279 axes[i] = inw(TRID_REG(card, T4D_GAME_AXD) + i * sizeof (u16));
4280 if (axes[i] == 0xffff)
4288 trident_game_open(struct gameport *gameport, int mode)
4290 struct trident_card *card = gameport->driver;
4293 case GAMEPORT_MODE_COOKED:
4294 outb(0x80, TRID_REG(card, T4D_GAME_CR));
4297 case GAMEPORT_MODE_RAW:
4298 outb(0x00, TRID_REG(card, T4D_GAME_CR));
4307 /* install the driver, we do not allocate hardware channel nor DMA buffer */
4308 /* now, they are defered until "ACCESS" time (in prog_dmabuf called by */
4309 /* open/read/write/ioctl/mmap) */
4310 static int __devinit
4311 trident_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
4313 unsigned long iobase;
4314 struct trident_card *card;
4319 struct pci_dev *pci_dev_m1533 = NULL;
4323 if (pci_enable_device(pci_dev))
4326 if (pci_dev->device == PCI_DEVICE_ID_ALI_5451)
4327 dma_mask = ALI_DMA_MASK;
4329 dma_mask = TRIDENT_DMA_MASK;
4330 if (pci_set_dma_mask(pci_dev, dma_mask)) {
4331 printk(KERN_ERR "trident: architecture does not support"
4332 " %s PCI busmaster DMA\n",
4333 pci_dev->device == PCI_DEVICE_ID_ALI_5451 ?
4334 "32-bit" : "30-bit");
4337 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
4339 if (pci_id->device == PCI_DEVICE_ID_INTERG_5050)
4340 iobase = pci_resource_start(pci_dev, 1);
4342 iobase = pci_resource_start(pci_dev, 0);
4344 if (!request_region(iobase, 256, card_names[pci_id->driver_data])) {
4345 printk(KERN_ERR "trident: can't allocate I/O space at "
4346 "0x%4.4lx\n", iobase);
4351 if ((card = kmalloc(sizeof(*card), GFP_KERNEL)) == NULL) {
4352 printk(KERN_ERR "trident: out of memory\n");
4353 goto out_release_region;
4355 memset(card, 0, sizeof (*card));
4357 init_timer(&card->timer);
4358 card->iobase = iobase;
4359 card->pci_dev = pci_dev;
4360 card->pci_id = pci_id->device;
4361 card->revision = revision;
4362 card->irq = pci_dev->irq;
4364 card->magic = TRIDENT_CARD_MAGIC;
4365 card->banks[BANK_A].addresses = &bank_a_addrs;
4366 card->banks[BANK_A].bitmap = 0UL;
4367 card->banks[BANK_B].addresses = &bank_b_addrs;
4368 card->banks[BANK_B].bitmap = 0UL;
4370 card->gameport.driver = card;
4371 card->gameport.fuzz = 64;
4372 card->gameport.read = trident_game_read;
4373 card->gameport.trigger = trident_game_trigger;
4374 card->gameport.cooked_read = trident_game_cooked_read;
4375 card->gameport.open = trident_game_open;
4377 init_MUTEX(&card->open_sem);
4378 spin_lock_init(&card->lock);
4379 init_timer(&card->timer);
4383 pci_set_master(pci_dev);
4385 printk(KERN_INFO "trident: %s found at IO 0x%04lx, IRQ %d\n",
4386 card_names[pci_id->driver_data], card->iobase, card->irq);
4388 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4389 /* ALi channel Management */
4390 card->alloc_pcm_channel = ali_alloc_pcm_channel;
4391 card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
4392 card->free_pcm_channel = ali_free_pcm_channel;
4394 card->address_interrupt = ali_address_interrupt;
4396 /* Added by Matt Wu 01-05-2001 for spdif in */
4397 card->multi_channel_use_count = 0;
4398 card->rec_channel_use_count = 0;
4400 /* ALi SPDIF OUT function */
4401 if (card->revision == ALI_5451_V02) {
4402 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4403 res = create_proc_entry("ALi5451", 0, NULL);
4405 res->write_proc = ali_write_proc;
4410 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4412 pci_dev_m1533 = pci_find_device(PCI_VENDOR_ID_AL,
4413 PCI_DEVICE_ID_AL_M1533,
4416 if (pci_dev_m1533 == NULL)
4418 pci_read_config_byte(pci_dev_m1533, 0x63, &bits);
4419 if (bits & (1 << 5))
4421 if (card->hwvolctl) {
4422 /* Clear m1533 pci cfg 78h bit 30 to zero, which makes
4423 GPIO11/12/13 work as ACGP_UP/DOWN/MUTE. */
4424 pci_read_config_byte(pci_dev_m1533, 0x7b, &bits);
4425 bits &= 0xbf; /*clear bit 6 */
4426 pci_write_config_byte(pci_dev_m1533, 0x7b, bits);
4428 } else if (card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
4429 card->alloc_pcm_channel = cyber_alloc_pcm_channel;
4430 card->alloc_rec_pcm_channel = cyber_alloc_pcm_channel;
4431 card->free_pcm_channel = cyber_free_pcm_channel;
4432 card->address_interrupt = cyber_address_interrupt;
4433 cyber_init_ritual(card);
4435 card->alloc_pcm_channel = trident_alloc_pcm_channel;
4436 card->alloc_rec_pcm_channel = trident_alloc_pcm_channel;
4437 card->free_pcm_channel = trident_free_pcm_channel;
4438 card->address_interrupt = trident_address_interrupt;
4443 if (request_irq(card->irq, &trident_interrupt, SA_SHIRQ,
4444 card_names[pci_id->driver_data], card)) {
4445 printk(KERN_ERR "trident: unable to allocate irq %d\n",
4449 /* register /dev/dsp */
4450 if ((card->dev_audio = register_sound_dsp(&trident_audio_fops, -1)) < 0) {
4451 printk(KERN_ERR "trident: couldn't register DSP device!\n");
4454 card->mixer_regs_ready = 0;
4455 /* initialize AC97 codec and register /dev/mixer */
4456 if (trident_ac97_init(card) <= 0) {
4457 /* unregister audio devices */
4458 for (i = 0; i < NR_AC97; i++) {
4459 if (card->ac97_codec[i] != NULL) {
4460 struct ac97_codec* codec = card->ac97_codec[i];
4461 unregister_sound_mixer(codec->dev_mixer);
4462 ac97_release_codec(codec);
4465 goto out_unregister_sound_dsp;
4467 card->mixer_regs_ready = 1;
4468 outl(0x00, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
4470 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4471 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4472 if (card->hwvolctl) {
4473 /* Enable GPIO IRQ (MISCINT bit 18h) */
4474 temp = inw(TRID_REG(card, T4D_MISCINT + 2));
4476 outw(temp, TRID_REG(card, T4D_MISCINT + 2));
4478 /* Enable H/W Volume Control GLOVAL CONTROL bit 0 */
4479 temp = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
4481 outw(temp, TRID_REG(card, ALI_GLOBAL_CONTROL));
4484 if (card->revision == ALI_5451_V02)
4485 ali_close_multi_channels();
4486 /* edited by HMSEO for GT sound */
4487 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
4490 extern struct hwrpb_struct *hwrpb;
4492 if ((hwrpb->sys_type) == 201) {
4493 printk(KERN_INFO "trident: Running on Alpha system "
4495 ac97_data = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
4496 ali_ac97_set(card, 0, AC97_POWER_CONTROL,
4497 ac97_data | ALI_EAPD_POWER_DOWN);
4500 #endif /* CONFIG_ALPHA_NAUTILUS || CONFIG_ALPHA_GENERIC */
4501 /* edited by HMSEO for GT sound */
4504 pci_set_drvdata(pci_dev, card);
4506 /* Enable Address Engine Interrupts */
4507 trident_enable_loop_interrupts(card);
4509 /* Register gameport */
4510 gameport_register_port(&card->gameport);
4515 out_unregister_sound_dsp:
4516 unregister_sound_dsp(card->dev_audio);
4518 free_irq(card->irq, card);
4521 remove_proc_entry("ALi5451", NULL);
4527 release_region(iobase, 256);
4531 static void __devexit
4532 trident_remove(struct pci_dev *pci_dev)
4535 struct trident_card *card = pci_get_drvdata(pci_dev);
4538 * Kill running timers before unload. We can't have them
4539 * going off after rmmod!
4542 del_timer_sync(&card->timer);
4544 /* ALi S/PDIF and Power Management */
4545 if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
4546 ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
4547 ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
4548 ali_disable_spdif_in(card);
4549 remove_proc_entry("ALi5451", NULL);
4552 /* Unregister gameport */
4553 gameport_unregister_port(&card->gameport);
4555 /* Kill interrupts, and SP/DIF */
4556 trident_disable_loop_interrupts(card);
4558 /* free hardware resources */
4559 free_irq(card->irq, card);
4560 release_region(card->iobase, 256);
4562 /* unregister audio devices */
4563 for (i = 0; i < NR_AC97; i++)
4564 if (card->ac97_codec[i] != NULL) {
4565 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
4566 ac97_release_codec(card->ac97_codec[i]);
4568 unregister_sound_dsp(card->dev_audio);
4572 pci_set_drvdata(pci_dev, NULL);
4575 MODULE_AUTHOR("Alan Cox, Aaron Holtzman, Ollie Lho, Ching Ling Lee, Muli Ben-Yehuda");
4576 MODULE_DESCRIPTION("Trident 4DWave/SiS 7018/ALi 5451 and Tvia/IGST CyberPro5050 PCI "
4578 MODULE_LICENSE("GPL");
4580 #define TRIDENT_MODULE_NAME "trident"
4582 static struct pci_driver trident_pci_driver = {
4583 .name = TRIDENT_MODULE_NAME,
4584 .id_table = trident_pci_tbl,
4585 .probe = trident_probe,
4586 .remove = __devexit_p(trident_remove),
4587 .suspend = trident_suspend,
4588 .resume = trident_resume
4592 trident_init_module(void)
4594 printk(KERN_INFO "Trident 4DWave/SiS 7018/ALi 5451,Tvia CyberPro "
4595 "5050 PCI Audio, version " DRIVER_VERSION ", " __TIME__ " "
4598 if (!pci_register_driver(&trident_pci_driver)) {
4599 pci_unregister_driver(&trident_pci_driver);
4606 trident_cleanup_module(void)
4608 pci_unregister_driver(&trident_pci_driver);
4611 module_init(trident_init_module);
4612 module_exit(trident_cleanup_module);