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