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