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_mutex - guard opens
194 * sem - guard dmabuf, write re-entry etc
197 #include <linux/module.h>
198 #include <linux/string.h>
199 #include <linux/ctype.h>
200 #include <linux/ioport.h>
201 #include <linux/sched.h>
202 #include <linux/delay.h>
203 #include <linux/sound.h>
204 #include <linux/slab.h>
205 #include <linux/soundcard.h>
206 #include <linux/pci.h>
207 #include <linux/init.h>
208 #include <linux/poll.h>
209 #include <linux/spinlock.h>
210 #include <linux/ac97_codec.h>
211 #include <linux/bitops.h>
212 #include <linux/proc_fs.h>
213 #include <linux/interrupt.h>
214 #include <linux/pm.h>
215 #include <linux/gameport.h>
216 #include <linux/kernel.h>
217 #include <linux/mutex.h>
218 #include <linux/mm.h>
220 #include <asm/uaccess.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 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
233 #define SUPPORT_JOYSTICK 1
236 /* magic numbers to protect our data structures */
237 #define TRIDENT_CARD_MAGIC 0x5072696E /* "Prin" */
238 #define TRIDENT_STATE_MAGIC 0x63657373 /* "cess" */
240 #define TRIDENT_DMA_MASK 0x3fffffff /* DMA buffer mask for pci_alloc_consist */
241 #define ALI_DMA_MASK 0x7fffffff /* ALI Tridents have 31-bit DMA. Wow. */
245 /* maximum number of AC97 codecs connected, AC97 2.0 defined 4, but 7018 and 4D-NX only
246 have 2 SDATA_IN lines (currently) */
249 /* minor number of /dev/swmodem (temporary, experimental) */
250 #define SND_DEV_SWMODEM 7
252 static const unsigned ali_multi_channels_5_1
[] = {
253 /*ALI_SURR_LEFT_CHANNEL, ALI_SURR_RIGHT_CHANNEL, */
256 ALI_SURR_LEFT_CHANNEL
,
257 ALI_SURR_RIGHT_CHANNEL
260 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
261 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
263 static const char invalid_magic
[] = KERN_CRIT
"trident: invalid magic value in %s\n";
273 static char *card_names
[] = {
276 "SiS 7018 PCI Audio",
277 "ALi Audio Accelerator",
278 "Tvia/IGST CyberPro 5050"
281 static struct pci_device_id trident_pci_tbl
[] = {
282 {PCI_DEVICE(PCI_VENDOR_ID_TRIDENT
, PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
),
283 PCI_CLASS_MULTIMEDIA_AUDIO
<< 8, 0xffff00, TRIDENT_4D_DX
},
284 {PCI_DEVICE(PCI_VENDOR_ID_TRIDENT
, PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
),
285 0, 0, TRIDENT_4D_NX
},
286 {PCI_DEVICE(PCI_VENDOR_ID_SI
, PCI_DEVICE_ID_SI_7018
), 0, 0, SIS_7018
},
287 {PCI_DEVICE(PCI_VENDOR_ID_ALI
, PCI_DEVICE_ID_ALI_5451
), 0, 0, ALI_5451
},
288 {PCI_DEVICE(PCI_VENDOR_ID_INTERG
, PCI_DEVICE_ID_INTERG_5050
),
293 MODULE_DEVICE_TABLE(pci
, trident_pci_tbl
);
295 /* "software" or virtual channel, an instance of opened /dev/dsp */
296 struct trident_state
{
298 struct trident_card
*card
; /* Card info */
303 /* virtual channel number */
307 /* wave sample stuff */
309 unsigned char fmt
, enable
;
311 /* hardware channel */
312 struct trident_channel
*channel
;
314 /* OSS buffer management stuff */
316 dma_addr_t dma_handle
;
321 /* our buffer acts like a circular ring */
322 unsigned hwptr
; /* where dma last started, updated by update_ptr */
323 unsigned swptr
; /* where driver last clear/filled, updated by read/write */
324 int count
; /* bytes to be comsumed or been generated by dma machine */
325 unsigned total_bytes
; /* total bytes dmaed by hardware */
327 unsigned error
; /* number of over/underruns */
328 /* put process on wait queue when no more space in buffer */
329 wait_queue_head_t wait
;
331 /* redundant, but makes calculations easier */
334 unsigned fragsamples
;
339 unsigned endcleared
:1;
340 unsigned update_flag
;
341 unsigned ossfragshift
;
343 unsigned subdivision
;
348 struct trident_state
*other_states
[4];
349 int multi_channels_adjust_count
;
351 unsigned long fmt_flag
;
352 /* Guard against mmap/write/read races */
357 /* hardware channels */
358 struct trident_channel
{
359 int num
; /* channel number */
360 u32 lba
; /* Loop Begine Address, where dma buffer starts */
361 u32 eso
; /* End Sample Offset, wehre dma buffer ends */
362 /* (in the unit of samples) */
363 u32 delta
; /* delta value, sample rate / 48k for playback, */
364 /* 48k/sample rate for recording */
365 u16 attribute
; /* control where PCM data go and come */
367 u32 control
; /* signed/unsigned, 8/16 bits, mono/stereo */
370 struct trident_pcm_bank_address
{
377 static struct trident_pcm_bank_address bank_a_addrs
= {
384 static struct trident_pcm_bank_address bank_b_addrs
= {
391 struct trident_pcm_bank
{
392 /* register addresses to control bank operations */
393 struct trident_pcm_bank_address
*addresses
;
394 /* each bank has 32 channels */
395 u32 bitmap
; /* channel allocation bitmap */
396 struct trident_channel channels
[32];
399 struct trident_card
{
402 /* We keep trident cards in a linked list */
403 struct trident_card
*next
;
405 /* single open lock mechanism, only used for recording */
406 struct mutex open_mutex
;
408 /* The trident has a certain amount of cross channel interaction
409 so we use a single per card lock */
412 /* PCI device stuff */
413 struct pci_dev
*pci_dev
;
417 /* soundcore stuff */
420 /* structures for abstraction of hardware facilities, codecs, */
421 /* banks and channels */
422 struct ac97_codec
*ac97_codec
[NR_AC97
];
423 struct trident_pcm_bank banks
[NR_BANKS
];
424 struct trident_state
*states
[NR_HW_CH
];
426 /* hardware resources */
427 unsigned long iobase
;
430 /* Function support */
431 struct trident_channel
*(*alloc_pcm_channel
) (struct trident_card
*);
432 struct trident_channel
*(*alloc_rec_pcm_channel
) (struct trident_card
*);
433 void (*free_pcm_channel
) (struct trident_card
*, unsigned int chan
);
434 void (*address_interrupt
) (struct trident_card
*);
436 /* Added by Matt Wu 01-05-2001 for spdif in */
437 int multi_channel_use_count
;
438 int rec_channel_use_count
;
439 u16 mixer_regs
[64][NR_AC97
]; /* Made card local by Alan */
440 int mixer_regs_ready
;
442 /* Added for hardware volume control */
444 struct timer_list timer
;
446 /* Game port support */
447 struct gameport
*gameport
;
455 /* table to map from CHANNELMASK to channel attribute for SiS 7018 */
456 static u16 mask2attr
[] = {
457 PCM_LR
, PCM_LR
, SURR_LR
, CENTER_LFE
,
458 HSET
, MIC
, MODEM_LINE1
, MODEM_LINE2
,
462 /* table to map from channel attribute to CHANNELMASK for SiS 7018 */
463 static int attr2mask
[] = {
464 DSP_BIND_MODEM1
, DSP_BIND_MODEM2
, DSP_BIND_FRONT
, DSP_BIND_HANDSET
,
465 DSP_BIND_I2S
, DSP_BIND_CENTER_LFE
, DSP_BIND_SURR
, DSP_BIND_SPDIF
468 /* Added by Matt Wu 01-05-2001 for spdif in */
469 static int ali_close_multi_channels(void);
470 static void ali_delay(struct trident_card
*card
, int interval
);
471 static void ali_detect_spdif_rate(struct trident_card
*card
);
473 static void ali_ac97_write(struct ac97_codec
*codec
, u8 reg
, u16 val
);
474 static u16
ali_ac97_read(struct ac97_codec
*codec
, u8 reg
);
476 static struct trident_card
*devs
;
478 static void trident_ac97_set(struct ac97_codec
*codec
, u8 reg
, u16 val
);
479 static u16
trident_ac97_get(struct ac97_codec
*codec
, u8 reg
);
481 static int trident_open_mixdev(struct inode
*inode
, struct file
*file
);
482 static int trident_ioctl_mixdev(struct inode
*inode
, struct file
*file
,
483 unsigned int cmd
, unsigned long arg
);
485 static void ali_ac97_set(struct trident_card
*card
, int secondary
, u8 reg
, u16 val
);
486 static u16
ali_ac97_get(struct trident_card
*card
, int secondary
, u8 reg
);
487 static void ali_set_spdif_out_rate(struct trident_card
*card
, unsigned int rate
);
488 static void ali_enable_special_channel(struct trident_state
*stat
);
489 static struct trident_channel
*ali_alloc_rec_pcm_channel(struct trident_card
*card
);
490 static struct trident_channel
*ali_alloc_pcm_channel(struct trident_card
*card
);
491 static void ali_free_pcm_channel(struct trident_card
*card
, unsigned int channel
);
492 static int ali_setup_multi_channels(struct trident_card
*card
, int chan_nums
);
493 static unsigned int ali_get_spdif_in_rate(struct trident_card
*card
);
494 static void ali_setup_spdif_in(struct trident_card
*card
);
495 static void ali_disable_spdif_in(struct trident_card
*card
);
496 static void ali_disable_special_channel(struct trident_card
*card
, int ch
);
497 static void ali_setup_spdif_out(struct trident_card
*card
, int flag
);
498 static int ali_write_5_1(struct trident_state
*state
,
499 const char __user
*buffer
,
500 int cnt_for_multi_channel
, unsigned int *copy_count
,
501 unsigned int *state_cnt
);
502 static int ali_allocate_other_states_resources(struct trident_state
*state
,
504 static void ali_free_other_states_resources(struct trident_state
*state
);
506 #define seek_offset(dma_ptr, buffer, cnt, offset, copy_count) do { \
507 (dma_ptr) += (offset); \
508 (buffer) += (offset); \
510 (copy_count) += (offset); \
513 static inline int lock_set_fmt(struct trident_state
* state
)
515 if (test_and_set_bit(0, &state
->fmt_flag
))
521 static inline void unlock_set_fmt(struct trident_state
* state
)
523 clear_bit(0, &state
->fmt_flag
);
527 trident_enable_loop_interrupts(struct trident_card
*card
)
531 global_control
= inl(TRID_REG(card
, T4D_LFO_GC_CIR
));
533 switch (card
->pci_id
) {
534 case PCI_DEVICE_ID_SI_7018
:
535 global_control
|= (ENDLP_IE
| MIDLP_IE
| BANK_B_EN
);
537 case PCI_DEVICE_ID_ALI_5451
:
538 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
:
539 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
:
540 case PCI_DEVICE_ID_INTERG_5050
:
541 global_control
|= (ENDLP_IE
| MIDLP_IE
);
547 outl(global_control
, TRID_REG(card
, T4D_LFO_GC_CIR
));
549 pr_debug("trident: Enable Loop Interrupts, globctl = 0x%08X\n",
550 inl(TRID_REG(card
, T4D_LFO_GC_CIR
)));
556 trident_disable_loop_interrupts(struct trident_card
*card
)
560 global_control
= inl(TRID_REG(card
, T4D_LFO_GC_CIR
));
561 global_control
&= ~(ENDLP_IE
| MIDLP_IE
);
562 outl(global_control
, TRID_REG(card
, T4D_LFO_GC_CIR
));
564 pr_debug("trident: Disabled Loop Interrupts, globctl = 0x%08X\n",
571 trident_enable_voice_irq(struct trident_card
*card
, unsigned int channel
)
573 unsigned int mask
= 1 << (channel
& 0x1f);
574 struct trident_pcm_bank
*bank
= &card
->banks
[channel
>> 5];
575 u32 reg
, addr
= bank
->addresses
->aint_en
;
577 reg
= inl(TRID_REG(card
, addr
));
579 outl(reg
, TRID_REG(card
, addr
));
582 reg
= inl(TRID_REG(card
, addr
));
583 pr_debug("trident: enabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
584 channel
, addr
== T4D_AINTEN_B
? "AINTEN_B" : "AINTEN_A",
590 trident_disable_voice_irq(struct trident_card
*card
, unsigned int channel
)
592 unsigned int mask
= 1 << (channel
& 0x1f);
593 struct trident_pcm_bank
*bank
= &card
->banks
[channel
>> 5];
594 u32 reg
, addr
= bank
->addresses
->aint_en
;
596 reg
= inl(TRID_REG(card
, addr
));
598 outl(reg
, TRID_REG(card
, addr
));
600 /* Ack the channel in case the interrupt was set before we disable it. */
601 outl(mask
, TRID_REG(card
, bank
->addresses
->aint
));
604 reg
= inl(TRID_REG(card
, addr
));
605 pr_debug("trident: disabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
606 channel
, addr
== T4D_AINTEN_B
? "AINTEN_B" : "AINTEN_A",
612 trident_start_voice(struct trident_card
*card
, unsigned int channel
)
614 unsigned int mask
= 1 << (channel
& 0x1f);
615 struct trident_pcm_bank
*bank
= &card
->banks
[channel
>> 5];
616 u32 addr
= bank
->addresses
->start
;
622 outl(mask
, TRID_REG(card
, addr
));
625 reg
= inl(TRID_REG(card
, addr
));
626 pr_debug("trident: start voice on channel %d, %s = 0x%08x(addr:%X)\n",
627 channel
, addr
== T4D_START_B
? "START_B" : "START_A",
633 trident_stop_voice(struct trident_card
*card
, unsigned int channel
)
635 unsigned int mask
= 1 << (channel
& 0x1f);
636 struct trident_pcm_bank
*bank
= &card
->banks
[channel
>> 5];
637 u32 addr
= bank
->addresses
->stop
;
643 outl(mask
, TRID_REG(card
, addr
));
646 reg
= inl(TRID_REG(card
, addr
));
647 pr_debug("trident: stop voice on channel %d, %s = 0x%08x(addr:%X)\n",
648 channel
, addr
== T4D_STOP_B
? "STOP_B" : "STOP_A",
654 trident_get_interrupt_mask(struct trident_card
*card
, unsigned int channel
)
656 struct trident_pcm_bank
*bank
= &card
->banks
[channel
];
657 u32 addr
= bank
->addresses
->aint
;
658 return inl(TRID_REG(card
, addr
));
662 trident_check_channel_interrupt(struct trident_card
*card
, unsigned int channel
)
664 unsigned int mask
= 1 << (channel
& 0x1f);
665 u32 reg
= trident_get_interrupt_mask(card
, channel
>> 5);
669 pr_debug("trident: channel %d has interrupt, %s = 0x%08x\n",
670 channel
, reg
== T4D_AINT_B
? "AINT_B" : "AINT_A",
673 return (reg
& mask
) ? 1 : 0;
677 trident_ack_channel_interrupt(struct trident_card
*card
, unsigned int channel
)
679 unsigned int mask
= 1 << (channel
& 0x1f);
680 struct trident_pcm_bank
*bank
= &card
->banks
[channel
>> 5];
681 u32 reg
, addr
= bank
->addresses
->aint
;
683 reg
= inl(TRID_REG(card
, addr
));
685 outl(reg
, TRID_REG(card
, addr
));
688 reg
= inl(TRID_REG(card
, T4D_AINT_B
));
689 pr_debug("trident: Ack channel %d interrupt, AINT_B = 0x%08x\n",
694 static struct trident_channel
*
695 trident_alloc_pcm_channel(struct trident_card
*card
)
697 struct trident_pcm_bank
*bank
;
700 bank
= &card
->banks
[BANK_B
];
702 for (idx
= 31; idx
>= 0; idx
--) {
703 if (!(bank
->bitmap
& (1 << idx
))) {
704 struct trident_channel
*channel
= &bank
->channels
[idx
];
705 bank
->bitmap
|= 1 << idx
;
706 channel
->num
= idx
+ 32;
711 /* no more free channels available */
712 printk(KERN_ERR
"trident: no more channels available on Bank B.\n");
717 trident_free_pcm_channel(struct trident_card
*card
, unsigned int channel
)
722 if (channel
< 31 || channel
> 63)
725 if (card
->pci_id
== PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
||
726 card
->pci_id
== PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
) {
727 b
= inb(TRID_REG(card
, T4D_REC_CH
));
728 if ((b
& ~0x80) == channel
)
729 outb(0x0, TRID_REG(card
, T4D_REC_CH
));
733 channel
= channel
& 0x1f;
735 card
->banks
[bank
].bitmap
&= ~(1 << (channel
));
738 static struct trident_channel
*
739 cyber_alloc_pcm_channel(struct trident_card
*card
)
741 struct trident_pcm_bank
*bank
;
744 /* The cyberpro 5050 has only 32 voices and one bank */
745 /* .. at least they are not documented (if you want to call that
746 * crap documentation), perhaps broken ? */
748 bank
= &card
->banks
[BANK_A
];
750 for (idx
= 31; idx
>= 0; idx
--) {
751 if (!(bank
->bitmap
& (1 << idx
))) {
752 struct trident_channel
*channel
= &bank
->channels
[idx
];
753 bank
->bitmap
|= 1 << idx
;
759 /* no more free channels available */
760 printk(KERN_ERR
"cyberpro5050: no more channels available on Bank A.\n");
765 cyber_free_pcm_channel(struct trident_card
*card
, unsigned int channel
)
769 card
->banks
[BANK_A
].bitmap
&= ~(1 << (channel
));
773 cyber_outidx(int port
, int idx
, int data
)
776 outb(data
, port
+ 1);
780 cyber_inidx(int port
, int idx
)
783 return inb(port
+ 1);
787 cyber_init_ritual(struct trident_card
*card
)
789 /* some black magic, taken from SDK samples */
790 /* remove this and nothing will work */
796 * Keep interrupts off for the configure - we don't want to
797 * clash with another cyberpro config event
800 spin_lock_irqsave(&card
->lock
, flags
);
801 portDat
= cyber_inidx(CYBER_PORT_AUDIO
, CYBER_IDX_AUDIO_ENABLE
);
802 /* enable, if it was disabled */
803 if ((portDat
& CYBER_BMSK_AUENZ
) != CYBER_BMSK_AUENZ_ENABLE
) {
804 printk(KERN_INFO
"cyberpro5050: enabling audio controller\n");
805 cyber_outidx(CYBER_PORT_AUDIO
, CYBER_IDX_AUDIO_ENABLE
,
806 portDat
| CYBER_BMSK_AUENZ_ENABLE
);
807 /* check again if hardware is enabled now */
808 portDat
= cyber_inidx(CYBER_PORT_AUDIO
, CYBER_IDX_AUDIO_ENABLE
);
810 if ((portDat
& CYBER_BMSK_AUENZ
) != CYBER_BMSK_AUENZ_ENABLE
) {
811 printk(KERN_ERR
"cyberpro5050: initAudioAccess: no success\n");
814 cyber_outidx(CYBER_PORT_AUDIO
, CYBER_IDX_IRQ_ENABLE
,
815 CYBER_BMSK_AUDIO_INT_ENABLE
);
816 cyber_outidx(CYBER_PORT_AUDIO
, 0xbf, 0x01);
817 cyber_outidx(CYBER_PORT_AUDIO
, 0xba, 0x20);
818 cyber_outidx(CYBER_PORT_AUDIO
, 0xbb, 0x08);
819 cyber_outidx(CYBER_PORT_AUDIO
, 0xbf, 0x02);
820 cyber_outidx(CYBER_PORT_AUDIO
, 0xb3, 0x06);
821 cyber_outidx(CYBER_PORT_AUDIO
, 0xbf, 0x00);
823 spin_unlock_irqrestore(&card
->lock
, flags
);
827 /* called with spin lock held */
830 trident_load_channel_registers(struct trident_card
*card
, u32
* data
,
831 unsigned int channel
)
838 /* select hardware channel to write */
839 outb(channel
, TRID_REG(card
, T4D_LFO_GC_CIR
));
841 /* Output the channel registers, but don't write register
842 three to an ALI chip. */
843 for (i
= 0; i
< CHANNEL_REGS
; i
++) {
844 if (i
== 3 && card
->pci_id
== PCI_DEVICE_ID_ALI_5451
)
846 outl(data
[i
], TRID_REG(card
, CHANNEL_START
+ 4 * i
));
848 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
||
849 card
->pci_id
== PCI_DEVICE_ID_INTERG_5050
) {
850 outl(ALI_EMOD_Still
, TRID_REG(card
, ALI_EBUF1
));
851 outl(ALI_EMOD_Still
, TRID_REG(card
, ALI_EBUF2
));
856 /* called with spin lock held */
858 trident_write_voice_regs(struct trident_state
*state
)
860 unsigned int data
[CHANNEL_REGS
+ 1];
861 struct trident_channel
*channel
;
863 channel
= state
->dmabuf
.channel
;
865 data
[1] = channel
->lba
;
866 data
[4] = channel
->control
;
868 switch (state
->card
->pci_id
) {
869 case PCI_DEVICE_ID_ALI_5451
:
870 data
[0] = 0; /* Current Sample Offset */
871 data
[2] = (channel
->eso
<< 16) | (channel
->delta
& 0xffff);
874 case PCI_DEVICE_ID_SI_7018
:
875 case PCI_DEVICE_ID_INTERG_5050
:
876 data
[0] = 0; /* Current Sample Offset */
877 data
[2] = (channel
->eso
<< 16) | (channel
->delta
& 0xffff);
878 data
[3] = (channel
->attribute
<< 16) | (channel
->fm_vol
& 0xffff);
880 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
:
881 data
[0] = 0; /* Current Sample Offset */
882 data
[2] = (channel
->eso
<< 16) | (channel
->delta
& 0xffff);
883 data
[3] = channel
->fm_vol
& 0xffff;
885 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
:
886 data
[0] = (channel
->delta
<< 24);
887 data
[2] = ((channel
->delta
<< 16) & 0xff000000) |
888 (channel
->eso
& 0x00ffffff);
889 data
[3] = channel
->fm_vol
& 0xffff;
895 return trident_load_channel_registers(state
->card
, data
, channel
->num
);
899 compute_rate_play(u32 rate
)
902 /* We special case 44100 and 8000 since rounding with the equation
903 does not give us an accurate enough value. For 11025 and 22050
904 the equation gives us the best answer. All other frequencies will
905 also use the equation. JDW */
908 else if (rate
== 8000)
910 else if (rate
== 48000)
913 delta
= (((rate
<< 12) + rate
) / 48000) & 0x0000ffff;
918 compute_rate_rec(u32 rate
)
924 else if (rate
== 8000)
926 else if (rate
== 48000)
929 delta
= ((48000 << 12) / rate
) & 0x0000ffff;
934 /* set playback sample rate */
936 trident_set_dac_rate(struct trident_state
*state
, unsigned int rate
)
938 struct dmabuf
*dmabuf
= &state
->dmabuf
;
946 dmabuf
->channel
->delta
= compute_rate_play(rate
);
948 trident_write_voice_regs(state
);
950 pr_debug("trident: called trident_set_dac_rate : rate = %d\n", rate
);
955 /* set recording sample rate */
957 trident_set_adc_rate(struct trident_state
*state
, unsigned int rate
)
959 struct dmabuf
*dmabuf
= &state
->dmabuf
;
967 dmabuf
->channel
->delta
= compute_rate_rec(rate
);
969 trident_write_voice_regs(state
);
971 pr_debug("trident: called trident_set_adc_rate : rate = %d\n", rate
);
976 /* prepare channel attributes for playback */
978 trident_play_setup(struct trident_state
*state
)
980 struct dmabuf
*dmabuf
= &state
->dmabuf
;
981 struct trident_channel
*channel
= dmabuf
->channel
;
983 channel
->lba
= dmabuf
->dma_handle
;
984 channel
->delta
= compute_rate_play(dmabuf
->rate
);
986 channel
->eso
= dmabuf
->dmasize
>> sample_shift
[dmabuf
->fmt
];
989 if (state
->card
->pci_id
!= PCI_DEVICE_ID_SI_7018
) {
990 channel
->attribute
= 0;
991 if (state
->card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
992 if ((channel
->num
== ALI_SPDIF_IN_CHANNEL
) ||
993 (channel
->num
== ALI_PCM_IN_CHANNEL
))
994 ali_disable_special_channel(state
->card
, channel
->num
);
995 else if ((inl(TRID_REG(state
->card
, ALI_GLOBAL_CONTROL
))
996 & ALI_SPDIF_OUT_CH_ENABLE
)
997 && (channel
->num
== ALI_SPDIF_OUT_CHANNEL
)) {
998 ali_set_spdif_out_rate(state
->card
,
1000 state
->dmabuf
.channel
->delta
= 0x1000;
1005 channel
->fm_vol
= 0x0;
1007 channel
->control
= CHANNEL_LOOP
;
1008 if (dmabuf
->fmt
& TRIDENT_FMT_16BIT
) {
1010 channel
->control
|= CHANNEL_16BITS
;
1012 channel
->control
|= CHANNEL_SIGNED
;
1014 if (dmabuf
->fmt
& TRIDENT_FMT_STEREO
)
1016 channel
->control
|= CHANNEL_STEREO
;
1018 pr_debug("trident: trident_play_setup, LBA = 0x%08x, Delta = 0x%08x, "
1019 "ESO = 0x%08x, Control = 0x%08x\n", channel
->lba
,
1020 channel
->delta
, channel
->eso
, channel
->control
);
1022 trident_write_voice_regs(state
);
1025 /* prepare channel attributes for recording */
1027 trident_rec_setup(struct trident_state
*state
)
1032 struct trident_card
*card
= state
->card
;
1033 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1034 struct trident_channel
*channel
= dmabuf
->channel
;
1037 /* Enable AC-97 ADC (capture) */
1038 switch (card
->pci_id
) {
1039 case PCI_DEVICE_ID_ALI_5451
:
1040 ali_enable_special_channel(state
);
1042 case PCI_DEVICE_ID_SI_7018
:
1043 /* for 7018, the ac97 is always in playback/record (duplex) mode */
1045 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
:
1046 w
= inb(TRID_REG(card
, DX_ACR2_AC97_COM_STAT
));
1047 outb(w
| 0x48, TRID_REG(card
, DX_ACR2_AC97_COM_STAT
));
1048 /* enable and set record channel */
1049 outb(0x80 | channel
->num
, TRID_REG(card
, T4D_REC_CH
));
1051 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
:
1052 w
= inw(TRID_REG(card
, T4D_MISCINT
));
1053 outw(w
| 0x1000, TRID_REG(card
, T4D_MISCINT
));
1054 /* enable and set record channel */
1055 outb(0x80 | channel
->num
, TRID_REG(card
, T4D_REC_CH
));
1057 case PCI_DEVICE_ID_INTERG_5050
:
1058 /* don't know yet, using special channel 22 in GC1(0xd4)? */
1064 channel
->lba
= dmabuf
->dma_handle
;
1065 channel
->delta
= compute_rate_rec(dmabuf
->rate
);
1066 if ((card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) &&
1067 (channel
->num
== ALI_SPDIF_IN_CHANNEL
)) {
1068 rate
= ali_get_spdif_in_rate(card
);
1070 printk(KERN_WARNING
"trident: ALi 5451 "
1071 "S/PDIF input setup error!\n");
1074 bval
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
));
1076 outb(bval
, TRID_REG(card
, ALI_SPDIF_CTRL
));
1077 printk(KERN_WARNING
"trident: cleared ALi "
1078 "5451 S/PDIF parity error flag.\n");
1082 channel
->delta
= ((rate
<< 12) / dmabuf
->rate
) & 0x0000ffff;
1085 channel
->eso
= dmabuf
->dmasize
>> sample_shift
[dmabuf
->fmt
];
1088 if (state
->card
->pci_id
!= PCI_DEVICE_ID_SI_7018
) {
1089 channel
->attribute
= 0;
1092 channel
->fm_vol
= 0x0;
1094 channel
->control
= CHANNEL_LOOP
;
1095 if (dmabuf
->fmt
& TRIDENT_FMT_16BIT
) {
1097 channel
->control
|= CHANNEL_16BITS
;
1099 channel
->control
|= CHANNEL_SIGNED
;
1101 if (dmabuf
->fmt
& TRIDENT_FMT_STEREO
)
1103 channel
->control
|= CHANNEL_STEREO
;
1105 pr_debug("trident: trident_rec_setup, LBA = 0x%08x, Delat = 0x%08x, "
1106 "ESO = 0x%08x, Control = 0x%08x\n", channel
->lba
,
1107 channel
->delta
, channel
->eso
, channel
->control
);
1109 trident_write_voice_regs(state
);
1112 /* get current playback/recording dma buffer pointer (byte offset from LBA),
1113 called with spinlock held! */
1114 static inline unsigned
1115 trident_get_dma_addr(struct trident_state
*state
)
1117 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1120 if (!dmabuf
->enable
)
1123 outb(dmabuf
->channel
->num
, TRID_REG(state
->card
, T4D_LFO_GC_CIR
));
1125 switch (state
->card
->pci_id
) {
1126 case PCI_DEVICE_ID_ALI_5451
:
1127 case PCI_DEVICE_ID_SI_7018
:
1128 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
:
1129 case PCI_DEVICE_ID_INTERG_5050
:
1130 /* 16 bits ESO, CSO for 7018 and DX */
1131 cso
= inw(TRID_REG(state
->card
, CH_DX_CSO_ALPHA_FMS
+ 2));
1133 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
:
1134 /* 24 bits ESO, CSO for NX */
1135 cso
= inl(TRID_REG(state
->card
, CH_NX_DELTA_CSO
)) & 0x00ffffff;
1141 pr_debug("trident: trident_get_dma_addr: chip reported channel: %d, "
1142 "cso = 0x%04x\n", dmabuf
->channel
->num
, cso
);
1144 /* ESO and CSO are in units of Samples, convert to byte offset */
1145 cso
<<= sample_shift
[dmabuf
->fmt
];
1147 return (cso
% dmabuf
->dmasize
);
1150 /* Stop recording (lock held) */
1152 __stop_adc(struct trident_state
*state
)
1154 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1155 unsigned int chan_num
= dmabuf
->channel
->num
;
1156 struct trident_card
*card
= state
->card
;
1158 dmabuf
->enable
&= ~ADC_RUNNING
;
1159 trident_stop_voice(card
, chan_num
);
1160 trident_disable_voice_irq(card
, chan_num
);
1164 stop_adc(struct trident_state
*state
)
1166 struct trident_card
*card
= state
->card
;
1167 unsigned long flags
;
1169 spin_lock_irqsave(&card
->lock
, flags
);
1171 spin_unlock_irqrestore(&card
->lock
, flags
);
1175 start_adc(struct trident_state
*state
)
1177 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1178 unsigned int chan_num
= dmabuf
->channel
->num
;
1179 struct trident_card
*card
= state
->card
;
1180 unsigned long flags
;
1182 spin_lock_irqsave(&card
->lock
, flags
);
1183 if ((dmabuf
->mapped
||
1184 dmabuf
->count
< (signed) dmabuf
->dmasize
) &&
1186 dmabuf
->enable
|= ADC_RUNNING
;
1187 trident_enable_voice_irq(card
, chan_num
);
1188 trident_start_voice(card
, chan_num
);
1190 spin_unlock_irqrestore(&card
->lock
, flags
);
1193 /* stop playback (lock held) */
1195 __stop_dac(struct trident_state
*state
)
1197 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1198 unsigned int chan_num
= dmabuf
->channel
->num
;
1199 struct trident_card
*card
= state
->card
;
1201 dmabuf
->enable
&= ~DAC_RUNNING
;
1202 trident_stop_voice(card
, chan_num
);
1203 if (state
->chans_num
== 6) {
1204 trident_stop_voice(card
, state
->other_states
[0]->
1205 dmabuf
.channel
->num
);
1206 trident_stop_voice(card
, state
->other_states
[1]->
1207 dmabuf
.channel
->num
);
1208 trident_stop_voice(card
, state
->other_states
[2]->
1209 dmabuf
.channel
->num
);
1210 trident_stop_voice(card
, state
->other_states
[3]->
1211 dmabuf
.channel
->num
);
1213 trident_disable_voice_irq(card
, chan_num
);
1217 stop_dac(struct trident_state
*state
)
1219 struct trident_card
*card
= state
->card
;
1220 unsigned long flags
;
1222 spin_lock_irqsave(&card
->lock
, flags
);
1224 spin_unlock_irqrestore(&card
->lock
, flags
);
1228 start_dac(struct trident_state
*state
)
1230 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1231 unsigned int chan_num
= dmabuf
->channel
->num
;
1232 struct trident_card
*card
= state
->card
;
1233 unsigned long flags
;
1235 spin_lock_irqsave(&card
->lock
, flags
);
1236 if ((dmabuf
->mapped
|| dmabuf
->count
> 0) && dmabuf
->ready
) {
1237 dmabuf
->enable
|= DAC_RUNNING
;
1238 trident_enable_voice_irq(card
, chan_num
);
1239 trident_start_voice(card
, chan_num
);
1240 if (state
->chans_num
== 6) {
1241 trident_start_voice(card
, state
->other_states
[0]->
1242 dmabuf
.channel
->num
);
1243 trident_start_voice(card
, state
->other_states
[1]->
1244 dmabuf
.channel
->num
);
1245 trident_start_voice(card
, state
->other_states
[2]->
1246 dmabuf
.channel
->num
);
1247 trident_start_voice(card
, state
->other_states
[3]->
1248 dmabuf
.channel
->num
);
1251 spin_unlock_irqrestore(&card
->lock
, flags
);
1254 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
1255 #define DMABUF_MINORDER 1
1257 /* alloc a DMA buffer of with a buffer of this order */
1259 alloc_dmabuf(struct dmabuf
*dmabuf
, struct pci_dev
*pci_dev
, int order
)
1261 void *rawbuf
= NULL
;
1262 struct page
*page
, *pend
;
1264 if (!(rawbuf
= pci_alloc_consistent(pci_dev
, PAGE_SIZE
<< order
,
1265 &dmabuf
->dma_handle
)))
1268 pr_debug("trident: allocated %ld (order = %d) bytes at %p\n",
1269 PAGE_SIZE
<< order
, order
, rawbuf
);
1271 dmabuf
->ready
= dmabuf
->mapped
= 0;
1272 dmabuf
->rawbuf
= rawbuf
;
1273 dmabuf
->buforder
= order
;
1275 /* now mark the pages as reserved; otherwise */
1276 /* remap_pfn_range doesn't do what we want */
1277 pend
= virt_to_page(rawbuf
+ (PAGE_SIZE
<< order
) - 1);
1278 for (page
= virt_to_page(rawbuf
); page
<= pend
; page
++)
1279 SetPageReserved(page
);
1284 /* allocate the main DMA buffer, playback and recording buffer should be */
1285 /* allocated separately */
1287 alloc_main_dmabuf(struct trident_state
*state
)
1289 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1293 /* alloc as big a chunk as we can, FIXME: is this necessary ?? */
1294 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--) {
1295 if (!(ret
= alloc_dmabuf(dmabuf
, state
->card
->pci_dev
, order
)))
1297 /* else try again */
1302 /* deallocate a DMA buffer */
1304 dealloc_dmabuf(struct dmabuf
*dmabuf
, struct pci_dev
*pci_dev
)
1306 struct page
*page
, *pend
;
1308 if (dmabuf
->rawbuf
) {
1309 /* undo marking the pages as reserved */
1310 pend
= virt_to_page(dmabuf
->rawbuf
+ (PAGE_SIZE
<< dmabuf
->buforder
) - 1);
1311 for (page
= virt_to_page(dmabuf
->rawbuf
); page
<= pend
; page
++)
1312 ClearPageReserved(page
);
1313 pci_free_consistent(pci_dev
, PAGE_SIZE
<< dmabuf
->buforder
,
1314 dmabuf
->rawbuf
, dmabuf
->dma_handle
);
1315 dmabuf
->rawbuf
= NULL
;
1317 dmabuf
->mapped
= dmabuf
->ready
= 0;
1321 prog_dmabuf(struct trident_state
*state
, enum dmabuf_mode rec
)
1323 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1324 unsigned bytepersec
;
1325 struct trident_state
*s
= state
;
1326 unsigned bufsize
, dma_nums
;
1327 unsigned long flags
;
1330 if ((ret
= lock_set_fmt(state
)) < 0)
1333 if (state
->chans_num
== 6)
1338 for (i
= 0; i
< dma_nums
; i
++) {
1340 s
= state
->other_states
[i
- 1];
1341 dmabuf
= &s
->dmabuf
;
1342 dmabuf
->fmt
= state
->dmabuf
.fmt
;
1343 dmabuf
->rate
= state
->dmabuf
.rate
;
1346 spin_lock_irqsave(&s
->card
->lock
, flags
);
1347 dmabuf
->hwptr
= dmabuf
->swptr
= dmabuf
->total_bytes
= 0;
1348 dmabuf
->count
= dmabuf
->error
= 0;
1349 spin_unlock_irqrestore(&s
->card
->lock
, flags
);
1351 /* allocate DMA buffer if not allocated yet */
1352 if (!dmabuf
->rawbuf
) {
1354 if ((ret
= alloc_main_dmabuf(state
))) {
1355 unlock_set_fmt(state
);
1360 order
= state
->dmabuf
.buforder
- 1;
1361 if (order
>= DMABUF_MINORDER
) {
1362 ret
= alloc_dmabuf(dmabuf
,
1363 state
->card
->pci_dev
,
1367 /* release the main DMA buffer */
1368 dealloc_dmabuf(&state
->dmabuf
, state
->card
->pci_dev
);
1369 /* release the auxiliary DMA buffers */
1370 for (i
-= 2; i
>= 0; i
--)
1371 dealloc_dmabuf(&state
->other_states
[i
]->dmabuf
,
1372 state
->card
->pci_dev
);
1373 unlock_set_fmt(state
);
1378 /* FIXME: figure out all this OSS fragment stuff */
1379 bytepersec
= dmabuf
->rate
<< sample_shift
[dmabuf
->fmt
];
1380 bufsize
= PAGE_SIZE
<< dmabuf
->buforder
;
1381 if (dmabuf
->ossfragshift
) {
1382 if ((1000 << dmabuf
->ossfragshift
) < bytepersec
)
1383 dmabuf
->fragshift
= ld2(bytepersec
/ 1000);
1385 dmabuf
->fragshift
= dmabuf
->ossfragshift
;
1387 /* lets hand out reasonable big ass buffers by default */
1388 dmabuf
->fragshift
= (dmabuf
->buforder
+ PAGE_SHIFT
- 2);
1390 dmabuf
->numfrag
= bufsize
>> dmabuf
->fragshift
;
1391 while (dmabuf
->numfrag
< 4 && dmabuf
->fragshift
> 3) {
1392 dmabuf
->fragshift
--;
1393 dmabuf
->numfrag
= bufsize
>> dmabuf
->fragshift
;
1395 dmabuf
->fragsize
= 1 << dmabuf
->fragshift
;
1396 if (dmabuf
->ossmaxfrags
>= 4 && dmabuf
->ossmaxfrags
< dmabuf
->numfrag
)
1397 dmabuf
->numfrag
= dmabuf
->ossmaxfrags
;
1398 dmabuf
->fragsamples
= dmabuf
->fragsize
>> sample_shift
[dmabuf
->fmt
];
1399 dmabuf
->dmasize
= dmabuf
->numfrag
<< dmabuf
->fragshift
;
1401 memset(dmabuf
->rawbuf
, (dmabuf
->fmt
& TRIDENT_FMT_16BIT
) ? 0 : 0x80,
1404 spin_lock_irqsave(&s
->card
->lock
, flags
);
1405 if (rec
== DM_RECORD
)
1406 trident_rec_setup(s
);
1407 else /* DM_PLAYBACK */
1408 trident_play_setup(s
);
1410 spin_unlock_irqrestore(&s
->card
->lock
, flags
);
1412 /* set the ready flag for the dma buffer */
1415 pr_debug("trident: prog_dmabuf(%d), sample rate = %d, "
1416 "format = %d, numfrag = %d, fragsize = %d "
1417 "dmasize = %d\n", dmabuf
->channel
->num
,
1418 dmabuf
->rate
, dmabuf
->fmt
, dmabuf
->numfrag
,
1419 dmabuf
->fragsize
, dmabuf
->dmasize
);
1421 unlock_set_fmt(state
);
1426 static inline int prog_dmabuf_record(struct trident_state
* state
)
1428 return prog_dmabuf(state
, DM_RECORD
);
1431 static inline int prog_dmabuf_playback(struct trident_state
* state
)
1433 return prog_dmabuf(state
, DM_PLAYBACK
);
1436 /* we are doing quantum mechanics here, the buffer can only be empty, half or full filled i.e.
1437 |------------|------------| or |xxxxxxxxxxxx|------------| or |xxxxxxxxxxxx|xxxxxxxxxxxx|
1438 but we almost always get this
1439 |xxxxxx------|------------| or |xxxxxxxxxxxx|xxxxx-------|
1440 so we have to clear the tail space to "silence"
1441 |xxxxxx000000|------------| or |xxxxxxxxxxxx|xxxxxx000000|
1444 trident_clear_tail(struct trident_state
*state
)
1446 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1448 unsigned char silence
= (dmabuf
->fmt
& TRIDENT_FMT_16BIT
) ? 0 : 0x80;
1450 unsigned long flags
;
1452 spin_lock_irqsave(&state
->card
->lock
, flags
);
1453 swptr
= dmabuf
->swptr
;
1454 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
1456 if (swptr
== 0 || swptr
== dmabuf
->dmasize
/ 2 ||
1457 swptr
== dmabuf
->dmasize
)
1460 if (swptr
< dmabuf
->dmasize
/ 2)
1461 len
= dmabuf
->dmasize
/ 2 - swptr
;
1463 len
= dmabuf
->dmasize
- swptr
;
1465 memset(dmabuf
->rawbuf
+ swptr
, silence
, len
);
1466 if (state
->card
->pci_id
!= PCI_DEVICE_ID_ALI_5451
) {
1467 spin_lock_irqsave(&state
->card
->lock
, flags
);
1468 dmabuf
->swptr
+= len
;
1469 dmabuf
->count
+= len
;
1470 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
1473 /* restart the dma machine in case it is halted */
1478 drain_dac(struct trident_state
*state
, int nonblock
)
1480 DECLARE_WAITQUEUE(wait
, current
);
1481 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1482 unsigned long flags
;
1485 unsigned long diff
= 0;
1487 if (dmabuf
->mapped
|| !dmabuf
->ready
)
1490 add_wait_queue(&dmabuf
->wait
, &wait
);
1492 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1493 every time to make the process really go to sleep */
1494 set_current_state(TASK_INTERRUPTIBLE
);
1496 spin_lock_irqsave(&state
->card
->lock
, flags
);
1497 count
= dmabuf
->count
;
1498 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
1503 if (signal_pending(current
))
1507 remove_wait_queue(&dmabuf
->wait
, &wait
);
1508 set_current_state(TASK_RUNNING
);
1512 /* No matter how much data is left in the buffer, we have to wait until
1513 CSO == ESO/2 or CSO == ESO when address engine interrupts */
1514 if (state
->card
->pci_id
== PCI_DEVICE_ID_ALI_5451
||
1515 state
->card
->pci_id
== PCI_DEVICE_ID_INTERG_5050
) {
1516 diff
= dmabuf
->swptr
- trident_get_dma_addr(state
) + dmabuf
->dmasize
;
1517 diff
= diff
% (dmabuf
->dmasize
);
1518 tmo
= (diff
* HZ
) / dmabuf
->rate
;
1520 tmo
= (dmabuf
->dmasize
* HZ
) / dmabuf
->rate
;
1522 tmo
>>= sample_shift
[dmabuf
->fmt
];
1523 if (!schedule_timeout(tmo
? tmo
: 1) && tmo
) {
1527 remove_wait_queue(&dmabuf
->wait
, &wait
);
1528 set_current_state(TASK_RUNNING
);
1529 if (signal_pending(current
))
1530 return -ERESTARTSYS
;
1535 /* update buffer manangement pointers, especially, */
1536 /* dmabuf->count and dmabuf->hwptr */
1538 trident_update_ptr(struct trident_state
*state
)
1540 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1541 unsigned hwptr
, swptr
;
1544 unsigned char silence
;
1545 unsigned half_dmasize
;
1547 /* update hardware pointer */
1548 hwptr
= trident_get_dma_addr(state
);
1549 diff
= (dmabuf
->dmasize
+ hwptr
- dmabuf
->hwptr
) % dmabuf
->dmasize
;
1550 dmabuf
->hwptr
= hwptr
;
1551 dmabuf
->total_bytes
+= diff
;
1553 /* error handling and process wake up for ADC */
1554 if (dmabuf
->enable
== ADC_RUNNING
) {
1555 if (dmabuf
->mapped
) {
1556 dmabuf
->count
-= diff
;
1557 if (dmabuf
->count
>= (signed) dmabuf
->fragsize
)
1558 wake_up(&dmabuf
->wait
);
1560 dmabuf
->count
+= diff
;
1562 if (dmabuf
->count
< 0 ||
1563 dmabuf
->count
> dmabuf
->dmasize
) {
1564 /* buffer underrun or buffer overrun, */
1565 /* we have no way to recover it here, just */
1566 /* stop the machine and let the process */
1567 /* force hwptr and swptr to sync */
1571 if (dmabuf
->count
< (signed) dmabuf
->dmasize
/ 2)
1572 wake_up(&dmabuf
->wait
);
1576 /* error handling and process wake up for DAC */
1577 if (dmabuf
->enable
== DAC_RUNNING
) {
1578 if (dmabuf
->mapped
) {
1579 dmabuf
->count
+= diff
;
1580 if (dmabuf
->count
>= (signed) dmabuf
->fragsize
)
1581 wake_up(&dmabuf
->wait
);
1583 dmabuf
->count
-= diff
;
1585 if (dmabuf
->count
< 0 ||
1586 dmabuf
->count
> dmabuf
->dmasize
) {
1587 /* buffer underrun or buffer overrun, we have no way to recover
1588 it here, just stop the machine and let the process force hwptr
1589 and swptr to sync */
1592 } else if (!dmabuf
->endcleared
) {
1593 swptr
= dmabuf
->swptr
;
1594 silence
= (dmabuf
->fmt
& TRIDENT_FMT_16BIT
? 0 : 0x80);
1595 if (dmabuf
->update_flag
& ALI_ADDRESS_INT_UPDATE
) {
1596 /* We must clear end data of 1/2 dmabuf if needed.
1597 According to 1/2 algorithm of Address Engine Interrupt,
1598 check the validation of the data of half dmasize. */
1599 half_dmasize
= dmabuf
->dmasize
/ 2;
1600 if ((diff
= hwptr
- half_dmasize
) < 0)
1602 if ((dmabuf
->count
+ diff
) < half_dmasize
) {
1603 //there is invalid data in the end of half buffer
1604 if ((clear_cnt
= half_dmasize
- swptr
) < 0)
1605 clear_cnt
+= half_dmasize
;
1606 //clear the invalid data
1607 memset(dmabuf
->rawbuf
+ swptr
, silence
, clear_cnt
);
1608 if (state
->chans_num
== 6) {
1609 clear_cnt
= clear_cnt
/ 2;
1611 memset(state
->other_states
[0]->dmabuf
.rawbuf
+ swptr
,
1612 silence
, clear_cnt
);
1613 memset(state
->other_states
[1]->dmabuf
.rawbuf
+ swptr
,
1614 silence
, clear_cnt
);
1615 memset(state
->other_states
[2]->dmabuf
.rawbuf
+ swptr
,
1616 silence
, clear_cnt
);
1617 memset(state
->other_states
[3]->dmabuf
.rawbuf
+ swptr
,
1618 silence
, clear_cnt
);
1620 dmabuf
->endcleared
= 1;
1622 } else if (dmabuf
->count
< (signed) dmabuf
->fragsize
) {
1623 clear_cnt
= dmabuf
->fragsize
;
1624 if ((swptr
+ clear_cnt
) > dmabuf
->dmasize
)
1625 clear_cnt
= dmabuf
->dmasize
- swptr
;
1626 memset(dmabuf
->rawbuf
+ swptr
, silence
, clear_cnt
);
1627 if (state
->chans_num
== 6) {
1628 clear_cnt
= clear_cnt
/ 2;
1630 memset(state
->other_states
[0]->dmabuf
.rawbuf
+ swptr
,
1631 silence
, clear_cnt
);
1632 memset(state
->other_states
[1]->dmabuf
.rawbuf
+ swptr
,
1633 silence
, clear_cnt
);
1634 memset(state
->other_states
[2]->dmabuf
.rawbuf
+ swptr
,
1635 silence
, clear_cnt
);
1636 memset(state
->other_states
[3]->dmabuf
.rawbuf
+ swptr
,
1637 silence
, clear_cnt
);
1639 dmabuf
->endcleared
= 1;
1642 /* trident_update_ptr is called by interrupt handler or by process via
1643 ioctl/poll, we only wake up the waiting process when we have more
1644 than 1/2 buffer free (always true for interrupt handler) */
1645 if (dmabuf
->count
< (signed) dmabuf
->dmasize
/ 2)
1646 wake_up(&dmabuf
->wait
);
1649 dmabuf
->update_flag
&= ~ALI_ADDRESS_INT_UPDATE
;
1653 trident_address_interrupt(struct trident_card
*card
)
1656 struct trident_state
*state
;
1657 unsigned int channel
;
1659 /* Update the pointers for all channels we are running. */
1660 /* FIXME: should read interrupt status only once */
1661 for (i
= 0; i
< NR_HW_CH
; i
++) {
1663 if (trident_check_channel_interrupt(card
, channel
)) {
1664 trident_ack_channel_interrupt(card
, channel
);
1665 if ((state
= card
->states
[i
]) != NULL
) {
1666 trident_update_ptr(state
);
1668 printk(KERN_WARNING
"trident: spurious channel "
1669 "irq %d.\n", channel
);
1670 trident_stop_voice(card
, channel
);
1671 trident_disable_voice_irq(card
, channel
);
1678 ali_hwvol_control(struct trident_card
*card
, int opt
)
1680 u16 dwTemp
, volume
[2], mute
, diff
, *pVol
[2];
1682 dwTemp
= ali_ac97_read(card
->ac97_codec
[0], 0x02);
1683 mute
= dwTemp
& 0x8000;
1684 volume
[0] = dwTemp
& 0x001f;
1685 volume
[1] = (dwTemp
& 0x1f00) >> 8;
1686 if (volume
[0] < volume
[1]) {
1687 pVol
[0] = &volume
[0];
1688 pVol
[1] = &volume
[1];
1690 pVol
[1] = &volume
[0];
1691 pVol
[0] = &volume
[1];
1693 diff
= *(pVol
[1]) - *(pVol
[0]);
1695 if (opt
== 1) { // MUTE
1697 ali_ac97_write(card
->ac97_codec
[0],
1699 } else if (opt
== 2) { // Down
1702 if (*(pVol
[1]) < 0x001f) {
1704 *(pVol
[0]) = *(pVol
[1]) - diff
;
1707 dwTemp
|= (volume
[0]) | (volume
[1] << 8);
1708 ali_ac97_write(card
->ac97_codec
[0], 0x02, dwTemp
);
1709 card
->ac97_codec
[0]->mixer_state
[0] = ((32 - volume
[0]) * 25 / 8) |
1710 (((32 - volume
[1]) * 25 / 8) << 8);
1711 } else if (opt
== 4) { // Up
1714 if (*(pVol
[0]) > 0) {
1716 *(pVol
[1]) = *(pVol
[0]) + diff
;
1719 dwTemp
|= (volume
[0]) | (volume
[1] << 8);
1720 ali_ac97_write(card
->ac97_codec
[0], 0x02, dwTemp
);
1721 card
->ac97_codec
[0]->mixer_state
[0] = ((32 - volume
[0]) * 25 / 8) |
1722 (((32 - volume
[1]) * 25 / 8) << 8);
1724 /* Nothing needs doing */
1729 * Re-enable reporting of vol change after 0.1 seconds
1733 ali_timeout(unsigned long ptr
)
1735 struct trident_card
*card
= (struct trident_card
*) ptr
;
1738 /* Enable GPIO IRQ (MISCINT bit 18h) */
1739 temp
= inw(TRID_REG(card
, T4D_MISCINT
+ 2));
1741 outw(temp
, TRID_REG(card
, T4D_MISCINT
+ 2));
1745 * Set up the timer to clear the vol change notification
1749 ali_set_timer(struct trident_card
*card
)
1751 /* Add Timer Routine to Enable GPIO IRQ */
1752 del_timer(&card
->timer
); /* Never queue twice */
1753 card
->timer
.function
= ali_timeout
;
1754 card
->timer
.data
= (unsigned long) card
;
1755 card
->timer
.expires
= jiffies
+ HZ
/ 10;
1756 add_timer(&card
->timer
);
1760 * Process a GPIO event
1764 ali_queue_task(struct trident_card
*card
, int opt
)
1768 /* Disable GPIO IRQ (MISCINT bit 18h) */
1769 temp
= inw(TRID_REG(card
, T4D_MISCINT
+ 2));
1770 temp
&= (u16
) (~0x0004);
1771 outw(temp
, TRID_REG(card
, T4D_MISCINT
+ 2));
1773 /* Adjust the volume */
1774 ali_hwvol_control(card
, opt
);
1776 /* Set the timer for 1/10th sec */
1777 ali_set_timer(card
);
1781 cyber_address_interrupt(struct trident_card
*card
)
1784 struct trident_state
*state
;
1785 unsigned int channel
;
1787 /* Update the pointers for all channels we are running. */
1788 /* FIXED: read interrupt status only once */
1789 irq_status
= inl(TRID_REG(card
, T4D_AINT_A
));
1791 pr_debug("cyber_address_interrupt: irq_status 0x%X\n", irq_status
);
1793 for (i
= 0; i
< NR_HW_CH
; i
++) {
1795 if (irq_status
& (1 << channel
)) {
1796 /* clear bit by writing a 1, zeroes are ignored */
1797 outl((1 << channel
), TRID_REG(card
, T4D_AINT_A
));
1799 pr_debug("cyber_interrupt: channel %d\n", channel
);
1801 if ((state
= card
->states
[i
]) != NULL
) {
1802 trident_update_ptr(state
);
1804 printk(KERN_WARNING
"cyber5050: spurious "
1805 "channel irq %d.\n", channel
);
1806 trident_stop_voice(card
, channel
);
1807 trident_disable_voice_irq(card
, channel
);
1814 trident_interrupt(int irq
, void *dev_id
)
1816 struct trident_card
*card
= (struct trident_card
*) dev_id
;
1820 spin_lock(&card
->lock
);
1821 event
= inl(TRID_REG(card
, T4D_MISCINT
));
1823 pr_debug("trident: trident_interrupt called, MISCINT = 0x%08x\n",
1826 if (event
& ADDRESS_IRQ
) {
1827 card
->address_interrupt(card
);
1830 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
1831 /* GPIO IRQ (H/W Volume Control) */
1832 event
= inl(TRID_REG(card
, T4D_MISCINT
));
1833 if (event
& (1 << 25)) {
1834 gpio
= inl(TRID_REG(card
, ALI_GPIO
));
1835 if (!timer_pending(&card
->timer
))
1836 ali_queue_task(card
, gpio
& 0x07);
1838 event
= inl(TRID_REG(card
, T4D_MISCINT
));
1839 outl(event
| (ST_TARGET_REACHED
| MIXER_OVERFLOW
| MIXER_UNDERFLOW
),
1840 TRID_REG(card
, T4D_MISCINT
));
1841 spin_unlock(&card
->lock
);
1845 /* manually clear interrupt status, bad hardware design, blame T^2 */
1846 outl((ST_TARGET_REACHED
| MIXER_OVERFLOW
| MIXER_UNDERFLOW
),
1847 TRID_REG(card
, T4D_MISCINT
));
1848 spin_unlock(&card
->lock
);
1852 /* in this loop, dmabuf.count signifies the amount of data that is waiting */
1853 /* to be copied to the user's buffer. it is filled by the dma machine and */
1854 /* drained by this loop. */
1856 trident_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
* ppos
)
1858 struct trident_state
*state
= (struct trident_state
*)file
->private_data
;
1859 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1861 unsigned long flags
;
1865 pr_debug("trident: trident_read called, count = %zd\n", count
);
1867 VALIDATE_STATE(state
);
1871 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1874 mutex_lock(&state
->sem
);
1875 if (!dmabuf
->ready
&& (ret
= prog_dmabuf_record(state
)))
1879 spin_lock_irqsave(&state
->card
->lock
, flags
);
1880 if (dmabuf
->count
> (signed) dmabuf
->dmasize
) {
1881 /* buffer overrun, we are recovering from */
1882 /* sleep_on_timeout, resync hwptr and swptr, */
1883 /* make process flush the buffer */
1884 dmabuf
->count
= dmabuf
->dmasize
;
1885 dmabuf
->swptr
= dmabuf
->hwptr
;
1887 swptr
= dmabuf
->swptr
;
1888 cnt
= dmabuf
->dmasize
- swptr
;
1889 if (dmabuf
->count
< cnt
)
1890 cnt
= dmabuf
->count
;
1891 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
1897 /* buffer is empty, start the dma machine and */
1898 /* wait for data to be recorded */
1900 if (file
->f_flags
& O_NONBLOCK
) {
1906 mutex_unlock(&state
->sem
);
1907 /* No matter how much space left in the buffer, */
1908 /* we have to wait until CSO == ESO/2 or CSO == ESO */
1909 /* when address engine interrupts */
1910 tmo
= (dmabuf
->dmasize
* HZ
) / (dmabuf
->rate
* 2);
1911 tmo
>>= sample_shift
[dmabuf
->fmt
];
1912 /* There are two situations when sleep_on_timeout returns, one is when
1913 the interrupt is serviced correctly and the process is waked up by
1914 ISR ON TIME. Another is when timeout is expired, which means that
1915 either interrupt is NOT serviced correctly (pending interrupt) or it
1916 is TOO LATE for the process to be scheduled to run (scheduler latency)
1917 which results in a (potential) buffer overrun. And worse, there is
1918 NOTHING we can do to prevent it. */
1919 if (!interruptible_sleep_on_timeout(&dmabuf
->wait
, tmo
)) {
1920 pr_debug(KERN_ERR
"trident: recording schedule timeout, "
1921 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1922 dmabuf
->dmasize
, dmabuf
->fragsize
, dmabuf
->count
,
1923 dmabuf
->hwptr
, dmabuf
->swptr
);
1925 /* a buffer overrun, we delay the recovery until next time the
1926 while loop begin and we REALLY have space to record */
1928 if (signal_pending(current
)) {
1933 mutex_lock(&state
->sem
);
1934 if (dmabuf
->mapped
) {
1942 if (copy_to_user(buffer
, dmabuf
->rawbuf
+ swptr
, cnt
)) {
1948 swptr
= (swptr
+ cnt
) % dmabuf
->dmasize
;
1950 spin_lock_irqsave(&state
->card
->lock
, flags
);
1951 dmabuf
->swptr
= swptr
;
1952 dmabuf
->count
-= cnt
;
1953 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
1961 mutex_unlock(&state
->sem
);
1965 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1966 the soundcard. it is drained by the dma machine and filled by this loop. */
1969 trident_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
* ppos
)
1971 struct trident_state
*state
= (struct trident_state
*)file
->private_data
;
1972 struct dmabuf
*dmabuf
= &state
->dmabuf
;
1974 unsigned long flags
;
1977 unsigned int state_cnt
;
1978 unsigned int copy_count
;
1979 int lret
; /* for lock_set_fmt */
1981 pr_debug("trident: trident_write called, count = %zd\n", count
);
1983 VALIDATE_STATE(state
);
1986 * Guard against an mmap or ioctl while writing
1989 mutex_lock(&state
->sem
);
1991 if (dmabuf
->mapped
) {
1995 if (!dmabuf
->ready
&& (ret
= prog_dmabuf_playback(state
)))
1998 if (!access_ok(VERIFY_READ
, buffer
, count
)) {
2006 spin_lock_irqsave(&state
->card
->lock
, flags
);
2007 if (dmabuf
->count
< 0) {
2008 /* buffer underrun, we are recovering from */
2009 /* sleep_on_timeout, resync hwptr and swptr */
2011 dmabuf
->swptr
= dmabuf
->hwptr
;
2013 swptr
= dmabuf
->swptr
;
2014 cnt
= dmabuf
->dmasize
- swptr
;
2015 if (dmabuf
->count
+ cnt
> dmabuf
->dmasize
)
2016 cnt
= dmabuf
->dmasize
- dmabuf
->count
;
2017 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2023 /* buffer is full, start the dma machine and */
2024 /* wait for data to be played */
2026 if (file
->f_flags
& O_NONBLOCK
) {
2031 /* No matter how much data left in the buffer, */
2032 /* we have to wait until CSO == ESO/2 or CSO == ESO */
2033 /* when address engine interrupts */
2034 lock_set_fmt(state
);
2035 tmo
= (dmabuf
->dmasize
* HZ
) / (dmabuf
->rate
* 2);
2036 tmo
>>= sample_shift
[dmabuf
->fmt
];
2037 unlock_set_fmt(state
);
2038 mutex_unlock(&state
->sem
);
2040 /* There are two situations when sleep_on_timeout */
2041 /* returns, one is when the interrupt is serviced */
2042 /* correctly and the process is waked up by ISR */
2043 /* ON TIME. Another is when timeout is expired, which */
2044 /* means that either interrupt is NOT serviced */
2045 /* correctly (pending interrupt) or it is TOO LATE */
2046 /* for the process to be scheduled to run */
2047 /* (scheduler latency) which results in a (potential) */
2048 /* buffer underrun. And worse, there is NOTHING we */
2049 /* can do to prevent it. */
2050 if (!interruptible_sleep_on_timeout(&dmabuf
->wait
, tmo
)) {
2051 pr_debug(KERN_ERR
"trident: playback schedule "
2052 "timeout, dmasz %u fragsz %u count %i "
2053 "hwptr %u swptr %u\n", dmabuf
->dmasize
,
2054 dmabuf
->fragsize
, dmabuf
->count
,
2055 dmabuf
->hwptr
, dmabuf
->swptr
);
2057 /* a buffer underrun, we delay the recovery */
2058 /* until next time the while loop begin and */
2059 /* we REALLY have data to play */
2061 if (signal_pending(current
)) {
2066 mutex_lock(&state
->sem
);
2067 if (dmabuf
->mapped
) {
2074 if ((lret
= lock_set_fmt(state
)) < 0) {
2079 if (state
->chans_num
== 6) {
2082 if (ali_write_5_1(state
, buffer
, cnt
, ©_count
,
2083 &state_cnt
) == -EFAULT
) {
2085 swptr
= (swptr
+ state_cnt
) % dmabuf
->dmasize
;
2086 spin_lock_irqsave(&state
->card
->lock
, flags
);
2087 dmabuf
->swptr
= swptr
;
2088 dmabuf
->count
+= state_cnt
;
2089 dmabuf
->endcleared
= 0;
2090 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2095 unlock_set_fmt(state
);
2099 if (copy_from_user(dmabuf
->rawbuf
+ swptr
,
2103 unlock_set_fmt(state
);
2108 unlock_set_fmt(state
);
2110 swptr
= (swptr
+ state_cnt
) % dmabuf
->dmasize
;
2112 spin_lock_irqsave(&state
->card
->lock
, flags
);
2113 dmabuf
->swptr
= swptr
;
2114 dmabuf
->count
+= state_cnt
;
2115 dmabuf
->endcleared
= 0;
2116 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2124 mutex_unlock(&state
->sem
);
2129 /* No kernel lock - we have our own spinlock */
2131 trident_poll(struct file
*file
, struct poll_table_struct
*wait
)
2133 struct trident_state
*state
= (struct trident_state
*)file
->private_data
;
2134 struct dmabuf
*dmabuf
= &state
->dmabuf
;
2135 unsigned long flags
;
2136 unsigned int mask
= 0;
2138 VALIDATE_STATE(state
);
2141 * Guard against a parallel poll and write causing multiple
2142 * prog_dmabuf events
2145 mutex_lock(&state
->sem
);
2147 if (file
->f_mode
& FMODE_WRITE
) {
2148 if (!dmabuf
->ready
&& prog_dmabuf_playback(state
)) {
2149 mutex_unlock(&state
->sem
);
2152 poll_wait(file
, &dmabuf
->wait
, wait
);
2154 if (file
->f_mode
& FMODE_READ
) {
2155 if (!dmabuf
->ready
&& prog_dmabuf_record(state
)) {
2156 mutex_unlock(&state
->sem
);
2159 poll_wait(file
, &dmabuf
->wait
, wait
);
2162 mutex_unlock(&state
->sem
);
2164 spin_lock_irqsave(&state
->card
->lock
, flags
);
2165 trident_update_ptr(state
);
2166 if (file
->f_mode
& FMODE_READ
) {
2167 if (dmabuf
->count
>= (signed) dmabuf
->fragsize
)
2168 mask
|= POLLIN
| POLLRDNORM
;
2170 if (file
->f_mode
& FMODE_WRITE
) {
2171 if (dmabuf
->mapped
) {
2172 if (dmabuf
->count
>= (signed) dmabuf
->fragsize
)
2173 mask
|= POLLOUT
| POLLWRNORM
;
2175 if ((signed) dmabuf
->dmasize
>= dmabuf
->count
+
2176 (signed) dmabuf
->fragsize
)
2177 mask
|= POLLOUT
| POLLWRNORM
;
2180 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2186 trident_mmap(struct file
*file
, struct vm_area_struct
*vma
)
2188 struct trident_state
*state
= (struct trident_state
*)file
->private_data
;
2189 struct dmabuf
*dmabuf
= &state
->dmabuf
;
2193 VALIDATE_STATE(state
);
2196 * Lock against poll read write or mmap creating buffers. Also lock
2197 * a read or write against an mmap.
2200 mutex_lock(&state
->sem
);
2202 if (vma
->vm_flags
& VM_WRITE
) {
2203 if ((ret
= prog_dmabuf_playback(state
)) != 0)
2205 } else if (vma
->vm_flags
& VM_READ
) {
2206 if ((ret
= prog_dmabuf_record(state
)) != 0)
2212 if (vma
->vm_pgoff
!= 0)
2214 size
= vma
->vm_end
- vma
->vm_start
;
2215 if (size
> (PAGE_SIZE
<< dmabuf
->buforder
))
2218 if (remap_pfn_range(vma
, vma
->vm_start
,
2219 virt_to_phys(dmabuf
->rawbuf
) >> PAGE_SHIFT
,
2220 size
, vma
->vm_page_prot
))
2225 mutex_unlock(&state
->sem
);
2230 trident_ioctl(struct inode
*inode
, struct file
*file
,
2231 unsigned int cmd
, unsigned long arg
)
2233 struct trident_state
*state
= (struct trident_state
*)file
->private_data
;
2234 struct dmabuf
*dmabuf
= &state
->dmabuf
;
2235 unsigned long flags
;
2236 audio_buf_info abinfo
;
2238 int val
, mapped
, ret
= 0;
2239 struct trident_card
*card
= state
->card
;
2240 void __user
*argp
= (void __user
*)arg
;
2241 int __user
*p
= argp
;
2243 VALIDATE_STATE(state
);
2246 mapped
= ((file
->f_mode
& (FMODE_WRITE
| FMODE_READ
)) && dmabuf
->mapped
);
2248 pr_debug("trident: trident_ioctl, command = %2d, arg = 0x%08x\n",
2249 _IOC_NR(cmd
), arg
? *p
: 0);
2252 case OSS_GETVERSION
:
2253 ret
= put_user(SOUND_VERSION
, p
);
2256 case SNDCTL_DSP_RESET
:
2257 /* FIXME: spin_lock ? */
2258 if (file
->f_mode
& FMODE_WRITE
) {
2260 synchronize_irq(card
->irq
);
2262 dmabuf
->swptr
= dmabuf
->hwptr
= 0;
2263 dmabuf
->count
= dmabuf
->total_bytes
= 0;
2265 if (file
->f_mode
& FMODE_READ
) {
2267 synchronize_irq(card
->irq
);
2269 dmabuf
->swptr
= dmabuf
->hwptr
= 0;
2270 dmabuf
->count
= dmabuf
->total_bytes
= 0;
2274 case SNDCTL_DSP_SYNC
:
2275 if (file
->f_mode
& FMODE_WRITE
)
2276 ret
= drain_dac(state
, file
->f_flags
& O_NONBLOCK
);
2279 case SNDCTL_DSP_SPEED
: /* set smaple rate */
2280 if (get_user(val
, p
)) {
2285 if (file
->f_mode
& FMODE_WRITE
) {
2288 spin_lock_irqsave(&state
->card
->lock
, flags
);
2289 trident_set_dac_rate(state
, val
);
2290 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2292 if (file
->f_mode
& FMODE_READ
) {
2295 spin_lock_irqsave(&state
->card
->lock
, flags
);
2296 trident_set_adc_rate(state
, val
);
2297 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2300 ret
= put_user(dmabuf
->rate
, p
);
2303 case SNDCTL_DSP_STEREO
: /* set stereo or mono channel */
2304 if (get_user(val
, p
)) {
2308 if ((ret
= lock_set_fmt(state
)) < 0)
2311 if (file
->f_mode
& FMODE_WRITE
) {
2315 dmabuf
->fmt
|= TRIDENT_FMT_STEREO
;
2317 dmabuf
->fmt
&= ~TRIDENT_FMT_STEREO
;
2319 if (file
->f_mode
& FMODE_READ
) {
2323 dmabuf
->fmt
|= TRIDENT_FMT_STEREO
;
2325 dmabuf
->fmt
&= ~TRIDENT_FMT_STEREO
;
2327 unlock_set_fmt(state
);
2330 case SNDCTL_DSP_GETBLKSIZE
:
2331 if (file
->f_mode
& FMODE_WRITE
) {
2332 if ((val
= prog_dmabuf_playback(state
)))
2335 ret
= put_user(dmabuf
->fragsize
, p
);
2338 if (file
->f_mode
& FMODE_READ
) {
2339 if ((val
= prog_dmabuf_record(state
)))
2342 ret
= put_user(dmabuf
->fragsize
, p
);
2345 /* neither READ nor WRITE? is this even possible? */
2350 case SNDCTL_DSP_GETFMTS
: /* Returns a mask of supported sample format */
2351 ret
= put_user(AFMT_S16_LE
| AFMT_U16_LE
| AFMT_S8
|
2355 case SNDCTL_DSP_SETFMT
: /* Select sample format */
2356 if (get_user(val
, p
)) {
2360 if ((ret
= lock_set_fmt(state
)) < 0)
2363 if (val
!= AFMT_QUERY
) {
2364 if (file
->f_mode
& FMODE_WRITE
) {
2367 if (val
== AFMT_S16_LE
)
2368 dmabuf
->fmt
|= TRIDENT_FMT_16BIT
;
2370 dmabuf
->fmt
&= ~TRIDENT_FMT_16BIT
;
2372 if (file
->f_mode
& FMODE_READ
) {
2375 if (val
== AFMT_S16_LE
)
2376 dmabuf
->fmt
|= TRIDENT_FMT_16BIT
;
2378 dmabuf
->fmt
&= ~TRIDENT_FMT_16BIT
;
2381 unlock_set_fmt(state
);
2382 ret
= put_user((dmabuf
->fmt
& TRIDENT_FMT_16BIT
) ? AFMT_S16_LE
:
2386 case SNDCTL_DSP_CHANNELS
:
2387 if (get_user(val
, p
)) {
2392 if ((ret
= lock_set_fmt(state
)) < 0)
2395 if (file
->f_mode
& FMODE_WRITE
) {
2399 //prevent from memory leak
2400 if ((state
->chans_num
> 2) && (state
->chans_num
!= val
)) {
2401 ali_free_other_states_resources(state
);
2402 state
->chans_num
= 1;
2407 dmabuf
->fmt
|= TRIDENT_FMT_STEREO
;
2408 if ((val
== 6) && (state
->card
->pci_id
== PCI_DEVICE_ID_ALI_5451
)) {
2409 if (card
->rec_channel_use_count
> 0) {
2410 printk(KERN_ERR
"trident: Record is "
2411 "working on the card!\n");
2413 unlock_set_fmt(state
);
2417 ret
= ali_setup_multi_channels(state
->card
, 6);
2419 unlock_set_fmt(state
);
2422 mutex_lock(&state
->card
->open_mutex
);
2423 ret
= ali_allocate_other_states_resources(state
, 6);
2425 mutex_unlock(&state
->card
->open_mutex
);
2426 unlock_set_fmt(state
);
2429 state
->card
->multi_channel_use_count
++;
2430 mutex_unlock(&state
->card
->open_mutex
);
2432 val
= 2; /*yield to 2-channels */
2434 dmabuf
->fmt
&= ~TRIDENT_FMT_STEREO
;
2435 state
->chans_num
= val
;
2437 if (file
->f_mode
& FMODE_READ
) {
2441 if (!((file
->f_mode
& FMODE_WRITE
) &&
2444 dmabuf
->fmt
|= TRIDENT_FMT_STEREO
;
2446 dmabuf
->fmt
&= ~TRIDENT_FMT_STEREO
;
2447 state
->chans_num
= val
;
2449 unlock_set_fmt(state
);
2451 ret
= put_user(val
, p
);
2454 case SNDCTL_DSP_POST
:
2455 /* Cause the working fragment to be output */
2458 case SNDCTL_DSP_SUBDIVIDE
:
2459 if (dmabuf
->subdivision
) {
2463 if (get_user(val
, p
)) {
2467 if (val
!= 1 && val
!= 2 && val
!= 4) {
2471 dmabuf
->subdivision
= val
;
2474 case SNDCTL_DSP_SETFRAGMENT
:
2475 if (get_user(val
, p
)) {
2480 dmabuf
->ossfragshift
= val
& 0xffff;
2481 dmabuf
->ossmaxfrags
= (val
>> 16) & 0xffff;
2482 if (dmabuf
->ossfragshift
< 4)
2483 dmabuf
->ossfragshift
= 4;
2484 if (dmabuf
->ossfragshift
> 15)
2485 dmabuf
->ossfragshift
= 15;
2486 if (dmabuf
->ossmaxfrags
< 4)
2487 dmabuf
->ossmaxfrags
= 4;
2491 case SNDCTL_DSP_GETOSPACE
:
2492 if (!(file
->f_mode
& FMODE_WRITE
)) {
2496 if (!dmabuf
->ready
&& (val
= prog_dmabuf_playback(state
)) != 0) {
2500 spin_lock_irqsave(&state
->card
->lock
, flags
);
2501 trident_update_ptr(state
);
2502 abinfo
.fragsize
= dmabuf
->fragsize
;
2503 abinfo
.bytes
= dmabuf
->dmasize
- dmabuf
->count
;
2504 abinfo
.fragstotal
= dmabuf
->numfrag
;
2505 abinfo
.fragments
= abinfo
.bytes
>> dmabuf
->fragshift
;
2506 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2507 ret
= copy_to_user(argp
, &abinfo
, sizeof (abinfo
)) ?
2511 case SNDCTL_DSP_GETISPACE
:
2512 if (!(file
->f_mode
& FMODE_READ
)) {
2516 if (!dmabuf
->ready
&& (val
= prog_dmabuf_record(state
)) != 0) {
2520 spin_lock_irqsave(&state
->card
->lock
, flags
);
2521 trident_update_ptr(state
);
2522 abinfo
.fragsize
= dmabuf
->fragsize
;
2523 abinfo
.bytes
= dmabuf
->count
;
2524 abinfo
.fragstotal
= dmabuf
->numfrag
;
2525 abinfo
.fragments
= abinfo
.bytes
>> dmabuf
->fragshift
;
2526 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2527 ret
= copy_to_user(argp
, &abinfo
, sizeof (abinfo
)) ?
2531 case SNDCTL_DSP_NONBLOCK
:
2532 file
->f_flags
|= O_NONBLOCK
;
2535 case SNDCTL_DSP_GETCAPS
:
2536 ret
= put_user(DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
|
2537 DSP_CAP_MMAP
| DSP_CAP_BIND
, p
);
2540 case SNDCTL_DSP_GETTRIGGER
:
2542 if ((file
->f_mode
& FMODE_READ
) && dmabuf
->enable
)
2543 val
|= PCM_ENABLE_INPUT
;
2544 if ((file
->f_mode
& FMODE_WRITE
) && dmabuf
->enable
)
2545 val
|= PCM_ENABLE_OUTPUT
;
2546 ret
= put_user(val
, p
);
2549 case SNDCTL_DSP_SETTRIGGER
:
2550 if (get_user(val
, p
)) {
2554 if (file
->f_mode
& FMODE_READ
) {
2555 if (val
& PCM_ENABLE_INPUT
) {
2556 if (!dmabuf
->ready
&&
2557 (ret
= prog_dmabuf_record(state
)))
2563 if (file
->f_mode
& FMODE_WRITE
) {
2564 if (val
& PCM_ENABLE_OUTPUT
) {
2565 if (!dmabuf
->ready
&&
2566 (ret
= prog_dmabuf_playback(state
)))
2574 case SNDCTL_DSP_GETIPTR
:
2575 if (!(file
->f_mode
& FMODE_READ
)) {
2579 if (!dmabuf
->ready
&& (val
= prog_dmabuf_record(state
))
2584 spin_lock_irqsave(&state
->card
->lock
, flags
);
2585 trident_update_ptr(state
);
2586 cinfo
.bytes
= dmabuf
->total_bytes
;
2587 cinfo
.blocks
= dmabuf
->count
>> dmabuf
->fragshift
;
2588 cinfo
.ptr
= dmabuf
->hwptr
;
2590 dmabuf
->count
&= dmabuf
->fragsize
- 1;
2591 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2592 ret
= copy_to_user(argp
, &cinfo
, sizeof (cinfo
)) ?
2596 case SNDCTL_DSP_GETOPTR
:
2597 if (!(file
->f_mode
& FMODE_WRITE
)) {
2601 if (!dmabuf
->ready
&& (val
= prog_dmabuf_playback(state
))
2607 spin_lock_irqsave(&state
->card
->lock
, flags
);
2608 trident_update_ptr(state
);
2609 cinfo
.bytes
= dmabuf
->total_bytes
;
2610 cinfo
.blocks
= dmabuf
->count
>> dmabuf
->fragshift
;
2611 cinfo
.ptr
= dmabuf
->hwptr
;
2613 dmabuf
->count
&= dmabuf
->fragsize
- 1;
2614 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2615 ret
= copy_to_user(argp
, &cinfo
, sizeof (cinfo
)) ?
2619 case SNDCTL_DSP_SETDUPLEX
:
2623 case SNDCTL_DSP_GETODELAY
:
2624 if (!(file
->f_mode
& FMODE_WRITE
)) {
2628 if (!dmabuf
->ready
&& (val
= prog_dmabuf_playback(state
)) != 0) {
2632 spin_lock_irqsave(&state
->card
->lock
, flags
);
2633 trident_update_ptr(state
);
2634 val
= dmabuf
->count
;
2635 spin_unlock_irqrestore(&state
->card
->lock
, flags
);
2636 ret
= put_user(val
, p
);
2639 case SOUND_PCM_READ_RATE
:
2640 ret
= put_user(dmabuf
->rate
, p
);
2643 case SOUND_PCM_READ_CHANNELS
:
2644 ret
= put_user((dmabuf
->fmt
& TRIDENT_FMT_STEREO
) ? 2 : 1,
2648 case SOUND_PCM_READ_BITS
:
2649 ret
= put_user((dmabuf
->fmt
& TRIDENT_FMT_16BIT
) ? AFMT_S16_LE
:
2653 case SNDCTL_DSP_GETCHANNELMASK
:
2654 ret
= put_user(DSP_BIND_FRONT
| DSP_BIND_SURR
|
2655 DSP_BIND_CENTER_LFE
, p
);
2658 case SNDCTL_DSP_BIND_CHANNEL
:
2659 if (state
->card
->pci_id
!= PCI_DEVICE_ID_SI_7018
) {
2664 if (get_user(val
, p
)) {
2668 if (val
== DSP_BIND_QUERY
) {
2669 val
= dmabuf
->channel
->attribute
| 0x3c00;
2670 val
= attr2mask
[val
>> 8];
2673 if (file
->f_mode
& FMODE_READ
)
2674 dmabuf
->channel
->attribute
= (CHANNEL_REC
|
2676 if (file
->f_mode
& FMODE_WRITE
)
2677 dmabuf
->channel
->attribute
= (CHANNEL_SPC_PB
|
2679 dmabuf
->channel
->attribute
|= mask2attr
[ffs(val
)];
2681 ret
= put_user(val
, p
);
2684 case SNDCTL_DSP_MAPINBUF
:
2685 case SNDCTL_DSP_MAPOUTBUF
:
2686 case SNDCTL_DSP_SETSYNCRO
:
2687 case SOUND_PCM_WRITE_FILTER
:
2688 case SOUND_PCM_READ_FILTER
:
2698 trident_open(struct inode
*inode
, struct file
*file
)
2701 int minor
= iminor(inode
);
2702 struct trident_card
*card
= devs
;
2703 struct trident_state
*state
= NULL
;
2704 struct dmabuf
*dmabuf
= NULL
;
2705 unsigned long flags
;
2707 /* Added by Matt Wu 01-05-2001 */
2708 /* TODO: there's some redundacy here wrt the check below */
2709 /* for multi_use_count > 0. Should we return -EBUSY or find */
2710 /* a different card? for now, don't break current behaviour */
2712 if (file
->f_mode
& FMODE_READ
) {
2713 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
2714 if (card
->multi_channel_use_count
> 0)
2719 /* find an available virtual channel (instance of /dev/dsp) */
2720 while (card
!= NULL
) {
2721 mutex_lock(&card
->open_mutex
);
2722 if (file
->f_mode
& FMODE_READ
) {
2723 /* Skip opens on cards that are in 6 channel mode */
2724 if (card
->multi_channel_use_count
> 0) {
2725 mutex_unlock(&card
->open_mutex
);
2730 for (i
= 0; i
< NR_HW_CH
; i
++) {
2731 if (card
->states
[i
] == NULL
) {
2732 state
= card
->states
[i
] = kzalloc(sizeof(*state
), GFP_KERNEL
);
2733 if (state
== NULL
) {
2734 mutex_unlock(&card
->open_mutex
);
2737 mutex_init(&state
->sem
);
2738 dmabuf
= &state
->dmabuf
;
2742 mutex_unlock(&card
->open_mutex
);
2745 /* no more virtual channel avaiable */
2750 /* found a free virtual channel, allocate hardware channels */
2751 if (file
->f_mode
& FMODE_READ
)
2752 dmabuf
->channel
= card
->alloc_rec_pcm_channel(card
);
2754 dmabuf
->channel
= card
->alloc_pcm_channel(card
);
2756 if (dmabuf
->channel
== NULL
) {
2757 kfree(card
->states
[i
]);
2758 card
->states
[i
] = NULL
;
2762 /* initialize the virtual channel */
2765 state
->magic
= TRIDENT_STATE_MAGIC
;
2766 init_waitqueue_head(&dmabuf
->wait
);
2767 file
->private_data
= state
;
2769 /* set default sample format. According to OSS Programmer's */
2770 /* Guide /dev/dsp should be default to unsigned 8-bits, mono, */
2771 /* with sample rate 8kHz and /dev/dspW will accept 16-bits sample */
2772 if (file
->f_mode
& FMODE_WRITE
) {
2773 dmabuf
->fmt
&= ~TRIDENT_FMT_MASK
;
2774 if ((minor
& 0x0f) == SND_DEV_DSP16
)
2775 dmabuf
->fmt
|= TRIDENT_FMT_16BIT
;
2776 dmabuf
->ossfragshift
= 0;
2777 dmabuf
->ossmaxfrags
= 0;
2778 dmabuf
->subdivision
= 0;
2779 if (card
->pci_id
== PCI_DEVICE_ID_SI_7018
) {
2780 /* set default channel attribute to normal playback */
2781 dmabuf
->channel
->attribute
= CHANNEL_PB
;
2783 spin_lock_irqsave(&card
->lock
, flags
);
2784 trident_set_dac_rate(state
, 8000);
2785 spin_unlock_irqrestore(&card
->lock
, flags
);
2788 if (file
->f_mode
& FMODE_READ
) {
2789 /* FIXME: Trident 4d can only record in signed 16-bits stereo, */
2790 /* 48kHz sample, to be dealed with in trident_set_adc_rate() ?? */
2791 dmabuf
->fmt
&= ~TRIDENT_FMT_MASK
;
2792 if ((minor
& 0x0f) == SND_DEV_DSP16
)
2793 dmabuf
->fmt
|= TRIDENT_FMT_16BIT
;
2794 dmabuf
->ossfragshift
= 0;
2795 dmabuf
->ossmaxfrags
= 0;
2796 dmabuf
->subdivision
= 0;
2797 if (card
->pci_id
== PCI_DEVICE_ID_SI_7018
) {
2798 /* set default channel attribute to 0x8a80, record from
2799 PCM L/R FIFO and mono = (left + right + 1)/2 */
2800 dmabuf
->channel
->attribute
= (CHANNEL_REC
| PCM_LR
|
2803 spin_lock_irqsave(&card
->lock
, flags
);
2804 trident_set_adc_rate(state
, 8000);
2805 spin_unlock_irqrestore(&card
->lock
, flags
);
2807 /* Added by Matt Wu 01-05-2001 */
2808 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
)
2809 card
->rec_channel_use_count
++;
2812 state
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
2813 mutex_unlock(&card
->open_mutex
);
2815 pr_debug("trident: open virtual channel %d, hard channel %d\n",
2816 state
->virt
, dmabuf
->channel
->num
);
2818 return nonseekable_open(inode
, file
);
2822 trident_release(struct inode
*inode
, struct file
*file
)
2824 struct trident_state
*state
= (struct trident_state
*)file
->private_data
;
2825 struct trident_card
*card
;
2826 struct dmabuf
*dmabuf
;
2828 VALIDATE_STATE(state
);
2831 dmabuf
= &state
->dmabuf
;
2833 if (file
->f_mode
& FMODE_WRITE
) {
2834 trident_clear_tail(state
);
2835 drain_dac(state
, file
->f_flags
& O_NONBLOCK
);
2838 pr_debug("trident: closing virtual channel %d, hard channel %d\n",
2839 state
->virt
, dmabuf
->channel
->num
);
2841 /* stop DMA state machine and free DMA buffers/channels */
2842 mutex_lock(&card
->open_mutex
);
2844 if (file
->f_mode
& FMODE_WRITE
) {
2846 dealloc_dmabuf(&state
->dmabuf
, state
->card
->pci_dev
);
2847 state
->card
->free_pcm_channel(state
->card
, dmabuf
->channel
->num
);
2849 /* Added by Matt Wu */
2850 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
2851 if (state
->chans_num
> 2) {
2852 if (card
->multi_channel_use_count
-- < 0)
2853 card
->multi_channel_use_count
= 0;
2854 if (card
->multi_channel_use_count
== 0)
2855 ali_close_multi_channels();
2856 ali_free_other_states_resources(state
);
2860 if (file
->f_mode
& FMODE_READ
) {
2862 dealloc_dmabuf(&state
->dmabuf
, state
->card
->pci_dev
);
2863 state
->card
->free_pcm_channel(state
->card
, dmabuf
->channel
->num
);
2865 /* Added by Matt Wu */
2866 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
2867 if (card
->rec_channel_use_count
-- < 0)
2868 card
->rec_channel_use_count
= 0;
2872 card
->states
[state
->virt
] = NULL
;
2875 /* we're covered by the open_mutex */
2876 mutex_unlock(&card
->open_mutex
);
2881 static /*const */ struct file_operations trident_audio_fops
= {
2882 .owner
= THIS_MODULE
,
2883 .llseek
= no_llseek
,
2884 .read
= trident_read
,
2885 .write
= trident_write
,
2886 .poll
= trident_poll
,
2887 .ioctl
= trident_ioctl
,
2888 .mmap
= trident_mmap
,
2889 .open
= trident_open
,
2890 .release
= trident_release
,
2893 /* trident specific AC97 functions */
2894 /* Write AC97 codec registers */
2896 trident_ac97_set(struct ac97_codec
*codec
, u8 reg
, u16 val
)
2898 struct trident_card
*card
= (struct trident_card
*)codec
->private_data
;
2899 unsigned int address
, mask
, busy
;
2900 unsigned short count
= 0xffff;
2901 unsigned long flags
;
2904 data
= ((u32
) val
) << 16;
2906 switch (card
->pci_id
) {
2908 case PCI_DEVICE_ID_SI_7018
:
2909 address
= SI_AC97_WRITE
;
2910 mask
= SI_AC97_BUSY_WRITE
| SI_AC97_AUDIO_BUSY
;
2912 mask
|= SI_AC97_SECONDARY
;
2913 busy
= SI_AC97_BUSY_WRITE
;
2915 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
:
2916 address
= DX_ACR0_AC97_W
;
2917 mask
= busy
= DX_AC97_BUSY_WRITE
;
2919 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
:
2920 address
= NX_ACR1_AC97_W
;
2921 mask
= NX_AC97_BUSY_WRITE
;
2923 mask
|= NX_AC97_WRITE_SECONDARY
;
2924 busy
= NX_AC97_BUSY_WRITE
;
2926 case PCI_DEVICE_ID_INTERG_5050
:
2927 address
= SI_AC97_WRITE
;
2928 mask
= busy
= SI_AC97_BUSY_WRITE
;
2930 mask
|= SI_AC97_SECONDARY
;
2934 spin_lock_irqsave(&card
->lock
, flags
);
2936 if ((inw(TRID_REG(card
, address
)) & busy
) == 0)
2940 data
|= (mask
| (reg
& AC97_REG_ADDR
));
2943 printk(KERN_ERR
"trident: AC97 CODEC write timed out.\n");
2944 spin_unlock_irqrestore(&card
->lock
, flags
);
2948 outl(data
, TRID_REG(card
, address
));
2949 spin_unlock_irqrestore(&card
->lock
, flags
);
2952 /* Read AC97 codec registers */
2954 trident_ac97_get(struct ac97_codec
*codec
, u8 reg
)
2956 struct trident_card
*card
= (struct trident_card
*)codec
->private_data
;
2957 unsigned int address
, mask
, busy
;
2958 unsigned short count
= 0xffff;
2959 unsigned long flags
;
2962 switch (card
->pci_id
) {
2964 case PCI_DEVICE_ID_SI_7018
:
2965 address
= SI_AC97_READ
;
2966 mask
= SI_AC97_BUSY_READ
| SI_AC97_AUDIO_BUSY
;
2968 mask
|= SI_AC97_SECONDARY
;
2969 busy
= SI_AC97_BUSY_READ
;
2971 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
:
2972 address
= DX_ACR1_AC97_R
;
2973 mask
= busy
= DX_AC97_BUSY_READ
;
2975 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
:
2977 address
= NX_ACR3_AC97_R_SECONDARY
;
2979 address
= NX_ACR2_AC97_R_PRIMARY
;
2980 mask
= NX_AC97_BUSY_READ
;
2981 busy
= NX_AC97_BUSY_READ
| NX_AC97_BUSY_DATA
;
2983 case PCI_DEVICE_ID_INTERG_5050
:
2984 address
= SI_AC97_READ
;
2985 mask
= busy
= SI_AC97_BUSY_READ
;
2987 mask
|= SI_AC97_SECONDARY
;
2991 data
= (mask
| (reg
& AC97_REG_ADDR
));
2993 spin_lock_irqsave(&card
->lock
, flags
);
2994 outl(data
, TRID_REG(card
, address
));
2996 data
= inl(TRID_REG(card
, address
));
2997 if ((data
& busy
) == 0)
3000 spin_unlock_irqrestore(&card
->lock
, flags
);
3003 printk(KERN_ERR
"trident: AC97 CODEC read timed out.\n");
3006 return ((u16
) (data
>> 16));
3009 /* rewrite ac97 read and write mixer register by hulei for ALI*/
3011 acquirecodecaccess(struct trident_card
*card
)
3013 u16 wsemamask
= 0x6000; /* bit 14..13 */
3019 wcontrol
= inw(TRID_REG(card
, ALI_AC97_WRITE
));
3020 wsemabits
= wcontrol
& wsemamask
;
3022 if (wsemabits
== 0x4000)
3023 return 1; /* 0x4000 is audio ,then success */
3026 if (wsemabits
== 0) {
3028 outl(((u32
) (wcontrol
& 0x1eff) | 0x00004000),
3029 TRID_REG(card
, ALI_AC97_WRITE
));
3035 pr_debug("accesscodecsemaphore: try unlock\n");
3043 releasecodecaccess(struct trident_card
*card
)
3045 unsigned long wcontrol
;
3046 wcontrol
= inl(TRID_REG(card
, ALI_AC97_WRITE
));
3047 outl((wcontrol
& 0xffff1eff), TRID_REG(card
, ALI_AC97_WRITE
));
3051 waitforstimertick(struct trident_card
*card
)
3053 unsigned long chk1
, chk2
;
3054 unsigned int wcount
= 0xffff;
3055 chk1
= inl(TRID_REG(card
, ALI_STIMER
));
3058 chk2
= inl(TRID_REG(card
, ALI_STIMER
));
3059 if ((wcount
> 0) && chk1
!= chk2
)
3068 /* Read AC97 codec registers for ALi*/
3070 ali_ac97_get(struct trident_card
*card
, int secondary
, u8 reg
)
3072 unsigned int address
, mask
;
3073 unsigned int ncount
;
3074 unsigned long aud_reg
;
3077 unsigned long flags
;
3082 address
= ALI_AC97_READ
;
3083 if (card
->revision
== ALI_5451_V02
) {
3084 address
= ALI_AC97_WRITE
;
3086 mask
= ALI_AC97_READ_ACTION
| ALI_AC97_AUDIO_BUSY
;
3088 mask
|= ALI_AC97_SECONDARY
;
3090 spin_lock_irqsave(&card
->lock
, flags
);
3092 if (!acquirecodecaccess(card
))
3093 printk(KERN_ERR
"access codec fail\n");
3095 wcontrol
= inw(TRID_REG(card
, ALI_AC97_WRITE
));
3097 wcontrol
|= (0x8000 | reg
);
3098 outw(wcontrol
, TRID_REG(card
, ALI_AC97_WRITE
));
3100 data
= (mask
| (reg
& AC97_REG_ADDR
));
3102 if (!waitforstimertick(card
)) {
3103 printk(KERN_ERR
"ali_ac97_read: BIT_CLOCK is dead\n");
3112 if ((inw(TRID_REG(card
, ALI_AC97_WRITE
)) & ALI_AC97_BUSY_READ
)
3117 if (ncount
-- == 1) {
3118 pr_debug("ali_ac97_read :try clear busy flag\n");
3119 aud_reg
= inl(TRID_REG(card
, ALI_AC97_WRITE
));
3120 outl((aud_reg
& 0xffff7fff),
3121 TRID_REG(card
, ALI_AC97_WRITE
));
3126 data
= inl(TRID_REG(card
, address
));
3128 spin_unlock_irqrestore(&card
->lock
, flags
);
3130 return ((u16
) (data
>> 16));
3133 releasecodecaccess(card
);
3134 spin_unlock_irqrestore(&card
->lock
, flags
);
3135 printk(KERN_ERR
"ali_ac97_read: AC97 CODEC read timed out.\n");
3139 /* Write AC97 codec registers for hulei*/
3141 ali_ac97_set(struct trident_card
*card
, int secondary
, u8 reg
, u16 val
)
3143 unsigned int address
, mask
;
3144 unsigned int ncount
;
3147 unsigned long flags
;
3149 data
= ((u32
) val
) << 16;
3154 address
= ALI_AC97_WRITE
;
3155 mask
= ALI_AC97_WRITE_ACTION
| ALI_AC97_AUDIO_BUSY
;
3157 mask
|= ALI_AC97_SECONDARY
;
3158 if (card
->revision
== ALI_5451_V02
)
3159 mask
|= ALI_AC97_WRITE_MIXER_REGISTER
;
3161 spin_lock_irqsave(&card
->lock
, flags
);
3162 if (!acquirecodecaccess(card
))
3163 printk(KERN_ERR
"ali_ac97_write: access codec fail\n");
3165 wcontrol
= inw(TRID_REG(card
, ALI_AC97_WRITE
));
3167 wcontrol
|= (0x8100 | reg
); /* bit 8=1: (ali1535 )reserved/ */
3168 /* ali1535+ write */
3169 outl((data
| wcontrol
), TRID_REG(card
, ALI_AC97_WRITE
));
3171 if (!waitforstimertick(card
)) {
3172 printk(KERN_ERR
"BIT_CLOCK is dead\n");
3178 wcontrol
= inw(TRID_REG(card
, ALI_AC97_WRITE
));
3179 if (!(wcontrol
& 0x8000))
3183 if (ncount
-- == 1) {
3184 pr_debug("ali_ac97_set :try clear busy flag!!\n");
3185 outw(wcontrol
& 0x7fff,
3186 TRID_REG(card
, ALI_AC97_WRITE
));
3192 releasecodecaccess(card
);
3193 spin_unlock_irqrestore(&card
->lock
, flags
);
3198 ali_enable_special_channel(struct trident_state
*stat
)
3200 struct trident_card
*card
= stat
->card
;
3201 unsigned long s_channels
;
3203 s_channels
= inl(TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3204 s_channels
|= (1 << stat
->dmabuf
.channel
->num
);
3205 outl(s_channels
, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3209 ali_ac97_read(struct ac97_codec
*codec
, u8 reg
)
3213 struct trident_card
*card
= NULL
;
3215 /* Added by Matt Wu */
3219 card
= (struct trident_card
*) codec
->private_data
;
3221 if (!card
->mixer_regs_ready
)
3222 return ali_ac97_get(card
, codec
->id
, reg
);
3225 * FIXME: need to stop this caching some registers
3232 data
= card
->mixer_regs
[reg
/ 2][id
];
3237 ali_ac97_write(struct ac97_codec
*codec
, u8 reg
, u16 val
)
3240 struct trident_card
*card
;
3242 /* Added by Matt Wu */
3246 card
= (struct trident_card
*) codec
->private_data
;
3248 if (!card
->mixer_regs_ready
) {
3249 ali_ac97_set(card
, codec
->id
, reg
, val
);
3258 card
->mixer_regs
[reg
/ 2][id
] = val
;
3259 ali_ac97_set(card
, codec
->id
, reg
, val
);
3263 flag: ALI_SPDIF_OUT_TO_SPDIF_OUT
3264 ALI_PCM_TO_SPDIF_OUT
3268 ali_setup_spdif_out(struct trident_card
*card
, int flag
)
3270 unsigned long spdif
;
3274 struct pci_dev
*pci_dev
= NULL
;
3276 pci_dev
= pci_get_device(PCI_VENDOR_ID_AL
, PCI_DEVICE_ID_AL_M1533
,
3278 if (pci_dev
== NULL
)
3280 pci_read_config_byte(pci_dev
, 0x61, &temp
);
3282 pci_write_config_byte(pci_dev
, 0x61, temp
);
3283 pci_read_config_byte(pci_dev
, 0x7d, &temp
);
3285 pci_write_config_byte(pci_dev
, 0x7d, temp
);
3286 pci_read_config_byte(pci_dev
, 0x7e, &temp
);
3289 pci_write_config_byte(pci_dev
, 0x7e, temp
);
3291 pci_dev_put(pci_dev
);
3293 ch
= inb(TRID_REG(card
, ALI_SCTRL
));
3294 outb(ch
| ALI_SPDIF_OUT_ENABLE
, TRID_REG(card
, ALI_SCTRL
));
3295 ch
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
));
3296 outb(ch
& ALI_SPDIF_OUT_CH_STATUS
, TRID_REG(card
, ALI_SPDIF_CTRL
));
3298 if (flag
& ALI_SPDIF_OUT_TO_SPDIF_OUT
) {
3299 spdif
= inw(TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3300 spdif
|= ALI_SPDIF_OUT_CH_ENABLE
;
3301 spdif
&= ALI_SPDIF_OUT_SEL_SPDIF
;
3302 outw(spdif
, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3303 spdif
= inw(TRID_REG(card
, ALI_SPDIF_CS
));
3304 if (flag
& ALI_SPDIF_OUT_NON_PCM
)
3308 outw(spdif
, TRID_REG(card
, ALI_SPDIF_CS
));
3310 spdif
= inw(TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3311 spdif
|= ALI_SPDIF_OUT_SEL_PCM
;
3312 outw(spdif
, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3317 ali_disable_special_channel(struct trident_card
*card
, int ch
)
3321 sc
= inl(TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3323 outl(sc
, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3327 ali_disable_spdif_in(struct trident_card
*card
)
3329 unsigned long spdif
;
3331 spdif
= inl(TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3332 spdif
&= (~ALI_SPDIF_IN_SUPPORT
);
3333 outl(spdif
, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3335 ali_disable_special_channel(card
, ALI_SPDIF_IN_CHANNEL
);
3339 ali_setup_spdif_in(struct trident_card
*card
)
3341 unsigned long spdif
;
3343 //Set SPDIF IN Supported
3344 spdif
= inl(TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3345 spdif
|= ALI_SPDIF_IN_SUPPORT
;
3346 outl(spdif
, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3349 spdif
= inl(TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3350 spdif
|= ALI_SPDIF_IN_CH_ENABLE
;
3351 outl(spdif
, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
3353 spdif
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
));
3354 spdif
|= ALI_SPDIF_IN_CH_STATUS
;
3355 outb(spdif
, TRID_REG(card
, ALI_SPDIF_CTRL
));
3357 spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
3358 spdif |= ALI_SPDIF_IN_FUNC_ENABLE;
3359 outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
3364 ali_delay(struct trident_card
*card
, int interval
)
3366 unsigned long begintimer
, currenttimer
;
3368 begintimer
= inl(TRID_REG(card
, ALI_STIMER
));
3369 currenttimer
= inl(TRID_REG(card
, ALI_STIMER
));
3371 while (currenttimer
< begintimer
+ interval
)
3372 currenttimer
= inl(TRID_REG(card
, ALI_STIMER
));
3376 ali_detect_spdif_rate(struct trident_card
*card
)
3380 u8 bval
= 0, R1
= 0, R2
= 0;
3382 bval
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
));
3384 outb(bval
, TRID_REG(card
, ALI_SPDIF_CTRL
));
3386 bval
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
+ 1));
3388 outb(bval
, TRID_REG(card
, ALI_SPDIF_CTRL
+ 1));
3390 while (((R1
< 0x0B) || (R1
> 0x0E)) && (R1
!= 0x12) &&
3396 bval
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
+ 1));
3400 if (count
> 50000) {
3401 printk(KERN_WARNING
"trident: Error in "
3402 "ali_detect_spdif_rate!\n");
3408 while (count
<= 50000) {
3413 bval
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
+ 1));
3422 if (count
> 50000) {
3423 printk(KERN_WARNING
"trident: Error in "
3424 "ali_detect_spdif_rate!\n");
3433 wval
= inw(TRID_REG(card
, ALI_SPDIF_CTRL
+ 2));
3435 wval
|= (u16
) 0x09 << 8 | (u16
) 0x05;
3436 outw(wval
, TRID_REG(card
, ALI_SPDIF_CTRL
+ 2));
3438 bval
= inb(TRID_REG(card
, ALI_SPDIF_CS
+ 3)) & 0xF0;
3439 outb(bval
| 0x02, TRID_REG(card
, ALI_SPDIF_CS
+ 3));
3443 wval
= inw(TRID_REG(card
, ALI_SPDIF_CTRL
+ 2));
3445 wval
|= (u16
) 0x0E << 8 | (u16
) 0x08;
3446 outw(wval
, TRID_REG(card
, ALI_SPDIF_CTRL
+ 2));
3448 bval
= inb(TRID_REG(card
, ALI_SPDIF_CS
+ 3)) & 0xF0;
3449 outb(bval
| 0x03, TRID_REG(card
, ALI_SPDIF_CS
+ 3));
3459 ali_get_spdif_in_rate(struct trident_card
*card
)
3464 ali_detect_spdif_rate(card
);
3466 bval
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
));
3469 outb(bval
, TRID_REG(card
, ALI_SPDIF_CTRL
));
3471 bval
= inb(TRID_REG(card
, ALI_SPDIF_CS
+ 3));
3494 ali_close_multi_channels(void)
3497 struct pci_dev
*pci_dev
= NULL
;
3499 pci_dev
= pci_get_device(PCI_VENDOR_ID_AL
, PCI_DEVICE_ID_AL_M1533
,
3501 if (pci_dev
== NULL
)
3504 pci_read_config_byte(pci_dev
, 0x59, &temp
);
3506 pci_write_config_byte(pci_dev
, 0x59, temp
);
3508 pci_dev_put(pci_dev
);
3510 pci_dev
= pci_get_device(PCI_VENDOR_ID_AL
, PCI_DEVICE_ID_AL_M7101
,
3512 if (pci_dev
== NULL
)
3515 pci_read_config_byte(pci_dev
, 0xB8, &temp
);
3517 pci_write_config_byte(pci_dev
, 0xB8, temp
);
3519 pci_dev_put(pci_dev
);
3525 ali_setup_multi_channels(struct trident_card
*card
, int chan_nums
)
3527 unsigned long dwValue
;
3529 struct pci_dev
*pci_dev
= NULL
;
3531 pci_dev
= pci_get_device(PCI_VENDOR_ID_AL
, PCI_DEVICE_ID_AL_M1533
,
3533 if (pci_dev
== NULL
)
3535 pci_read_config_byte(pci_dev
, 0x59, &temp
);
3537 pci_write_config_byte(pci_dev
, 0x59, temp
);
3539 pci_dev_put(pci_dev
);
3541 pci_dev
= pci_get_device(PCI_VENDOR_ID_AL
, PCI_DEVICE_ID_AL_M7101
,
3543 if (pci_dev
== NULL
)
3545 pci_read_config_byte(pci_dev
, (int) 0xB8, &temp
);
3547 pci_write_config_byte(pci_dev
, (int) 0xB8, (u8
) temp
);
3549 pci_dev_put(pci_dev
);
3551 if (chan_nums
== 6) {
3552 dwValue
= inl(TRID_REG(card
, ALI_SCTRL
)) | 0x000f0000;
3553 outl(dwValue
, TRID_REG(card
, ALI_SCTRL
));
3555 dwValue
= inl(TRID_REG(card
, ALI_SCTRL
));
3556 if (dwValue
& 0x2000000) {
3557 ali_ac97_write(card
->ac97_codec
[0], 0x02, 8080);
3558 ali_ac97_write(card
->ac97_codec
[0], 0x36, 0);
3559 ali_ac97_write(card
->ac97_codec
[0], 0x38, 0);
3561 * On a board with a single codec you won't get the
3562 * surround. On other boards configure it.
3564 if (card
->ac97_codec
[1] != NULL
) {
3565 ali_ac97_write(card
->ac97_codec
[1], 0x36, 0);
3566 ali_ac97_write(card
->ac97_codec
[1], 0x38, 0);
3567 ali_ac97_write(card
->ac97_codec
[1], 0x02, 0x0606);
3568 ali_ac97_write(card
->ac97_codec
[1], 0x18, 0x0303);
3569 ali_ac97_write(card
->ac97_codec
[1], 0x74, 0x3);
3578 ali_free_pcm_channel(struct trident_card
*card
, unsigned int channel
)
3585 bank
= channel
>> 5;
3586 channel
= channel
& 0x1f;
3588 card
->banks
[bank
].bitmap
&= ~(1 << (channel
));
3592 ali_allocate_other_states_resources(struct trident_state
*state
, int chan_nums
)
3594 struct trident_card
*card
= state
->card
;
3595 struct trident_state
*s
;
3596 int i
, state_count
= 0;
3597 struct trident_pcm_bank
*bank
;
3598 struct trident_channel
*channel
;
3601 bank
= &card
->banks
[BANK_A
];
3606 for (i
= 0; (i
< ALI_CHANNELS
) && (state_count
!= 4); i
++) {
3607 if (card
->states
[i
])
3610 num
= ali_multi_channels_5_1
[state_count
];
3611 if (!(bank
->bitmap
& (1 << num
))) {
3612 bank
->bitmap
|= 1 << num
;
3613 channel
= &bank
->channels
[num
];
3617 for (; state_count
>= 0; state_count
--) {
3618 kfree(state
->other_states
[state_count
]);
3619 num
= ali_multi_channels_5_1
[state_count
];
3620 ali_free_pcm_channel(card
, num
);
3624 s
= card
->states
[i
] = kzalloc(sizeof(*state
), GFP_KERNEL
);
3626 num
= ali_multi_channels_5_1
[state_count
];
3627 ali_free_pcm_channel(card
, num
);
3629 for (; state_count
>= 0; state_count
--) {
3630 num
= ali_multi_channels_5_1
[state_count
];
3631 ali_free_pcm_channel(card
, num
);
3632 kfree(state
->other_states
[state_count
]);
3637 s
->dmabuf
.channel
= channel
;
3638 s
->dmabuf
.ossfragshift
= s
->dmabuf
.ossmaxfrags
=
3639 s
->dmabuf
.subdivision
= 0;
3640 init_waitqueue_head(&s
->dmabuf
.wait
);
3641 s
->magic
= card
->magic
;
3644 ali_enable_special_channel(s
);
3645 state
->other_states
[state_count
++] = s
;
3648 if (state_count
!= 4) {
3650 for (; state_count
>= 0; state_count
--) {
3651 kfree(state
->other_states
[state_count
]);
3652 num
= ali_multi_channels_5_1
[state_count
];
3653 ali_free_pcm_channel(card
, num
);
3661 /* save registers for ALi Power Management */
3662 static struct ali_saved_registers
{
3663 unsigned long global_regs
[ALI_GLOBAL_REGS
];
3664 unsigned long channel_regs
[ALI_CHANNELS
][ALI_CHANNEL_REGS
];
3665 unsigned mixer_regs
[ALI_MIXER_REGS
];
3669 ali_save_regs(struct trident_card
*card
)
3671 unsigned long flags
;
3674 spin_lock_irqsave(&card
->lock
, flags
);
3676 ali_registers
.global_regs
[0x2c] = inl(TRID_REG(card
, T4D_MISCINT
));
3677 //ali_registers.global_regs[0x20] = inl(TRID_REG(card,T4D_START_A));
3678 ali_registers
.global_regs
[0x21] = inl(TRID_REG(card
, T4D_STOP_A
));
3680 //disable all IRQ bits
3681 outl(ALI_DISABLE_ALL_IRQ
, TRID_REG(card
, T4D_MISCINT
));
3683 for (i
= 1; i
< ALI_MIXER_REGS
; i
++)
3684 ali_registers
.mixer_regs
[i
] = ali_ac97_read(card
->ac97_codec
[0],
3687 for (i
= 0; i
< ALI_GLOBAL_REGS
; i
++) {
3688 if ((i
* 4 == T4D_MISCINT
) || (i
* 4 == T4D_STOP_A
))
3690 ali_registers
.global_regs
[i
] = inl(TRID_REG(card
, i
* 4));
3693 for (i
= 0; i
< ALI_CHANNELS
; i
++) {
3694 outb(i
, TRID_REG(card
, T4D_LFO_GC_CIR
));
3695 for (j
= 0; j
< ALI_CHANNEL_REGS
; j
++)
3696 ali_registers
.channel_regs
[i
][j
] = inl(TRID_REG(card
,
3700 //Stop all HW channel
3701 outl(ALI_STOP_ALL_CHANNELS
, TRID_REG(card
, T4D_STOP_A
));
3703 spin_unlock_irqrestore(&card
->lock
, flags
);
3707 ali_restore_regs(struct trident_card
*card
)
3709 unsigned long flags
;
3712 spin_lock_irqsave(&card
->lock
, flags
);
3714 for (i
= 1; i
< ALI_MIXER_REGS
; i
++)
3715 ali_ac97_write(card
->ac97_codec
[0], i
* 2,
3716 ali_registers
.mixer_regs
[i
]);
3718 for (i
= 0; i
< ALI_CHANNELS
; i
++) {
3719 outb(i
, TRID_REG(card
, T4D_LFO_GC_CIR
));
3720 for (j
= 0; j
< ALI_CHANNEL_REGS
; j
++)
3721 outl(ali_registers
.channel_regs
[i
][j
],
3722 TRID_REG(card
, j
* 4 + 0xe0));
3725 for (i
= 0; i
< ALI_GLOBAL_REGS
; i
++) {
3726 if ((i
* 4 == T4D_MISCINT
) || (i
* 4 == T4D_STOP_A
) ||
3727 (i
* 4 == T4D_START_A
))
3729 outl(ali_registers
.global_regs
[i
], TRID_REG(card
, i
* 4));
3733 outl(ali_registers
.global_regs
[0x20], TRID_REG(card
, T4D_START_A
));
3734 //restore IRQ enable bits
3735 outl(ali_registers
.global_regs
[0x2c], TRID_REG(card
, T4D_MISCINT
));
3737 spin_unlock_irqrestore(&card
->lock
, flags
);
3741 trident_suspend(struct pci_dev
*dev
, pm_message_t unused
)
3743 struct trident_card
*card
= pci_get_drvdata(dev
);
3745 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
3746 ali_save_regs(card
);
3752 trident_resume(struct pci_dev
*dev
)
3754 struct trident_card
*card
= pci_get_drvdata(dev
);
3756 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
3757 ali_restore_regs(card
);
3763 static struct trident_channel
*
3764 ali_alloc_pcm_channel(struct trident_card
*card
)
3766 struct trident_pcm_bank
*bank
;
3769 bank
= &card
->banks
[BANK_A
];
3771 if (inl(TRID_REG(card
, ALI_GLOBAL_CONTROL
)) &
3772 (ALI_SPDIF_OUT_CH_ENABLE
)) {
3773 idx
= ALI_SPDIF_OUT_CHANNEL
;
3774 if (!(bank
->bitmap
& (1 << idx
))) {
3775 struct trident_channel
*channel
= &bank
->channels
[idx
];
3776 bank
->bitmap
|= 1 << idx
;
3782 for (idx
= ALI_PCM_OUT_CHANNEL_FIRST
; idx
<= ALI_PCM_OUT_CHANNEL_LAST
;
3784 if (!(bank
->bitmap
& (1 << idx
))) {
3785 struct trident_channel
*channel
= &bank
->channels
[idx
];
3786 bank
->bitmap
|= 1 << idx
;
3792 /* no more free channels avaliable */
3794 printk(KERN_ERR
"ali: no more channels available on Bank A.\n");
3799 static struct trident_channel
*
3800 ali_alloc_rec_pcm_channel(struct trident_card
*card
)
3802 struct trident_pcm_bank
*bank
;
3805 if (inl(TRID_REG(card
, ALI_GLOBAL_CONTROL
)) & ALI_SPDIF_IN_SUPPORT
)
3806 idx
= ALI_SPDIF_IN_CHANNEL
;
3808 idx
= ALI_PCM_IN_CHANNEL
;
3810 bank
= &card
->banks
[BANK_A
];
3812 if (!(bank
->bitmap
& (1 << idx
))) {
3813 struct trident_channel
*channel
= &bank
->channels
[idx
];
3814 bank
->bitmap
|= 1 << idx
;
3819 /* no free recordable channels avaliable */
3821 printk(KERN_ERR
"ali: no recordable channels available on Bank A.\n");
3827 ali_set_spdif_out_rate(struct trident_card
*card
, unsigned int rate
)
3829 unsigned char ch_st_sel
;
3830 unsigned short status_rate
;
3837 status_rate
= 0x300;
3841 status_rate
= 0x200;
3845 /* select spdif_out */
3846 ch_st_sel
= inb(TRID_REG(card
, ALI_SPDIF_CTRL
)) & ALI_SPDIF_OUT_CH_STATUS
;
3848 ch_st_sel
|= 0x80; /* select right */
3849 outb(ch_st_sel
, TRID_REG(card
, ALI_SPDIF_CTRL
));
3850 outb(status_rate
| 0x20, TRID_REG(card
, ALI_SPDIF_CS
+ 2));
3852 ch_st_sel
&= (~0x80); /* select left */
3853 outb(ch_st_sel
, TRID_REG(card
, ALI_SPDIF_CTRL
));
3854 outw(status_rate
| 0x10, TRID_REG(card
, ALI_SPDIF_CS
+ 2));
3858 ali_address_interrupt(struct trident_card
*card
)
3861 struct trident_state
*state
;
3862 u32 mask
, channel_mask
;
3864 mask
= trident_get_interrupt_mask(card
, 0);
3865 for (i
= 0; i
< NR_HW_CH
; i
++) {
3866 if ((state
= card
->states
[i
]) == NULL
)
3868 channel
= state
->dmabuf
.channel
->num
;
3869 if ((channel_mask
= 1 << channel
) & mask
) {
3870 mask
&= ~channel_mask
;
3871 trident_ack_channel_interrupt(card
, channel
);
3873 state
->dmabuf
.update_flag
|= ALI_ADDRESS_INT_UPDATE
;
3874 trident_update_ptr(state
);
3878 for (i
= 0; i
< NR_HW_CH
; i
++) {
3879 if (mask
& (1 << i
)) {
3880 printk("ali: spurious channel irq %d.\n", i
);
3881 trident_ack_channel_interrupt(card
, i
);
3882 trident_stop_voice(card
, i
);
3883 trident_disable_voice_irq(card
, i
);
3889 /* Updating the values of counters of other_states' DMAs without lock
3890 protection is no harm because all DMAs of multi-channels and interrupt
3891 depend on a master state's DMA, and changing the counters of the master
3892 state DMA is protected by a spinlock.
3895 ali_write_5_1(struct trident_state
*state
, const char __user
*buf
,
3896 int cnt_for_multi_channel
, unsigned int *copy_count
,
3897 unsigned int *state_cnt
)
3900 struct dmabuf
*dmabuf
= &state
->dmabuf
;
3901 struct dmabuf
*dmabuf_temp
;
3902 const char __user
*buffer
= buf
;
3903 unsigned swptr
, other_dma_nums
, sample_s
;
3904 unsigned int i
, loop
;
3907 sample_s
= sample_size
[dmabuf
->fmt
] >> 1;
3908 swptr
= dmabuf
->swptr
;
3910 if ((i
= state
->multi_channels_adjust_count
) > 0) {
3912 if (copy_from_user(dmabuf
->rawbuf
+ swptr
,
3915 seek_offset(swptr
, buffer
, cnt_for_multi_channel
,
3916 sample_s
, *copy_count
);
3918 (*state_cnt
) += sample_s
;
3919 state
->multi_channels_adjust_count
++;
3921 i
= i
- (state
->chans_num
- other_dma_nums
);
3922 for (; (i
< other_dma_nums
) && (cnt_for_multi_channel
> 0); i
++) {
3923 dmabuf_temp
= &state
->other_states
[i
]->dmabuf
;
3924 if (copy_from_user(dmabuf_temp
->rawbuf
+ dmabuf_temp
->swptr
,
3927 seek_offset(dmabuf_temp
->swptr
, buffer
, cnt_for_multi_channel
,
3928 sample_s
, *copy_count
);
3930 if (cnt_for_multi_channel
== 0)
3931 state
->multi_channels_adjust_count
+= i
;
3933 if (cnt_for_multi_channel
> 0) {
3934 loop
= cnt_for_multi_channel
/ (state
->chans_num
* sample_s
);
3935 for (i
= 0; i
< loop
; i
++) {
3936 if (copy_from_user(dmabuf
->rawbuf
+ swptr
, buffer
,
3939 seek_offset(swptr
, buffer
, cnt_for_multi_channel
,
3940 sample_s
* 2, *copy_count
);
3941 (*state_cnt
) += (sample_s
* 2);
3943 dmabuf_temp
= &state
->other_states
[0]->dmabuf
;
3944 if (copy_from_user(dmabuf_temp
->rawbuf
+ dmabuf_temp
->swptr
,
3947 seek_offset(dmabuf_temp
->swptr
, buffer
, cnt_for_multi_channel
,
3948 sample_s
, *copy_count
);
3950 dmabuf_temp
= &state
->other_states
[1]->dmabuf
;
3951 if (copy_from_user(dmabuf_temp
->rawbuf
+ dmabuf_temp
->swptr
,
3954 seek_offset(dmabuf_temp
->swptr
, buffer
, cnt_for_multi_channel
,
3955 sample_s
, *copy_count
);
3957 dmabuf_temp
= &state
->other_states
[2]->dmabuf
;
3958 if (copy_from_user(dmabuf_temp
->rawbuf
+ dmabuf_temp
->swptr
,
3961 seek_offset(dmabuf_temp
->swptr
, buffer
, cnt_for_multi_channel
,
3962 sample_s
, *copy_count
);
3964 dmabuf_temp
= &state
->other_states
[3]->dmabuf
;
3965 if (copy_from_user(dmabuf_temp
->rawbuf
+ dmabuf_temp
->swptr
,
3968 seek_offset(dmabuf_temp
->swptr
, buffer
, cnt_for_multi_channel
,
3969 sample_s
, *copy_count
);
3972 if (cnt_for_multi_channel
> 0) {
3973 state
->multi_channels_adjust_count
= cnt_for_multi_channel
/ sample_s
;
3975 if (copy_from_user(dmabuf
->rawbuf
+ swptr
, buffer
, sample_s
))
3977 seek_offset(swptr
, buffer
, cnt_for_multi_channel
,
3978 sample_s
, *copy_count
);
3979 (*state_cnt
) += sample_s
;
3981 if (cnt_for_multi_channel
> 0) {
3982 if (copy_from_user(dmabuf
->rawbuf
+ swptr
,
3985 seek_offset(swptr
, buffer
, cnt_for_multi_channel
,
3986 sample_s
, *copy_count
);
3987 (*state_cnt
) += sample_s
;
3989 if (cnt_for_multi_channel
> 0) {
3990 int diff
= state
->chans_num
- other_dma_nums
;
3991 loop
= state
->multi_channels_adjust_count
- diff
;
3992 for (i
= 0; i
< loop
; i
++) {
3993 dmabuf_temp
= &state
->other_states
[i
]->dmabuf
;
3994 if (copy_from_user(dmabuf_temp
->rawbuf
+
3998 seek_offset(dmabuf_temp
->swptr
, buffer
,
3999 cnt_for_multi_channel
,
4000 sample_s
, *copy_count
);
4005 state
->multi_channels_adjust_count
= 0;
4007 for (i
= 0; i
< other_dma_nums
; i
++) {
4008 dmabuf_temp
= &state
->other_states
[i
]->dmabuf
;
4009 dmabuf_temp
->swptr
= dmabuf_temp
->swptr
% dmabuf_temp
->dmasize
;
4015 ali_free_other_states_resources(struct trident_state
*state
)
4018 struct trident_card
*card
= state
->card
;
4019 struct trident_state
*s
;
4020 unsigned other_states_count
;
4022 other_states_count
= state
->chans_num
- 2; /* except PCM L/R channels */
4023 for (i
= 0; i
< other_states_count
; i
++) {
4024 s
= state
->other_states
[i
];
4025 dealloc_dmabuf(&s
->dmabuf
, card
->pci_dev
);
4026 ali_disable_special_channel(s
->card
, s
->dmabuf
.channel
->num
);
4027 state
->card
->free_pcm_channel(s
->card
, s
->dmabuf
.channel
->num
);
4028 card
->states
[s
->virt
] = NULL
;
4033 static struct proc_dir_entry
*res
;
4036 ali_write_proc(struct file
*file
, const char __user
*buffer
, unsigned long count
, void *data
)
4038 struct trident_card
*card
= (struct trident_card
*) data
;
4039 unsigned long flags
;
4046 if (get_user(c
, buffer
))
4049 spin_lock_irqsave(&card
->lock
, flags
);
4052 ali_setup_spdif_out(card
, ALI_PCM_TO_SPDIF_OUT
);
4053 ali_disable_special_channel(card
, ALI_SPDIF_OUT_CHANNEL
);
4056 ali_setup_spdif_out(card
, ALI_SPDIF_OUT_TO_SPDIF_OUT
|
4060 ali_setup_spdif_out(card
, ALI_SPDIF_OUT_TO_SPDIF_OUT
|
4061 ALI_SPDIF_OUT_NON_PCM
);
4064 ali_disable_spdif_in(card
); //default
4067 ali_setup_spdif_in(card
);
4070 spin_unlock_irqrestore(&card
->lock
, flags
);
4075 /* OSS /dev/mixer file operation methods */
4077 trident_open_mixdev(struct inode
*inode
, struct file
*file
)
4080 int minor
= iminor(inode
);
4081 struct trident_card
*card
= devs
;
4083 for (card
= devs
; card
!= NULL
; card
= card
->next
)
4084 for (i
= 0; i
< NR_AC97
; i
++)
4085 if (card
->ac97_codec
[i
] != NULL
&&
4086 card
->ac97_codec
[i
]->dev_mixer
== minor
)
4093 file
->private_data
= card
->ac97_codec
[i
];
4095 return nonseekable_open(inode
, file
);
4099 trident_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
,
4102 struct ac97_codec
*codec
= (struct ac97_codec
*) file
->private_data
;
4104 return codec
->mixer_ioctl(codec
, cmd
, arg
);
4107 static /*const */ struct file_operations trident_mixer_fops
= {
4108 .owner
= THIS_MODULE
,
4109 .llseek
= no_llseek
,
4110 .ioctl
= trident_ioctl_mixdev
,
4111 .open
= trident_open_mixdev
,
4115 ali_reset_5451(struct trident_card
*card
)
4117 struct pci_dev
*pci_dev
= NULL
;
4119 unsigned short wCount
, wReg
;
4121 pci_dev
= pci_get_device(PCI_VENDOR_ID_AL
, PCI_DEVICE_ID_AL_M1533
,
4123 if (pci_dev
== NULL
)
4126 pci_read_config_dword(pci_dev
, 0x7c, &dwVal
);
4127 pci_write_config_dword(pci_dev
, 0x7c, dwVal
| 0x08000000);
4129 pci_read_config_dword(pci_dev
, 0x7c, &dwVal
);
4130 pci_write_config_dword(pci_dev
, 0x7c, dwVal
& 0xf7ffffff);
4132 pci_dev_put(pci_dev
);
4134 pci_dev
= card
->pci_dev
;
4135 if (pci_dev
== NULL
)
4138 pci_read_config_dword(pci_dev
, 0x44, &dwVal
);
4139 pci_write_config_dword(pci_dev
, 0x44, dwVal
| 0x000c0000);
4141 pci_read_config_dword(pci_dev
, 0x44, &dwVal
);
4142 pci_write_config_dword(pci_dev
, 0x44, dwVal
& 0xfffbffff);
4145 /* TODO: recognize if we have a PM capable codec and only do this */
4146 /* if the codec is PM capable */
4149 wReg
= ali_ac97_get(card
, 0, AC97_POWER_CONTROL
);
4150 if ((wReg
& 0x000f) == 0x000f)
4154 /* This is non fatal if you have a non PM capable codec.. */
4158 /* AC97 codec initialisation. */
4159 static int __devinit
4160 trident_ac97_init(struct trident_card
*card
)
4163 unsigned long ready_2nd
= 0;
4164 struct ac97_codec
*codec
;
4167 /* initialize controller side of AC link, and find out if secondary codes
4169 switch (card
->pci_id
) {
4170 case PCI_DEVICE_ID_ALI_5451
:
4171 if (ali_reset_5451(card
)) {
4172 printk(KERN_ERR
"trident_ac97_init: error "
4173 "resetting 5451.\n");
4176 outl(0x80000001, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
4177 outl(0x00000000, TRID_REG(card
, T4D_AINTEN_A
));
4178 outl(0xffffffff, TRID_REG(card
, T4D_AINT_A
));
4179 outl(0x00000000, TRID_REG(card
, T4D_MUSICVOL_WAVEVOL
));
4180 outb(0x10, TRID_REG(card
, ALI_MPUR2
));
4181 ready_2nd
= inl(TRID_REG(card
, ALI_SCTRL
));
4182 ready_2nd
&= 0x3fff;
4183 outl(ready_2nd
| PCMOUT
| 0x8000, TRID_REG(card
, ALI_SCTRL
));
4184 ready_2nd
= inl(TRID_REG(card
, ALI_SCTRL
));
4185 ready_2nd
&= SI_AC97_SECONDARY_READY
;
4186 if (card
->revision
< ALI_5451_V02
)
4189 case PCI_DEVICE_ID_SI_7018
:
4190 /* disable AC97 GPIO interrupt */
4191 outl(0x00, TRID_REG(card
, SI_AC97_GPIO
));
4192 /* when power up the AC link is in cold reset mode so stop it */
4193 outl(PCMOUT
| SURROUT
| CENTEROUT
| LFEOUT
| SECONDARY_ID
,
4194 TRID_REG(card
, SI_SERIAL_INTF_CTRL
));
4195 /* it take a long time to recover from a cold reset */
4196 /* (especially when you have more than one codec) */
4198 ready_2nd
= inl(TRID_REG(card
, SI_SERIAL_INTF_CTRL
));
4199 ready_2nd
&= SI_AC97_SECONDARY_READY
;
4201 case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX
:
4203 outl(DX_AC97_PLAYBACK
, TRID_REG(card
, DX_ACR2_AC97_COM_STAT
));
4205 case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX
:
4206 /* enable AC97 Output Slot 3,4 (PCM Left/Right Playback) */
4207 outl(NX_AC97_PCM_OUTPUT
, TRID_REG(card
, NX_ACR0_AC97_COM_STAT
));
4208 ready_2nd
= inl(TRID_REG(card
, NX_ACR0_AC97_COM_STAT
));
4209 ready_2nd
&= NX_AC97_SECONDARY_READY
;
4211 case PCI_DEVICE_ID_INTERG_5050
:
4212 /* disable AC97 GPIO interrupt */
4213 outl(0x00, TRID_REG(card
, SI_AC97_GPIO
));
4214 /* when power up, the AC link is in cold reset mode, so stop it */
4215 outl(PCMOUT
| SURROUT
| CENTEROUT
| LFEOUT
,
4216 TRID_REG(card
, SI_SERIAL_INTF_CTRL
));
4217 /* it take a long time to recover from a cold reset (especially */
4218 /* when you have more than one codec) */
4220 ready_2nd
= inl(TRID_REG(card
, SI_SERIAL_INTF_CTRL
));
4221 ready_2nd
&= SI_AC97_SECONDARY_READY
;
4225 for (num_ac97
= 0; num_ac97
< NR_AC97
; num_ac97
++) {
4226 if ((codec
= ac97_alloc_codec()) == NULL
)
4229 /* initialize some basic codec information, other fields */
4230 /* will be filled in ac97_probe_codec */
4231 codec
->private_data
= card
;
4232 codec
->id
= num_ac97
;
4234 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
4235 codec
->codec_read
= ali_ac97_read
;
4236 codec
->codec_write
= ali_ac97_write
;
4238 codec
->codec_read
= trident_ac97_get
;
4239 codec
->codec_write
= trident_ac97_set
;
4242 if (ac97_probe_codec(codec
) == 0)
4245 codec
->dev_mixer
= register_sound_mixer(&trident_mixer_fops
, -1);
4246 if (codec
->dev_mixer
< 0) {
4247 printk(KERN_ERR
"trident: couldn't register mixer!\n");
4248 ac97_release_codec(codec
);
4252 card
->ac97_codec
[num_ac97
] = codec
;
4254 /* if there is no secondary codec at all, don't probe any more */
4259 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
4260 for (num_ac97
= 0; num_ac97
< NR_AC97
; num_ac97
++) {
4261 if (card
->ac97_codec
[num_ac97
] == NULL
)
4263 for (i
= 0; i
< 64; i
++) {
4264 u16 reg
= ali_ac97_get(card
, num_ac97
, i
* 2);
4265 card
->mixer_regs
[i
][num_ac97
] = reg
;
4269 return num_ac97
+ 1;
4272 #ifdef SUPPORT_JOYSTICK
4273 /* Gameport functions for the cards ADC gameport */
4275 static unsigned char trident_game_read(struct gameport
*gameport
)
4277 struct trident_card
*card
= gameport
->port_data
;
4279 return inb(TRID_REG(card
, T4D_GAME_LEG
));
4282 static void trident_game_trigger(struct gameport
*gameport
)
4284 struct trident_card
*card
= gameport
->port_data
;
4286 outb(0xff, TRID_REG(card
, T4D_GAME_LEG
));
4289 static int trident_game_cooked_read(struct gameport
*gameport
,
4290 int *axes
, int *buttons
)
4292 struct trident_card
*card
= gameport
->port_data
;
4295 *buttons
= (~inb(TRID_REG(card
, T4D_GAME_LEG
)) >> 4) & 0xf;
4297 for (i
= 0; i
< 4; i
++) {
4298 axes
[i
] = inw(TRID_REG(card
, T4D_GAME_AXD
) + i
* sizeof (u16
));
4299 if (axes
[i
] == 0xffff)
4306 static int trident_game_open(struct gameport
*gameport
, int mode
)
4308 struct trident_card
*card
= gameport
->port_data
;
4311 case GAMEPORT_MODE_COOKED
:
4312 outb(0x80, TRID_REG(card
, T4D_GAME_CR
));
4315 case GAMEPORT_MODE_RAW
:
4316 outb(0x00, TRID_REG(card
, T4D_GAME_CR
));
4325 static int __devinit
trident_register_gameport(struct trident_card
*card
)
4327 struct gameport
*gp
;
4329 card
->gameport
= gp
= gameport_allocate_port();
4331 printk(KERN_ERR
"trident: can not allocate memory for gameport\n");
4335 gameport_set_name(gp
, "Trident 4DWave");
4336 gameport_set_phys(gp
, "pci%s/gameport0", pci_name(card
->pci_dev
));
4337 gp
->read
= trident_game_read
;
4338 gp
->trigger
= trident_game_trigger
;
4339 gp
->cooked_read
= trident_game_cooked_read
;
4340 gp
->open
= trident_game_open
;
4342 gp
->port_data
= card
;
4344 gameport_register_port(gp
);
4349 static inline void trident_unregister_gameport(struct trident_card
*card
)
4352 gameport_unregister_port(card
->gameport
);
4356 static inline int trident_register_gameport(struct trident_card
*card
) { return -ENOSYS
; }
4357 static inline void trident_unregister_gameport(struct trident_card
*card
) { }
4358 #endif /* SUPPORT_JOYSTICK */
4360 /* install the driver, we do not allocate hardware channel nor DMA buffer */
4361 /* now, they are defered until "ACCESS" time (in prog_dmabuf called by */
4362 /* open/read/write/ioctl/mmap) */
4363 static int __devinit
4364 trident_probe(struct pci_dev
*pci_dev
, const struct pci_device_id
*pci_id
)
4366 unsigned long iobase
;
4367 struct trident_card
*card
;
4372 struct pci_dev
*pci_dev_m1533
= NULL
;
4376 if (pci_enable_device(pci_dev
))
4379 if (pci_dev
->device
== PCI_DEVICE_ID_ALI_5451
)
4380 dma_mask
= ALI_DMA_MASK
;
4382 dma_mask
= TRIDENT_DMA_MASK
;
4383 if (pci_set_dma_mask(pci_dev
, dma_mask
)) {
4384 printk(KERN_ERR
"trident: architecture does not support"
4385 " %s PCI busmaster DMA\n",
4386 pci_dev
->device
== PCI_DEVICE_ID_ALI_5451
?
4387 "32-bit" : "30-bit");
4390 pci_read_config_byte(pci_dev
, PCI_CLASS_REVISION
, &revision
);
4392 if (pci_id
->device
== PCI_DEVICE_ID_INTERG_5050
)
4393 iobase
= pci_resource_start(pci_dev
, 1);
4395 iobase
= pci_resource_start(pci_dev
, 0);
4397 if (!request_region(iobase
, 256, card_names
[pci_id
->driver_data
])) {
4398 printk(KERN_ERR
"trident: can't allocate I/O space at "
4399 "0x%4.4lx\n", iobase
);
4404 if ((card
= kzalloc(sizeof(*card
), GFP_KERNEL
)) == NULL
) {
4405 printk(KERN_ERR
"trident: out of memory\n");
4406 goto out_release_region
;
4409 init_timer(&card
->timer
);
4410 card
->iobase
= iobase
;
4411 card
->pci_dev
= pci_dev_get(pci_dev
);
4412 card
->pci_id
= pci_id
->device
;
4413 card
->revision
= revision
;
4414 card
->irq
= pci_dev
->irq
;
4416 card
->magic
= TRIDENT_CARD_MAGIC
;
4417 card
->banks
[BANK_A
].addresses
= &bank_a_addrs
;
4418 card
->banks
[BANK_A
].bitmap
= 0UL;
4419 card
->banks
[BANK_B
].addresses
= &bank_b_addrs
;
4420 card
->banks
[BANK_B
].bitmap
= 0UL;
4422 mutex_init(&card
->open_mutex
);
4423 spin_lock_init(&card
->lock
);
4424 init_timer(&card
->timer
);
4428 pci_set_master(pci_dev
);
4430 printk(KERN_INFO
"trident: %s found at IO 0x%04lx, IRQ %d\n",
4431 card_names
[pci_id
->driver_data
], card
->iobase
, card
->irq
);
4433 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
4434 /* ALi channel Management */
4435 card
->alloc_pcm_channel
= ali_alloc_pcm_channel
;
4436 card
->alloc_rec_pcm_channel
= ali_alloc_rec_pcm_channel
;
4437 card
->free_pcm_channel
= ali_free_pcm_channel
;
4439 card
->address_interrupt
= ali_address_interrupt
;
4441 /* Added by Matt Wu 01-05-2001 for spdif in */
4442 card
->multi_channel_use_count
= 0;
4443 card
->rec_channel_use_count
= 0;
4445 /* ALi SPDIF OUT function */
4446 if (card
->revision
== ALI_5451_V02
) {
4447 ali_setup_spdif_out(card
, ALI_PCM_TO_SPDIF_OUT
);
4448 res
= create_proc_entry("ALi5451", 0, NULL
);
4450 res
->write_proc
= ali_write_proc
;
4455 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4457 pci_dev_m1533
= pci_find_device(PCI_VENDOR_ID_AL
,
4458 PCI_DEVICE_ID_AL_M1533
,
4461 if (pci_dev_m1533
== NULL
)
4463 pci_read_config_byte(pci_dev_m1533
, 0x63, &bits
);
4464 if (bits
& (1 << 5))
4466 if (card
->hwvolctl
) {
4467 /* Clear m1533 pci cfg 78h bit 30 to zero, which makes
4468 GPIO11/12/13 work as ACGP_UP/DOWN/MUTE. */
4469 pci_read_config_byte(pci_dev_m1533
, 0x7b, &bits
);
4470 bits
&= 0xbf; /*clear bit 6 */
4471 pci_write_config_byte(pci_dev_m1533
, 0x7b, bits
);
4473 } else if (card
->pci_id
== PCI_DEVICE_ID_INTERG_5050
) {
4474 card
->alloc_pcm_channel
= cyber_alloc_pcm_channel
;
4475 card
->alloc_rec_pcm_channel
= cyber_alloc_pcm_channel
;
4476 card
->free_pcm_channel
= cyber_free_pcm_channel
;
4477 card
->address_interrupt
= cyber_address_interrupt
;
4478 cyber_init_ritual(card
);
4480 card
->alloc_pcm_channel
= trident_alloc_pcm_channel
;
4481 card
->alloc_rec_pcm_channel
= trident_alloc_pcm_channel
;
4482 card
->free_pcm_channel
= trident_free_pcm_channel
;
4483 card
->address_interrupt
= trident_address_interrupt
;
4488 if (request_irq(card
->irq
, &trident_interrupt
, IRQF_SHARED
,
4489 card_names
[pci_id
->driver_data
], card
)) {
4490 printk(KERN_ERR
"trident: unable to allocate irq %d\n",
4494 /* register /dev/dsp */
4495 if ((card
->dev_audio
= register_sound_dsp(&trident_audio_fops
, -1)) < 0) {
4496 printk(KERN_ERR
"trident: couldn't register DSP device!\n");
4499 card
->mixer_regs_ready
= 0;
4500 /* initialize AC97 codec and register /dev/mixer */
4501 if (trident_ac97_init(card
) <= 0) {
4502 /* unregister audio devices */
4503 for (i
= 0; i
< NR_AC97
; i
++) {
4504 if (card
->ac97_codec
[i
] != NULL
) {
4505 struct ac97_codec
* codec
= card
->ac97_codec
[i
];
4506 unregister_sound_mixer(codec
->dev_mixer
);
4507 ac97_release_codec(codec
);
4510 goto out_unregister_sound_dsp
;
4512 card
->mixer_regs_ready
= 1;
4513 outl(0x00, TRID_REG(card
, T4D_MUSICVOL_WAVEVOL
));
4515 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
4516 /* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
4517 if (card
->hwvolctl
) {
4518 /* Enable GPIO IRQ (MISCINT bit 18h) */
4519 temp
= inw(TRID_REG(card
, T4D_MISCINT
+ 2));
4521 outw(temp
, TRID_REG(card
, T4D_MISCINT
+ 2));
4523 /* Enable H/W Volume Control GLOVAL CONTROL bit 0 */
4524 temp
= inw(TRID_REG(card
, ALI_GLOBAL_CONTROL
));
4526 outw(temp
, TRID_REG(card
, ALI_GLOBAL_CONTROL
));
4529 if (card
->revision
== ALI_5451_V02
)
4530 ali_close_multi_channels();
4531 /* edited by HMSEO for GT sound */
4532 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
4535 extern struct hwrpb_struct
*hwrpb
;
4537 if ((hwrpb
->sys_type
) == 201) {
4538 printk(KERN_INFO
"trident: Running on Alpha system "
4540 ac97_data
= ali_ac97_get(card
, 0, AC97_POWER_CONTROL
);
4541 ali_ac97_set(card
, 0, AC97_POWER_CONTROL
,
4542 ac97_data
| ALI_EAPD_POWER_DOWN
);
4545 #endif /* CONFIG_ALPHA_NAUTILUS || CONFIG_ALPHA_GENERIC */
4546 /* edited by HMSEO for GT sound */
4549 pci_set_drvdata(pci_dev
, card
);
4551 /* Enable Address Engine Interrupts */
4552 trident_enable_loop_interrupts(card
);
4554 /* Register gameport */
4555 trident_register_gameport(card
);
4560 out_unregister_sound_dsp
:
4561 unregister_sound_dsp(card
->dev_audio
);
4563 free_irq(card
->irq
, card
);
4565 pci_dev_put(card
->pci_dev
);
4567 remove_proc_entry("ALi5451", NULL
);
4573 release_region(iobase
, 256);
4577 static void __devexit
4578 trident_remove(struct pci_dev
*pci_dev
)
4581 struct trident_card
*card
= pci_get_drvdata(pci_dev
);
4584 * Kill running timers before unload. We can't have them
4585 * going off after rmmod!
4588 del_timer_sync(&card
->timer
);
4590 /* ALi S/PDIF and Power Management */
4591 if (card
->pci_id
== PCI_DEVICE_ID_ALI_5451
) {
4592 ali_setup_spdif_out(card
, ALI_PCM_TO_SPDIF_OUT
);
4593 ali_disable_special_channel(card
, ALI_SPDIF_OUT_CHANNEL
);
4594 ali_disable_spdif_in(card
);
4595 remove_proc_entry("ALi5451", NULL
);
4598 /* Unregister gameport */
4599 trident_unregister_gameport(card
);
4601 /* Kill interrupts, and SP/DIF */
4602 trident_disable_loop_interrupts(card
);
4604 /* free hardware resources */
4605 free_irq(card
->irq
, card
);
4606 release_region(card
->iobase
, 256);
4608 /* unregister audio devices */
4609 for (i
= 0; i
< NR_AC97
; i
++)
4610 if (card
->ac97_codec
[i
] != NULL
) {
4611 unregister_sound_mixer(card
->ac97_codec
[i
]->dev_mixer
);
4612 ac97_release_codec(card
->ac97_codec
[i
]);
4614 unregister_sound_dsp(card
->dev_audio
);
4616 pci_set_drvdata(pci_dev
, NULL
);
4617 pci_dev_put(card
->pci_dev
);
4621 MODULE_AUTHOR("Alan Cox, Aaron Holtzman, Ollie Lho, Ching Ling Lee, Muli Ben-Yehuda");
4622 MODULE_DESCRIPTION("Trident 4DWave/SiS 7018/ALi 5451 and Tvia/IGST CyberPro5050 PCI "
4624 MODULE_LICENSE("GPL");
4626 #define TRIDENT_MODULE_NAME "trident"
4628 static struct pci_driver trident_pci_driver
= {
4629 .name
= TRIDENT_MODULE_NAME
,
4630 .id_table
= trident_pci_tbl
,
4631 .probe
= trident_probe
,
4632 .remove
= __devexit_p(trident_remove
),
4634 .suspend
= trident_suspend
,
4635 .resume
= trident_resume
4640 trident_init_module(void)
4642 printk(KERN_INFO
"Trident 4DWave/SiS 7018/ALi 5451,Tvia CyberPro "
4643 "5050 PCI Audio, version " DRIVER_VERSION
", " __TIME__
" "
4646 return pci_register_driver(&trident_pci_driver
);
4650 trident_cleanup_module(void)
4652 pci_unregister_driver(&trident_pci_driver
);
4655 module_init(trident_init_module
);
4656 module_exit(trident_cleanup_module
);