开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
trident.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：118k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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