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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
nec_vrc5477.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：54k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

nec_vrc5477.c：源码内容
  1. /***********************************************************************
  2.  * Copyright 2001 MontaVista Software Inc.
  3.  * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
  4.  *
  5.  * drivers/sound/nec_vrc5477.c
  6.  *     AC97 sound dirver for NEC Vrc5477 chip (an integrated, 
  7.  *     multi-function controller chip for MIPS CPUs)
  8.  *
  9.  * This program is free software; you can redistribute  it and/or modify it
  10.  * under  the terms of  the GNU General  Public License as published by the
  11.  * Free Software Foundation;  either version 2 of the  License, or (at your
  12.  * option) any later version.
  13.  ***********************************************************************
  14.  */
  16. /*
  17.  * This code is derived from ite8172.c, which is written by Steve Longerbeam.
  18.  *
  19.  * Features:
  20.  *   Currently we only support the following capabilities:
  21.  * . mono output to PCM L/R (line out).
  22.  * . stereo output to PCM L/R (line out).
  23.  * . mono input from PCM L (line in).
  24.  * . stereo output from PCM (line in).
  25.  * . sampling rate at 48k or variable sampling rate 
  26.  * . support /dev/dsp, /dev/mixer devices, standard OSS devices.
  27.  * . only support 16-bit PCM format (hardware limit, no software
  28.  *   translation) 
  29.  * . support duplex, but no trigger or realtime.
  30.  *
  31.  *   Specifically the following are not supported:
  32.  * . app-set frag size.
  33.  * . mmap'ed buffer access
  34.  */
  36. /* 
  37.  * Original comments from ite8172.c file.
  38.  */
  40. /*
  41.  *
  42.  * Notes:
  43.  *
  44.  *  1. Much of the OSS buffer allocation, ioctl's, and mmap'ing are
  45.  *     taken, slightly modified or not at all, from the ES1371 driver,
  46.  *     so refer to the credits in es1371.c for those. The rest of the
  47.  *     code (probe, open, read, write, the ISR, etc.) is new.
  48.  *  2. The following support is untested:
  49.  *      * Memory mapping the audio buffers, and the ioctl controls that go
  50.  *        with it.
  51.  *      * S/PDIF output.
  52.  *  3. The following is not supported:
  53.  *      * I2S input.
  54.  *      * legacy audio mode.
  55.  *  4. Support for volume button interrupts is implemented but doesn't
  56.  *     work yet.
  57.  *
  58.  *  Revision history
  59.  *    02.08.2001  0.1   Initial release
  60.  */
  62. #include <linux/version.h>
  63. #include <linux/module.h>
  64. #include <linux/string.h>
  65. #include <linux/kernel.h>
  66. #include <linux/ioport.h>
  67. #include <linux/sched.h>
  68. #include <linux/delay.h>
  69. #include <linux/sound.h>
  70. #include <linux/slab.h>
  71. #include <linux/soundcard.h>
  72. #include <linux/pci.h>
  73. #include <linux/init.h>
  74. #include <linux/poll.h>
  75. #include <linux/bitops.h>
  76. #include <linux/proc_fs.h>
  77. #include <linux/spinlock.h>
  78. #include <linux/smp_lock.h>
  79. #include <linux/ac97_codec.h>
  80. #include <linux/wrapper.h>
  81. #include <asm/io.h>
  82. #include <asm/dma.h>
  83. #include <asm/uaccess.h>
  84. #include <asm/hardirq.h>
  86. #include <asm/ddb5xxx/debug.h>
  88. #undef VRC5477_AC97_VERBOSE_DEBUG
  90. /* one must turn on CONFIG_LL_DEBUG before VERBOSE_DEBUG is turned */
  91. #if defined(VRC5477_AC97_VERBOSE_DEBUG)
  92. #if !defined(CONFIG_LL_DEBUG)
  93. #error "You must turn CONFIG_LL_DEBUG"
  94. #endif
  95. #endif
  97. #if defined(VRC5477_AC97_VERBOSE_DEBUG)
  98. static u16 inTicket=0;  /* check sync between intr & write */
  99. static u16 outTicket=0;
  100. #endif
  102. /* --------------------------------------------------------------------- */
  104. #undef OSS_DOCUMENTED_MIXER_SEMANTICS
  106. static const unsigned sample_shift[] = { 0, 1, 1, 2 };
  108. #define         VRC5477_INT_CLR         0x0
  109. #define         VRC5477_INT_STATUS 0x0
  110. #define         VRC5477_CODEC_WR        0x4
  111. #define         VRC5477_CODEC_RD        0x8
  112. #define         VRC5477_CTRL            0x18
  113. #define         VRC5477_ACLINK_CTRL     0x1c
  114. #define         VRC5477_INT_MASK        0x24
  116. #define VRC5477_DAC1_CTRL 0x30
  117. #define VRC5477_DAC1L 0x34
  118. #define VRC5477_DAC1_BADDR 0x38
  119. #define VRC5477_DAC2_CTRL 0x3c
  120. #define VRC5477_DAC2L 0x40
  121. #define VRC5477_DAC2_BADDR 0x44
  122. #define VRC5477_DAC3_CTRL 0x48
  123. #define VRC5477_DAC3L 0x4c
  124. #define VRC5477_DAC3_BADDR 0x50
  126. #define VRC5477_ADC1_CTRL 0x54
  127. #define VRC5477_ADC1L 0x58
  128. #define VRC5477_ADC1_BADDR 0x5c
  129. #define VRC5477_ADC2_CTRL 0x60
  130. #define VRC5477_ADC2L 0x64
  131. #define VRC5477_ADC2_BADDR 0x68
  132. #define VRC5477_ADC3_CTRL 0x6c
  133. #define VRC5477_ADC3L 0x70
  134. #define VRC5477_ADC3_BADDR 0x74
  136. #define VRC5477_CODEC_WR_RWC (1 << 23)
  138. #define VRC5477_CODEC_RD_RRDYA (1 << 31)
  139. #define VRC5477_CODEC_RD_RRDYD (1 << 30)
  141. #define VRC5477_ACLINK_CTRL_RST_ON (1 << 15)
  142. #define VRC5477_ACLINK_CTRL_RST_TIME 0x7f
  143. #define VRC5477_ACLINK_CTRL_SYNC_ON (1 << 30)
  144. #define VRC5477_ACLINK_CTRL_CK_STOP_ON (1 << 31)
  146. #define VRC5477_CTRL_DAC2ENB (1 << 15) 
  147. #define VRC5477_CTRL_ADC2ENB (1 << 14) 
  148. #define VRC5477_CTRL_DAC1ENB (1 << 13) 
  149. #define VRC5477_CTRL_ADC1ENB (1 << 12) 
  151. #define VRC5477_INT_MASK_NMASK (1 << 31) 
  152. #define VRC5477_INT_MASK_DAC1END (1 << 5) 
  153. #define VRC5477_INT_MASK_DAC2END (1 << 4) 
  154. #define VRC5477_INT_MASK_DAC3END (1 << 3) 
  155. #define VRC5477_INT_MASK_ADC1END (1 << 2) 
  156. #define VRC5477_INT_MASK_ADC2END (1 << 1) 
  157. #define VRC5477_INT_MASK_ADC3END (1 << 0) 
  159. #define VRC5477_DMA_ACTIVATION (1 << 31)
  160. #define VRC5477_DMA_WIP (1 << 30)
  163. #define VRC5477_AC97_MODULE_NAME "NEC_Vrc5477_audio"
  164. #define PFX VRC5477_AC97_MODULE_NAME ": "
  166. /* --------------------------------------------------------------------- */
  168. struct vrc5477_ac97_state {
  169. /* list of vrc5477_ac97 devices */
  170. struct list_head devs;
  172. /* the corresponding pci_dev structure */
  173. struct pci_dev *dev;
  175. /* soundcore stuff */
  176. int dev_audio;
  178. /* hardware resources */
  179. unsigned long io;
  180. unsigned int irq;
  182. #ifdef CONFIG_LL_DEBUG
  183. /* debug /proc entry */
  184. struct proc_dir_entry *ps;
  185. struct proc_dir_entry *ac97_ps;
  186. #endif /* CONFIG_LL_DEBUG */
  188. struct ac97_codec codec;
  190. unsigned dacChannels, adcChannels;
  191. unsigned short dacRate, adcRate;
  193. spinlock_t lock;
  194. struct semaphore open_sem;
  195. mode_t open_mode;
  196. wait_queue_head_t open_wait;
  198. struct dmabuf {
  199. void *lbuf, *rbuf;
  200. dma_addr_t lbufDma, rbufDma;
  201. unsigned bufOrder;
  202. unsigned numFrag;
  203. unsigned fragShift;
  204. unsigned fragSize; /* redundant */
  205. unsigned fragTotalSize; /* = numFrag * fragSize(real)  */
  206. unsigned nextIn;
  207. unsigned nextOut;
  208. int count;
  209. unsigned error; /* over/underrun */
  210. wait_queue_head_t wait;
  211. /* OSS stuff */
  212. unsigned stopped:1;
  213. unsigned ready:1;
  214. } dma_dac, dma_adc;
  216. #define WORK_BUF_SIZE 2048
  217. struct {
  218. u16 lchannel;
  219. u16 rchannel;
  220. } workBuf[WORK_BUF_SIZE/4];
  221. };
  223. /* --------------------------------------------------------------------- */
  225. static LIST_HEAD(devs);
  227. /* --------------------------------------------------------------------- */
  229. extern inline unsigned ld2(unsigned int x)
  230. {
  231.     unsigned r = 0;
  233.     if (x >= 0x10000) {
  234. x >>= 16;
  235. r += 16;
  236.     }
  237.     if (x >= 0x100) {
  238. x >>= 8;
  239. r += 8;
  240.     }
  241.     if (x >= 0x10) {
  242. x >>= 4;
  243. r += 4;
  244.     }
  245.     if (x >= 4) {
  246. x >>= 2;
  247. r += 2;
  248.     }
  249.     if (x >= 2)
  250. r++;
  251.     return r;
  252. }
  254. /* --------------------------------------------------------------------- */
  256. static u16 rdcodec(struct ac97_codec *codec, u8 addr)
  257. {
  258. struct vrc5477_ac97_state *s = 
  259. (struct vrc5477_ac97_state *)codec->private_data;
  260. unsigned long flags;
  261. u32 result;
  263. spin_lock_irqsave(&s->lock, flags);
  265. /* wait until we can access codec registers */
  266. while (inl(s->io + VRC5477_CODEC_WR) & 0x80000000);
  268. /* write the address and "read" command to codec */
  269. addr = addr & 0x7f;
  270. outl((addr << 16) | VRC5477_CODEC_WR_RWC, s->io + VRC5477_CODEC_WR);
  272. /* get the return result */
  273. udelay(100); /* workaround hardware bug */
  274. while ( (result = inl(s->io + VRC5477_CODEC_RD)) & 
  275.                 (VRC5477_CODEC_RD_RRDYA | VRC5477_CODEC_RD_RRDYD) ) {
  276. /* we get either addr or data, or both */
  277. if (result & VRC5477_CODEC_RD_RRDYA) {
  278. MIPS_ASSERT(addr == ((result >> 16) & 0x7f) );
  279. }
  280. if (result & VRC5477_CODEC_RD_RRDYD) {
  281. break;
  282. }
  283. }
  285. spin_unlock_irqrestore(&s->lock, flags);
  287. return result & 0xffff;;
  288. }
  291. static void wrcodec(struct ac97_codec *codec, u8 addr, u16 data)
  292. {
  293. struct vrc5477_ac97_state *s = 
  294. (struct vrc5477_ac97_state *)codec->private_data;
  295. unsigned long flags;
  297. spin_lock_irqsave(&s->lock, flags);
  299. /* wait until we can access codec registers */
  300. while (inl(s->io + VRC5477_CODEC_WR) & 0x80000000);
  302. /* write the address and value to codec */
  303. outl((addr << 16) | data, s->io + VRC5477_CODEC_WR);
  305. spin_unlock_irqrestore(&s->lock, flags);
  306. }
  309. static void waitcodec(struct ac97_codec *codec)
  310. {
  311. struct vrc5477_ac97_state *s = 
  312. (struct vrc5477_ac97_state *)codec->private_data;
  314. /* wait until we can access codec registers */
  315. while (inl(s->io + VRC5477_CODEC_WR) & 0x80000000);
  316. }
  319. /* --------------------------------------------------------------------- */
  321. static void vrc5477_ac97_delay(int msec)
  322. {
  323. unsigned long tmo;
  324. signed long tmo2;
  326. if (in_interrupt())
  327. return;
  328.     
  329. tmo = jiffies + (msec*HZ)/1000;
  330. for (;;) {
  331. tmo2 = tmo - jiffies;
  332. if (tmo2 <= 0)
  333. break;
  334. schedule_timeout(tmo2);
  335. }
  336. }
  339. static void set_adc_rate(struct vrc5477_ac97_state *s, unsigned rate)
  340. {
  341. wrcodec(&s->codec, AC97_PCM_LR_ADC_RATE, rate);
  342. s->adcRate = rate;
  343. }
  346. static void set_dac_rate(struct vrc5477_ac97_state *s, unsigned rate)
  347. {
  348. wrcodec(&s->codec, AC97_PCM_FRONT_DAC_RATE, rate);
  349. s->dacRate = rate;
  350. }
  353. /* --------------------------------------------------------------------- */
  355. extern inline void 
  356. stop_dac(struct vrc5477_ac97_state *s)
  357. {
  358. struct dmabuf* db = &s->dma_dac;
  359. unsigned long flags;
  360. u32 temp;
  361.     
  362. spin_lock_irqsave(&s->lock, flags);
  364. if (db->stopped) {
  365. spin_unlock_irqrestore(&s->lock, flags);
  366. return;
  367. }
  369. /* deactivate the dma */
  370. outl(0, s->io + VRC5477_DAC1_CTRL);
  371. outl(0, s->io + VRC5477_DAC2_CTRL);
  373. /* wait for DAM completely stop */
  374. while (inl(s->io + VRC5477_DAC1_CTRL) & VRC5477_DMA_WIP);
  375. while (inl(s->io + VRC5477_DAC2_CTRL) & VRC5477_DMA_WIP);
  377. /* disable dac slots in aclink */
  378. temp = inl(s->io + VRC5477_CTRL);
  379. temp &= ~ (VRC5477_CTRL_DAC1ENB | VRC5477_CTRL_DAC2ENB);
  380. outl (temp, s->io + VRC5477_CTRL);
  382. /* disable interrupts */
  383. temp = inl(s->io + VRC5477_INT_MASK);
  384. temp &= ~ (VRC5477_INT_MASK_DAC1END | VRC5477_INT_MASK_DAC2END); 
  385. outl (temp, s->io + VRC5477_INT_MASK);
  387. /* clear pending ones */
  388. outl(VRC5477_INT_MASK_DAC1END | VRC5477_INT_MASK_DAC2END, 
  389.      s->io +  VRC5477_INT_CLR);
  390.     
  391. db->stopped = 1;
  392.     
  393. spin_unlock_irqrestore(&s->lock, flags);
  394. }
  396. static void start_dac(struct vrc5477_ac97_state *s)
  397. {
  398. struct dmabuf* db = &s->dma_dac;
  399. unsigned long flags;
  400. u32 dmaLength;
  401. u32 temp;
  403. spin_lock_irqsave(&s->lock, flags);
  405. if (!db->stopped) {
  406. spin_unlock_irqrestore(&s->lock, flags);
  407. return;
  408. }
  410. /* we should have some data to do the DMA trasnfer */
  411. MIPS_ASSERT(db->count >= db->fragSize);
  413. /* clear pending fales interrupts */
  414. outl(VRC5477_INT_MASK_DAC1END | VRC5477_INT_MASK_DAC2END, 
  415.      s->io +  VRC5477_INT_CLR);
  417. /* enable interrupts */
  418. temp = inl(s->io + VRC5477_INT_MASK);
  419. temp |= VRC5477_INT_MASK_DAC1END | VRC5477_INT_MASK_DAC2END;
  420. outl(temp, s->io +  VRC5477_INT_MASK);
  422. /* setup dma base addr */
  423. outl(db->lbufDma + db->nextOut, s->io + VRC5477_DAC1_BADDR);
  424. if (s->dacChannels == 1) {
  425. outl(db->lbufDma + db->nextOut, s->io + VRC5477_DAC2_BADDR);
  426. } else {
  427. outl(db->rbufDma + db->nextOut, s->io + VRC5477_DAC2_BADDR);
  428. }
  430. /* set dma length, in the unit of 0x10 bytes */
  431. dmaLength = db->fragSize >> 4;
  432. outl(dmaLength, s->io + VRC5477_DAC1L);
  433. outl(dmaLength, s->io + VRC5477_DAC2L);
  435. /* activate dma */
  436. outl(VRC5477_DMA_ACTIVATION, s->io + VRC5477_DAC1_CTRL);
  437. outl(VRC5477_DMA_ACTIVATION, s->io + VRC5477_DAC2_CTRL);
  439. /* enable dac slots - we should hear the music now! */
  440. temp = inl(s->io + VRC5477_CTRL);
  441. temp |= (VRC5477_CTRL_DAC1ENB | VRC5477_CTRL_DAC2ENB);
  442. outl (temp, s->io + VRC5477_CTRL);
  444. /* it is time to setup next dma transfer */
  445. MIPS_ASSERT(inl(s->io + VRC5477_DAC1_CTRL) & VRC5477_DMA_WIP);
  446. MIPS_ASSERT(inl(s->io + VRC5477_DAC2_CTRL) & VRC5477_DMA_WIP);
  448. temp = db->nextOut + db->fragSize;
  449. if (temp >= db->fragTotalSize) {
  450. MIPS_ASSERT(temp == db->fragTotalSize);
  451. temp = 0;
  452. }
  454. outl(db->lbufDma + temp, s->io + VRC5477_DAC1_BADDR);
  455. if (s->dacChannels == 1) {
  456. outl(db->lbufDma + temp, s->io + VRC5477_DAC2_BADDR);
  457. } else {
  458. outl(db->rbufDma + temp, s->io + VRC5477_DAC2_BADDR);
  459. }
  461. db->stopped = 0;
  463. #if defined(VRC5477_AC97_VERBOSE_DEBUG)
  464. outTicket = *(u16*)(db->lbuf+db->nextOut);
  465. if (db->count > db->fragSize) {
  466. MIPS_ASSERT((u16)(outTicket+1) == *(u16*)(db->lbuf+temp));
  467. }
  468. #endif
  470. spin_unlock_irqrestore(&s->lock, flags);
  471. }
  473. extern inline void stop_adc(struct vrc5477_ac97_state *s)
  474. {
  475. struct dmabuf* db = &s->dma_adc;
  476. unsigned long flags;
  477. u32 temp;
  478.     
  479. spin_lock_irqsave(&s->lock, flags);
  481. if (db->stopped) {
  482. spin_unlock_irqrestore(&s->lock, flags);
  483. return;
  484. }
  486. /* deactivate the dma */
  487. outl(0, s->io + VRC5477_ADC1_CTRL);
  488. outl(0, s->io + VRC5477_ADC2_CTRL);
  490. /* disable adc slots in aclink */
  491. temp = inl(s->io + VRC5477_CTRL);
  492. temp &= ~ (VRC5477_CTRL_ADC1ENB | VRC5477_CTRL_ADC2ENB);
  493. outl (temp, s->io + VRC5477_CTRL);
  495. /* disable interrupts */
  496.         temp = inl(s->io + VRC5477_INT_MASK);
  497.         temp &= ~ (VRC5477_INT_MASK_ADC1END | VRC5477_INT_MASK_ADC2END); 
  498.         outl (temp, s->io + VRC5477_INT_MASK);
  500. /* clear pending ones */
  501. outl(VRC5477_INT_MASK_ADC1END | VRC5477_INT_MASK_ADC2END, 
  502.      s->io +  VRC5477_INT_CLR);
  503.     
  504. db->stopped = 1;
  506. spin_unlock_irqrestore(&s->lock, flags);
  507. }
  509. static void start_adc(struct vrc5477_ac97_state *s)
  510. {
  511. struct dmabuf* db = &s->dma_adc;
  512. unsigned long flags;
  513. u32 dmaLength;
  514. u32 temp;
  516. spin_lock_irqsave(&s->lock, flags);
  518. if (!db->stopped) {
  519. spin_unlock_irqrestore(&s->lock, flags);
  520. return;
  521. }
  523. /* we should at least have some free space in the buffer */
  524. MIPS_ASSERT(db->count < db->fragTotalSize - db->fragSize * 2);
  526. /* clear pending ones */
  527. outl(VRC5477_INT_MASK_ADC1END | VRC5477_INT_MASK_ADC2END, 
  528.      s->io +  VRC5477_INT_CLR);
  530.         /* enable interrupts */
  531.         temp = inl(s->io + VRC5477_INT_MASK);
  532.         temp |= VRC5477_INT_MASK_ADC1END | VRC5477_INT_MASK_ADC2END;
  533.         outl(temp, s->io +  VRC5477_INT_MASK);
  535. /* setup dma base addr */
  536. outl(db->lbufDma + db->nextIn, s->io + VRC5477_ADC1_BADDR);
  537. outl(db->rbufDma + db->nextIn, s->io + VRC5477_ADC2_BADDR);
  539. /* setup dma length */
  540. dmaLength = db->fragSize >> 4;
  541. outl(dmaLength, s->io + VRC5477_ADC1L);
  542. outl(dmaLength, s->io + VRC5477_ADC2L);
  544. /* activate dma */
  545. outl(VRC5477_DMA_ACTIVATION, s->io + VRC5477_ADC1_CTRL);
  546. outl(VRC5477_DMA_ACTIVATION, s->io + VRC5477_ADC2_CTRL);
  548. /* enable adc slots */
  549. temp = inl(s->io + VRC5477_CTRL);
  550. temp |= (VRC5477_CTRL_ADC1ENB | VRC5477_CTRL_ADC2ENB);
  551. outl (temp, s->io + VRC5477_CTRL);
  553. /* it is time to setup next dma transfer */
  554. temp = db->nextIn + db->fragSize;
  555. if (temp >= db->fragTotalSize) {
  556. MIPS_ASSERT(temp == db->fragTotalSize);
  557. temp = 0;
  558. }
  559. outl(db->lbufDma + temp, s->io + VRC5477_ADC1_BADDR);
  560. outl(db->rbufDma + temp, s->io + VRC5477_ADC2_BADDR);
  562. db->stopped = 0;
  564. spin_unlock_irqrestore(&s->lock, flags);
  565. }
  567. /* --------------------------------------------------------------------- */
  569. #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
  570. #define DMABUF_MINORDER 1
  572. extern inline void dealloc_dmabuf(struct vrc5477_ac97_state *s, 
  573.   struct dmabuf *db)
  574. {
  575. if (db->lbuf) {
  576. MIPS_ASSERT(db->rbuf);
  577. pci_free_consistent(s->dev, PAGE_SIZE << db->bufOrder,
  578.     db->lbuf, db->lbufDma);
  579. pci_free_consistent(s->dev, PAGE_SIZE << db->bufOrder,
  580.     db->rbuf, db->rbufDma);
  581. db->lbuf = db->rbuf = NULL;
  582. }
  583. db->nextIn = db->nextOut = 0;
  584. db->ready = 0;
  585. }
  587. static int prog_dmabuf(struct vrc5477_ac97_state *s, 
  588.        struct dmabuf *db,
  589.        unsigned rate)
  590. {
  591. int order;
  592. unsigned bufsize;
  594. if (!db->lbuf) {
  595. MIPS_ASSERT(!db->rbuf);
  597. db->ready = 0;
  598. for (order = DMABUF_DEFAULTORDER; 
  599.      order >= DMABUF_MINORDER; 
  600.      order--) {
  601. db->lbuf = pci_alloc_consistent(s->dev,
  602. PAGE_SIZE << order,
  603. &db->lbufDma);
  604. db->rbuf = pci_alloc_consistent(s->dev,
  605. PAGE_SIZE << order,
  606. &db->rbufDma);
  607. if (db->lbuf && db->rbuf) break;
  608. if (db->lbuf) {
  609.     MIPS_ASSERT(!db->rbuf);
  610.     pci_free_consistent(s->dev, 
  611. PAGE_SIZE << order,
  612. db->lbuf,
  613. db->lbufDma);
  614. }
  615. }
  616. if (!db->lbuf) {
  617. MIPS_ASSERT(!db->rbuf);
  618. return -ENOMEM;
  619. }
  621. db->bufOrder = order;
  622. }
  624. db->count = 0;
  625. db->nextIn = db->nextOut = 0;
  626.     
  627. bufsize = PAGE_SIZE << db->bufOrder;
  628. db->fragShift = ld2(rate * 2 / 100);
  629. if (db->fragShift < 4) db->fragShift = 4;
  631. db->numFrag = bufsize >> db->fragShift;
  632. while (db->numFrag < 4 && db->fragShift > 4) {
  633. db->fragShift--;
  634. db->numFrag = bufsize >> db->fragShift;
  635. }
  636. db->fragSize = 1 << db->fragShift;
  637. db->fragTotalSize = db->numFrag << db->fragShift;
  638. memset(db->lbuf, 0, db->fragTotalSize);
  639. memset(db->rbuf, 0, db->fragTotalSize);
  640.     
  641. db->ready = 1;
  643. return 0;
  644. }
  646. extern inline int prog_dmabuf_adc(struct vrc5477_ac97_state *s)
  647. {
  648.     stop_adc(s);
  649.     return prog_dmabuf(s, &s->dma_adc, s->adcRate);
  650. }
  652. extern inline int prog_dmabuf_dac(struct vrc5477_ac97_state *s)
  653. {
  654.     stop_dac(s);
  655.     return prog_dmabuf(s, &s->dma_dac, s->dacRate);
  656. }
  659. /* --------------------------------------------------------------------- */
  660. /* hold spinlock for the following! */
  662. static inline void vrc5477_ac97_adc_interrupt(struct vrc5477_ac97_state *s)
  663. {
  664. struct dmabuf* adc = &s->dma_adc;
  665. unsigned temp;
  667. /* we need two frags avaiable because one is already being used
  668.  * and the other will be used when next interrupt happens.
  669.  */
  670. if (adc->count >= adc->fragTotalSize - adc->fragSize) {
  671. stop_adc(s);
  672. adc->error++;
  673. printk(KERN_INFO PFX "adc overrunn");
  674. return;
  675. }
  677. /* set the base addr for next DMA transfer */
  678. temp = adc->nextIn + 2*adc->fragSize;
  679. if (temp >= adc->fragTotalSize) {
  680. MIPS_ASSERT( (temp == adc->fragTotalSize) ||
  681.                              (temp == adc->fragTotalSize + adc->fragSize) );
  682. temp -= adc->fragTotalSize;
  683. }
  684. outl(adc->lbufDma + temp, s->io + VRC5477_ADC1_BADDR);
  685. outl(adc->rbufDma + temp, s->io + VRC5477_ADC2_BADDR);
  687. /* adjust nextIn */
  688. adc->nextIn += adc->fragSize;
  689. if (adc->nextIn >= adc->fragTotalSize) {
  690. MIPS_ASSERT(adc->nextIn == adc->fragTotalSize);
  691. adc->nextIn = 0;
  692. }
  694. /* adjust count */
  695. adc->count += adc->fragSize;
  697. /* wake up anybody listening */
  698. if (waitqueue_active(&adc->wait)) {
  699. wake_up_interruptible(&adc->wait);
  700. }
  701. }
  703. static inline void vrc5477_ac97_dac_interrupt(struct vrc5477_ac97_state *s)
  704. {
  705. struct dmabuf* dac = &s->dma_dac;
  706. unsigned temp;
  708. /* next DMA transfer should already started */
  709. MIPS_ASSERT(inl(s->io + VRC5477_DAC1_CTRL) & VRC5477_DMA_WIP);
  710. MIPS_ASSERT(inl(s->io + VRC5477_DAC2_CTRL) & VRC5477_DMA_WIP);
  712. /* let us set for next next DMA transfer */
  713. temp = dac->nextOut + dac->fragSize*2;
  714. if (temp >= dac->fragTotalSize) {
  715. MIPS_ASSERT( (temp == dac->fragTotalSize) || 
  716.                              (temp == dac->fragTotalSize + dac->fragSize) );
  717. temp -= dac->fragTotalSize;
  718. }
  719. outl(dac->lbufDma + temp, s->io + VRC5477_DAC1_BADDR);
  720. if (s->dacChannels == 1) {
  721. outl(dac->lbufDma + temp, s->io + VRC5477_DAC2_BADDR);
  722. } else {
  723. outl(dac->rbufDma + temp, s->io + VRC5477_DAC2_BADDR);
  724. }
  726. #if defined(VRC5477_AC97_VERBOSE_DEBUG)
  727. if (*(u16*)(dac->lbuf +  dac->nextOut) != outTicket) {
  728. printk("assert fail: - %d vs %dn", 
  729.         *(u16*)(dac->lbuf +  dac->nextOut),
  730.                         outTicket);
  731.                 MIPS_ASSERT(1 == 0);
  732. }
  733. #endif
  735. /* adjust nextOut pointer */
  736. dac->nextOut += dac->fragSize;
  737. if (dac->nextOut >= dac->fragTotalSize) {
  738. MIPS_ASSERT(dac->nextOut == dac->fragTotalSize);
  739. dac->nextOut = 0;
  740. }
  742. /* adjust count */
  743. dac->count -= dac->fragSize;
  744. if (dac->count <=0 ) {
  745. MIPS_ASSERT(dac->count == 0);
  746. MIPS_ASSERT(dac->nextIn == dac->nextOut);
  747. /* buffer under run */
  748. stop_dac(s);
  749. }
  751. #if defined(VRC5477_AC97_VERBOSE_DEBUG)
  752. if (dac->count) {
  753. outTicket ++;
  754. MIPS_ASSERT(*(u16*)(dac->lbuf +  dac->nextOut) == outTicket);
  755. }
  756. #endif
  758. /* we cannot have both under run and someone is waiting on us */
  759. MIPS_ASSERT(! (waitqueue_active(&dac->wait) && (dac->count <= 0)) );
  761. /* wake up anybody listening */
  762. if (waitqueue_active(&dac->wait))
  763. wake_up_interruptible(&dac->wait);
  764. }
  766. static void vrc5477_ac97_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  767. {
  768. struct vrc5477_ac97_state *s = (struct vrc5477_ac97_state *)dev_id;
  769. u32 irqStatus;
  770. u32 adcInterrupts, dacInterrupts;
  772. spin_lock(&s->lock);
  774. /* get irqStatus and clear the detected ones */
  775. irqStatus = inl(s->io + VRC5477_INT_STATUS);
  776. outl(irqStatus, s->io + VRC5477_INT_CLR);
  778. /* let us see what we get */
  779. dacInterrupts = VRC5477_INT_MASK_DAC1END | VRC5477_INT_MASK_DAC2END;
  780. adcInterrupts = VRC5477_INT_MASK_ADC1END | VRC5477_INT_MASK_ADC2END;
  781. if (irqStatus & dacInterrupts) {
  782. /* we should get both interrupts, but just in case ...  */
  783. if (irqStatus & VRC5477_INT_MASK_DAC1END) {
  784. vrc5477_ac97_dac_interrupt(s);
  785. }
  786. if ( (irqStatus & dacInterrupts) != dacInterrupts ) {
  787. printk(KERN_WARNING "vrc5477_ac97 : dac interrupts not in sync!!!n");
  788. stop_dac(s);
  789. start_dac(s);
  790. }
  791. } else if (irqStatus & adcInterrupts) {
  792. /* we should get both interrupts, but just in case ...  */
  793. if(irqStatus & VRC5477_INT_MASK_ADC1END) {
  794. vrc5477_ac97_adc_interrupt(s);
  795. } 
  796. if ( (irqStatus & adcInterrupts) != adcInterrupts ) {
  797. printk(KERN_WARNING "vrc5477_ac97 : adc interrupts not in sync!!!n");
  798. stop_adc(s);
  799. start_adc(s);
  800. }
  801. }
  803. spin_unlock(&s->lock);
  804. }
  806. /* --------------------------------------------------------------------- */
  808. static loff_t vrc5477_ac97_llseek(struct file *file, loff_t offset, int origin)
  809. {
  810. return -ESPIPE;
  811. }
  814. static int vrc5477_ac97_open_mixdev(struct inode *inode, struct file *file)
  815. {
  816. int minor = MINOR(inode->i_rdev);
  817. struct list_head *list;
  818. struct vrc5477_ac97_state *s;
  820. for (list = devs.next; ; list = list->next) {
  821. if (list == &devs)
  822. return -ENODEV;
  823. s = list_entry(list, struct vrc5477_ac97_state, devs);
  824. if (s->codec.dev_mixer == minor)
  825. break;
  826. }
  827. file->private_data = s;
  828. return 0;
  829. }
  831. static int vrc5477_ac97_release_mixdev(struct inode *inode, struct file *file)
  832. {
  833. return 0;
  834. }
  837. static int mixdev_ioctl(struct ac97_codec *codec, unsigned int cmd,
  838. unsigned long arg)
  839. {
  840. return codec->mixer_ioctl(codec, cmd, arg);
  841. }
  843. static int vrc5477_ac97_ioctl_mixdev(struct inode *inode, struct file *file,
  844.      unsigned int cmd, unsigned long arg)
  845. {
  846.     struct vrc5477_ac97_state *s = 
  847.     (struct vrc5477_ac97_state *)file->private_data;
  848.     struct ac97_codec *codec = &s->codec;
  850.     return mixdev_ioctl(codec, cmd, arg);
  851. }
  853. static /*const*/ struct file_operations vrc5477_ac97_mixer_fops = {
  854. owner: THIS_MODULE,
  855. llseek: vrc5477_ac97_llseek,
  856. ioctl: vrc5477_ac97_ioctl_mixdev,
  857. open: vrc5477_ac97_open_mixdev,
  858. release: vrc5477_ac97_release_mixdev,
  859. };
  861. /* --------------------------------------------------------------------- */
  863. static int drain_dac(struct vrc5477_ac97_state *s, int nonblock)
  864. {
  865. unsigned long flags;
  866. int count, tmo;
  868. if (!s->dma_dac.ready)
  869. return 0;
  871. for (;;) {
  872. spin_lock_irqsave(&s->lock, flags);
  873. count = s->dma_dac.count;
  874. spin_unlock_irqrestore(&s->lock, flags);
  875. if (count <= 0)
  876. break;
  877. if (signal_pending(current))
  878. break;
  879. if (nonblock)
  880. return -EBUSY;
  881. tmo = 1000 * count / s->dacRate / 2;
  882. vrc5477_ac97_delay(tmo);
  883. }
  884. if (signal_pending(current))
  885. return -ERESTARTSYS;
  886. return 0;
  887. }
  889. /* --------------------------------------------------------------------- */
  891. static int inline 
  892. copy_two_channel_adc_to_user(struct vrc5477_ac97_state *s, 
  893.              char *buffer, 
  894.      int copyCount)
  895. {
  896. struct dmabuf *db = &s->dma_adc;
  897. int bufStart = db->nextOut;
  898. for (; copyCount > 0; ) {
  899. int i;
  900. int count = copyCount;
  901. if (count > WORK_BUF_SIZE/2) count = WORK_BUF_SIZE/2;
  902. for (i=0; i< count/2; i++) {
  903. s->workBuf[i].lchannel = 
  904. *(u16*)(db->lbuf + bufStart + i*2);
  905. s->workBuf[i].rchannel = 
  906. *(u16*)(db->rbuf + bufStart + i*2);
  907. }
  908. if (copy_to_user(buffer, s->workBuf, count*2)) {
  909. return -1;
  910. }
  912. copyCount -= count;
  913. bufStart += count;
  914. MIPS_ASSERT(bufStart <= db->fragTotalSize);
  915. buffer += count *2;
  916. }
  917. return 0;
  918. }
  920. /* return the total bytes that is copied */
  921. static int inline 
  922. copy_adc_to_user(struct vrc5477_ac97_state *s,
  923.  char * buffer,
  924.  size_t count,
  925.  int avail)
  926. {
  927. struct dmabuf *db = &s->dma_adc;
  928. int copyCount=0;
  929. int copyFragCount=0;
  930. int totalCopyCount = 0;
  931. int totalCopyFragCount = 0;
  932. unsigned long flags;
  934. /* adjust count to signel channel byte count */
  935. count >>= s->adcChannels - 1;
  937. /* we may have to "copy" twice as ring buffer wraps around */
  938. for (; (avail > 0) && (count > 0); ) {
  939. /* determine max possible copy count for single channel */
  940. copyCount = count;
  941. if (copyCount > avail) {
  942. copyCount = avail;
  943. }
  944. if (copyCount + db->nextOut > db->fragTotalSize) {
  945. copyCount = db->fragTotalSize - db->nextOut;
  946. MIPS_ASSERT((copyCount % db->fragSize) == 0);
  947. }
  949. copyFragCount = (copyCount-1) >> db->fragShift;
  950. copyFragCount = (copyFragCount+1) << db->fragShift;
  951. MIPS_ASSERT(copyFragCount >= copyCount);
  953. /* we copy differently based on adc channels */
  954. if (s->adcChannels == 1) {
  955. if (copy_to_user(buffer, 
  956.  db->lbuf + db->nextOut, 
  957.  copyCount)) 
  958. return -1;
  959. } else {
  960. /* *sigh* we have to mix two streams into one  */
  961. if (copy_two_channel_adc_to_user(s, buffer, copyCount))
  962. return -1;
  963. }
  965. count -= copyCount;
  966. totalCopyCount += copyCount;
  967. avail -= copyFragCount;
  968. totalCopyFragCount += copyFragCount;
  970. buffer += copyCount << (s->adcChannels-1);
  972. db->nextOut += copyFragCount;
  973. if (db->nextOut >= db->fragTotalSize) {
  974. MIPS_ASSERT(db->nextOut == db->fragTotalSize);
  975. db->nextOut = 0;
  976. }
  978. MIPS_ASSERT((copyFragCount % db->fragSize) == 0);
  979. MIPS_ASSERT( (count == 0) || (copyCount == copyFragCount));
  980. }
  982. spin_lock_irqsave(&s->lock, flags);
  983.         db->count -= totalCopyFragCount;
  984.         spin_unlock_irqrestore(&s->lock, flags);
  986. return totalCopyCount << (s->adcChannels-1);
  987. }
  989. static ssize_t 
  990. vrc5477_ac97_read(struct file *file, 
  991.   char *buffer,
  992.   size_t count, 
  993.   loff_t *ppos)
  994. {
  995. struct vrc5477_ac97_state *s = 
  996. (struct vrc5477_ac97_state *)file->private_data;
  997. struct dmabuf *db = &s->dma_adc;
  998. ssize_t ret = 0;
  999. unsigned long flags;
  1000. int copyCount;
  1001. size_t avail;
  1003. if (ppos != &file->f_pos)
  1004. return -ESPIPE;
  1005. if (!access_ok(VERIFY_WRITE, buffer, count))
  1006. return -EFAULT;
  1008. MIPS_ASSERT(db->ready);
  1010. while (count > 0) {
  1011. // wait for samples in capture buffer
  1012. do {
  1013. spin_lock_irqsave(&s->lock, flags);
  1014. if (db->stopped)
  1015. start_adc(s);
  1016. avail = db->count;
  1017. spin_unlock_irqrestore(&s->lock, flags);
  1018. if (avail <= 0) {
  1019. if (file->f_flags & O_NONBLOCK) {
  1020. if (!ret)
  1021. ret = -EAGAIN;
  1022. return ret;
  1023. }
  1024. interruptible_sleep_on(&db->wait);
  1025. if (signal_pending(current)) {
  1026. if (!ret)
  1027. ret = -ERESTARTSYS;
  1028. return ret;
  1029. }
  1030. }
  1031. } while (avail <= 0);
  1033. MIPS_ASSERT( (avail % db->fragSize) == 0);
  1034. copyCount = copy_adc_to_user(s, buffer, count, avail);
  1035. if (copyCount <=0 ) {
  1036. if (!ret) ret = -EFAULT;
  1037. return ret;
  1038. }
  1040. count -= copyCount;
  1041. buffer += copyCount;
  1042. ret += copyCount;
  1043. } // while (count > 0)
  1045. return ret;
  1046. }
  1048. static int inline 
  1049. copy_two_channel_dac_from_user(struct vrc5477_ac97_state *s, 
  1050.        const char *buffer, 
  1051.        int copyCount)
  1052. {
  1053. struct dmabuf *db = &s->dma_dac;
  1054. int bufStart = db->nextIn;
  1056. MIPS_ASSERT(db->ready);
  1058.         for (; copyCount > 0; ) {
  1059.                 int i;
  1060.                 int count = copyCount;
  1061.                 if (count > WORK_BUF_SIZE/2) count = WORK_BUF_SIZE/2;
  1062.                 if (copy_from_user(s->workBuf, buffer, count*2)) {
  1063.                         return -1;
  1064.                 }
  1065.                 for (i=0; i< count/2; i++) {
  1066. *(u16*)(db->lbuf + bufStart + i*2) = 
  1067. s->workBuf[i].lchannel;
  1068. *(u16*)(db->rbuf + bufStart + i*2) = 
  1069. s->workBuf[i].rchannel;
  1070.                 }
  1072.                 copyCount -= count;
  1073. bufStart += count;
  1074. MIPS_ASSERT(bufStart <= db->fragTotalSize);
  1075.                 buffer += count *2;
  1076.         }
  1077.         return 0;
  1079. }
  1081. /* return the total bytes that is copied */
  1082. static int inline 
  1083. copy_dac_from_user(struct vrc5477_ac97_state *s, 
  1084.    const char *buffer, 
  1085.    size_t count, 
  1086.    int avail)
  1087. {
  1088.         struct dmabuf *db = &s->dma_dac;
  1089.         int copyCount=0;
  1090.         int copyFragCount=0;
  1091.         int totalCopyCount = 0;
  1092.         int totalCopyFragCount = 0;
  1093.         unsigned long flags;
  1094. #if defined(VRC5477_AC97_VERBOSE_DEBUG)
  1095. int i;
  1096. #endif
  1098.         /* adjust count to signel channel byte count */
  1099.         count >>= s->dacChannels - 1;
  1101.         /* we may have to "copy" twice as ring buffer wraps around */
  1102.         for (; (avail > 0) && (count > 0); ) {
  1103.                 /* determine max possible copy count for single channel */
  1104.                 copyCount = count;
  1105.                 if (copyCount > avail) {
  1106.                         copyCount = avail;
  1107. }
  1108.                 if (copyCount + db->nextIn > db->fragTotalSize) {
  1109.                         copyCount = db->fragTotalSize - db->nextIn;
  1110.                         MIPS_ASSERT((copyCount % db->fragSize) == 0);
  1111.                         MIPS_ASSERT(copyCount > 0);
  1112.                 }
  1114. copyFragCount = (copyCount-1) >> db->fragShift;
  1115. copyFragCount = (copyFragCount+1) << db->fragShift;
  1116. MIPS_ASSERT(copyFragCount >= copyCount);
  1118. /* we copy differently based on the number channels */
  1119. if (s->dacChannels == 1) {
  1120. if (copy_from_user(db->lbuf + db->nextIn,
  1121.    buffer,
  1122.    copyCount)) 
  1123. return -1;
  1124. /* fill gaps with 0 */
  1125. memset(db->lbuf + db->nextIn + copyCount,
  1126.        0,
  1127.        copyFragCount - copyCount);
  1128. } else {
  1129. /* we have demux the stream into two separate ones */
  1130. if (copy_two_channel_dac_from_user(s, buffer, copyCount))
  1131. return -1;
  1132. /* fill gaps with 0 */
  1133. memset(db->lbuf + db->nextIn + copyCount,
  1134.        0,
  1135.        copyFragCount - copyCount);
  1136. memset(db->rbuf + db->nextIn + copyCount,
  1137.        0,
  1138.        copyFragCount - copyCount);
  1139. }
  1141. #if defined(VRC5477_AC97_VERBOSE_DEBUG)
  1142. for (i=0; i< copyFragCount; i+= db->fragSize) {
  1143. *(u16*)(db->lbuf + db->nextIn + i) = inTicket ++;
  1144. }
  1145. #endif
  1147. count -= copyCount;
  1148. totalCopyCount =+ copyCount;
  1149. avail -= copyFragCount;
  1150. totalCopyFragCount += copyFragCount;
  1152. buffer += copyCount << (s->dacChannels - 1);
  1154. db->nextIn += copyFragCount;
  1155. if (db->nextIn >= db->fragTotalSize) {
  1156. MIPS_ASSERT(db->nextIn == db->fragTotalSize);
  1157. db->nextIn = 0;
  1158. }
  1160. MIPS_ASSERT((copyFragCount % db->fragSize) == 0);
  1161. MIPS_ASSERT( (count == 0) || (copyCount == copyFragCount));
  1162. }
  1164. spin_lock_irqsave(&s->lock, flags);
  1165.         db->count += totalCopyFragCount;
  1166. if (db->stopped) {
  1167. start_dac(s);
  1168. }
  1170. /* nextIn should not be equal to nextOut unless we are full */
  1171. MIPS_ASSERT( ( (db->count == db->fragTotalSize) && 
  1172.                        (db->nextIn == db->nextOut) ) ||
  1173.                      ( (db->count < db->fragTotalSize) &&
  1174.                        (db->nextIn != db->nextOut) ) );
  1176.         spin_unlock_irqrestore(&s->lock, flags);
  1178.         return totalCopyCount << (s->dacChannels-1);
  1180. }
  1182. static ssize_t vrc5477_ac97_write(struct file *file, const char *buffer,
  1183.   size_t count, loff_t *ppos)
  1184. {
  1185. struct vrc5477_ac97_state *s = 
  1186. (struct vrc5477_ac97_state *)file->private_data;
  1187. struct dmabuf *db = &s->dma_dac;
  1188. ssize_t ret;
  1189. unsigned long flags;
  1190. int copyCount, avail;
  1192. if (ppos != &file->f_pos)
  1193. return -ESPIPE;
  1194. if (!access_ok(VERIFY_READ, buffer, count))
  1195. return -EFAULT;
  1196. ret = 0;
  1197.     
  1198. while (count > 0) {
  1199. // wait for space in playback buffer
  1200. do {
  1201. spin_lock_irqsave(&s->lock, flags);
  1202. avail = db->fragTotalSize - db->count;
  1203. spin_unlock_irqrestore(&s->lock, flags);
  1204. if (avail <= 0) {
  1205. if (file->f_flags & O_NONBLOCK) {
  1206. if (!ret)
  1207. ret = -EAGAIN;
  1208. return ret;
  1209. }
  1210. interruptible_sleep_on(&db->wait);
  1211. if (signal_pending(current)) {
  1212. if (!ret)
  1213. ret = -ERESTARTSYS;
  1214. return ret;
  1215. }
  1216. }
  1217. } while (avail <= 0);
  1219. MIPS_ASSERT( (avail % db->fragSize) == 0);
  1220. copyCount = copy_dac_from_user(s, buffer, count, avail);
  1221. if (copyCount < 0) {
  1222. if (!ret) ret = -EFAULT;
  1223. return ret;
  1224. }
  1226. count -= copyCount;
  1227. buffer += copyCount;
  1228. ret += copyCount;
  1229. } // while (count > 0)
  1231. return ret;
  1232. }
  1234. /* No kernel lock - we have our own spinlock */
  1235. static unsigned int vrc5477_ac97_poll(struct file *file,
  1236.       struct poll_table_struct *wait)
  1237. {
  1238. struct vrc5477_ac97_state *s = (struct vrc5477_ac97_state *)file->private_data;
  1239. unsigned long flags;
  1240. unsigned int mask = 0;
  1242. if (file->f_mode & FMODE_WRITE)
  1243. poll_wait(file, &s->dma_dac.wait, wait);
  1244. if (file->f_mode & FMODE_READ)
  1245. poll_wait(file, &s->dma_adc.wait, wait);
  1246. spin_lock_irqsave(&s->lock, flags);
  1247. if (file->f_mode & FMODE_READ) {
  1248. if (s->dma_adc.count >= (signed)s->dma_adc.fragSize)
  1249. mask |= POLLIN | POLLRDNORM;
  1250. }
  1251. if (file->f_mode & FMODE_WRITE) {
  1252. if ((signed)s->dma_dac.fragTotalSize >=
  1253.     s->dma_dac.count + (signed)s->dma_dac.fragSize)
  1254. mask |= POLLOUT | POLLWRNORM;
  1255. }
  1256. spin_unlock_irqrestore(&s->lock, flags);
  1257. return mask;
  1258. }
  1260. #ifdef CONFIG_LL_DEBUG
  1261. static struct ioctl_str_t {
  1262.     unsigned int cmd;
  1263.     const char* str;
  1264. } ioctl_str[] = {
  1265.     {SNDCTL_DSP_RESET, "SNDCTL_DSP_RESET"},
  1266.     {SNDCTL_DSP_SYNC, "SNDCTL_DSP_SYNC"},
  1267.     {SNDCTL_DSP_SPEED, "SNDCTL_DSP_SPEED"},
  1268.     {SNDCTL_DSP_STEREO, "SNDCTL_DSP_STEREO"},
  1269.     {SNDCTL_DSP_GETBLKSIZE, "SNDCTL_DSP_GETBLKSIZE"},
  1270.     {SNDCTL_DSP_SETFMT, "SNDCTL_DSP_SETFMT"},
  1271.     {SNDCTL_DSP_SAMPLESIZE, "SNDCTL_DSP_SAMPLESIZE"},
  1272.     {SNDCTL_DSP_CHANNELS, "SNDCTL_DSP_CHANNELS"},
  1273.     {SOUND_PCM_WRITE_CHANNELS, "SOUND_PCM_WRITE_CHANNELS"},
  1274.     {SOUND_PCM_WRITE_FILTER, "SOUND_PCM_WRITE_FILTER"},
  1275.     {SNDCTL_DSP_POST, "SNDCTL_DSP_POST"},
  1276.     {SNDCTL_DSP_SUBDIVIDE, "SNDCTL_DSP_SUBDIVIDE"},
  1277.     {SNDCTL_DSP_SETFRAGMENT, "SNDCTL_DSP_SETFRAGMENT"},
  1278.     {SNDCTL_DSP_GETFMTS, "SNDCTL_DSP_GETFMTS"},
  1279.     {SNDCTL_DSP_GETOSPACE, "SNDCTL_DSP_GETOSPACE"},
  1280.     {SNDCTL_DSP_GETISPACE, "SNDCTL_DSP_GETISPACE"},
  1281.     {SNDCTL_DSP_NONBLOCK, "SNDCTL_DSP_NONBLOCK"},
  1282.     {SNDCTL_DSP_GETCAPS, "SNDCTL_DSP_GETCAPS"},
  1283.     {SNDCTL_DSP_GETTRIGGER, "SNDCTL_DSP_GETTRIGGER"},
  1284.     {SNDCTL_DSP_SETTRIGGER, "SNDCTL_DSP_SETTRIGGER"},
  1285.     {SNDCTL_DSP_GETIPTR, "SNDCTL_DSP_GETIPTR"},
  1286.     {SNDCTL_DSP_GETOPTR, "SNDCTL_DSP_GETOPTR"},
  1287.     {SNDCTL_DSP_MAPINBUF, "SNDCTL_DSP_MAPINBUF"},
  1288.     {SNDCTL_DSP_MAPOUTBUF, "SNDCTL_DSP_MAPOUTBUF"},
  1289.     {SNDCTL_DSP_SETSYNCRO, "SNDCTL_DSP_SETSYNCRO"},
  1290.     {SNDCTL_DSP_SETDUPLEX, "SNDCTL_DSP_SETDUPLEX"},
  1291.     {SNDCTL_DSP_GETODELAY, "SNDCTL_DSP_GETODELAY"},
  1292.     {SNDCTL_DSP_GETCHANNELMASK, "SNDCTL_DSP_GETCHANNELMASK"},
  1293.     {SNDCTL_DSP_BIND_CHANNEL, "SNDCTL_DSP_BIND_CHANNEL"},
  1294.     {OSS_GETVERSION, "OSS_GETVERSION"},
  1295.     {SOUND_PCM_READ_RATE, "SOUND_PCM_READ_RATE"},
  1296.     {SOUND_PCM_READ_CHANNELS, "SOUND_PCM_READ_CHANNELS"},
  1297.     {SOUND_PCM_READ_BITS, "SOUND_PCM_READ_BITS"},
  1298.     {SOUND_PCM_READ_FILTER, "SOUND_PCM_READ_FILTER"}
  1299. };
  1300. #endif    
  1302. static int vrc5477_ac97_ioctl(struct inode *inode, struct file *file,
  1303. unsigned int cmd, unsigned long arg)
  1304. {
  1305. struct vrc5477_ac97_state *s = (struct vrc5477_ac97_state *)file->private_data;
  1306. unsigned long flags;
  1307. audio_buf_info abinfo;
  1308. int count;
  1309. int val, ret;
  1311. #ifdef CONFIG_LL_DEBUG
  1312. for (count=0; count<sizeof(ioctl_str)/sizeof(ioctl_str[0]); count++) {
  1313. if (ioctl_str[count].cmd == cmd)
  1314. break;
  1315. }
  1316. if (count < sizeof(ioctl_str)/sizeof(ioctl_str[0]))
  1317. printk(KERN_INFO PFX "ioctl %sn", ioctl_str[count].str);
  1318. else
  1319. printk(KERN_INFO PFX "ioctl unknown, 0x%xn", cmd);
  1320. #endif
  1321.     
  1322. switch (cmd) {
  1323. case OSS_GETVERSION:
  1324. return put_user(SOUND_VERSION, (int *)arg);
  1326. case SNDCTL_DSP_SYNC:
  1327. if (file->f_mode & FMODE_WRITE)
  1328. return drain_dac(s, file->f_flags & O_NONBLOCK);
  1329. return 0;
  1331. case SNDCTL_DSP_SETDUPLEX:
  1332. return 0;
  1334. case SNDCTL_DSP_GETCAPS:
  1335. return put_user(DSP_CAP_DUPLEX, (int *)arg);
  1337. case SNDCTL_DSP_RESET:
  1338. if (file->f_mode & FMODE_WRITE) {
  1339. stop_dac(s);
  1340. synchronize_irq();
  1341. s->dma_dac.count = 0;
  1342. s->dma_dac.nextIn = s->dma_dac.nextOut = 0;
  1343. }
  1344. if (file->f_mode & FMODE_READ) {
  1345. stop_adc(s);
  1346. synchronize_irq();
  1347. s->dma_adc.count = 0;
  1348. s->dma_adc.nextIn = s->dma_adc.nextOut = 0;
  1349. }
  1350. return 0;
  1352. case SNDCTL_DSP_SPEED:
  1353. if (get_user(val, (int *)arg))
  1354. return -EFAULT;
  1355. if (val >= 0) {
  1356. if (file->f_mode & FMODE_READ) {
  1357. stop_adc(s);
  1358. set_adc_rate(s, val);
  1359. if ((ret = prog_dmabuf_adc(s)))
  1360. return ret;
  1361. }
  1362. if (file->f_mode & FMODE_WRITE) {
  1363. stop_dac(s);
  1364. set_dac_rate(s, val);
  1365. if ((ret = prog_dmabuf_dac(s)))
  1366. return ret;
  1367. }
  1368. }
  1369. return put_user((file->f_mode & FMODE_READ) ?
  1370. s->adcRate : s->dacRate, (int *)arg);
  1372. case SNDCTL_DSP_STEREO:
  1373. if (get_user(val, (int *)arg))
  1374. return -EFAULT;
  1375. if (file->f_mode & FMODE_READ) {
  1376. stop_adc(s);
  1377. if (val)
  1378. s->adcChannels = 2;
  1379. else
  1380. s->adcChannels = 1;
  1381. if ((ret = prog_dmabuf_adc(s)))
  1382. return ret;
  1383. }
  1384. if (file->f_mode & FMODE_WRITE) {
  1385. stop_dac(s);
  1386. if (val)
  1387. s->dacChannels = 2;
  1388. else
  1389. s->dacChannels = 1;
  1390. if ((ret = prog_dmabuf_dac(s)))
  1391. return ret;
  1392. }
  1393. return 0;
  1395. case SNDCTL_DSP_CHANNELS:
  1396. if (get_user(val, (int *)arg))
  1397. return -EFAULT;
  1398. if (val != 0) {
  1399. if ( (val != 1) && (val != 2)) val = 2;
  1401. if (file->f_mode & FMODE_READ) {
  1402. stop_adc(s);
  1403. s->dacChannels = val;
  1404. if ((ret = prog_dmabuf_adc(s)))
  1405. return ret;
  1406. }
  1407. if (file->f_mode & FMODE_WRITE) {
  1408. stop_dac(s);
  1409. s->dacChannels = val;
  1410. if ((ret = prog_dmabuf_dac(s)))
  1411. return ret;
  1412. }
  1413. }
  1414. return put_user(val, (int *)arg);
  1416. case SNDCTL_DSP_GETFMTS: /* Returns a mask */
  1417. return put_user(AFMT_S16_LE, (int *)arg);
  1419. case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
  1420. if (get_user(val, (int *)arg))
  1421. return -EFAULT;
  1422. if (val != AFMT_QUERY) {
  1423. if (val != AFMT_S16_LE) return -EINVAL;
  1424. if (file->f_mode & FMODE_READ) {
  1425. stop_adc(s);
  1426. if ((ret = prog_dmabuf_adc(s)))
  1427. return ret;
  1428. }
  1429. if (file->f_mode & FMODE_WRITE) {
  1430. stop_dac(s);
  1431. if ((ret = prog_dmabuf_dac(s)))
  1432. return ret;
  1433. }
  1434. } else {
  1435. val = AFMT_S16_LE;
  1436. }
  1437. return put_user(val, (int *)arg);
  1439. case SNDCTL_DSP_POST:
  1440. return 0;
  1442. case SNDCTL_DSP_GETTRIGGER:
  1443. case SNDCTL_DSP_SETTRIGGER:
  1444. /* NO trigger */
  1445. return -EINVAL;
  1447. case SNDCTL_DSP_GETOSPACE:
  1448. if (!(file->f_mode & FMODE_WRITE))
  1449. return -EINVAL;
  1450. abinfo.fragsize = s->dma_dac.fragSize << (s->dacChannels-1);
  1451. spin_lock_irqsave(&s->lock, flags);
  1452. count = s->dma_dac.count;
  1453. spin_unlock_irqrestore(&s->lock, flags);
  1454. abinfo.bytes = (s->dma_dac.fragTotalSize - count) << 
  1455. (s->dacChannels-1);
  1456. abinfo.fragstotal = s->dma_dac.numFrag;
  1457. abinfo.fragments = abinfo.bytes >> s->dma_dac.fragShift >> 
  1458. (s->dacChannels-1);      
  1459. return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  1461. case SNDCTL_DSP_GETISPACE:
  1462. if (!(file->f_mode & FMODE_READ))
  1463. return -EINVAL;
  1464. abinfo.fragsize = s->dma_adc.fragSize << (s->adcChannels-1);
  1465. spin_lock_irqsave(&s->lock, flags);
  1466. count = s->dma_adc.count;
  1467. spin_unlock_irqrestore(&s->lock, flags);
  1468. if (count < 0)
  1469. count = 0;
  1470. abinfo.bytes = count << (s->adcChannels-1);
  1471. abinfo.fragstotal = s->dma_adc.numFrag;
  1472. abinfo.fragments = (abinfo.bytes >> s->dma_adc.fragShift) >>
  1473. (s->adcChannels-1);      
  1474. return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  1476. case SNDCTL_DSP_NONBLOCK:
  1477. file->f_flags |= O_NONBLOCK;
  1478. return 0;
  1480. case SNDCTL_DSP_GETODELAY:
  1481. if (!(file->f_mode & FMODE_WRITE))
  1482. return -EINVAL;
  1483. spin_lock_irqsave(&s->lock, flags);
  1484. count = s->dma_dac.count;
  1485. spin_unlock_irqrestore(&s->lock, flags);
  1486. return put_user(count, (int *)arg);
  1488. case SNDCTL_DSP_GETIPTR:
  1489. case SNDCTL_DSP_GETOPTR:
  1490. /* we cannot get DMA ptr */
  1491. return -EINVAL;
  1493. case SNDCTL_DSP_GETBLKSIZE:
  1494. if (file->f_mode & FMODE_WRITE)
  1495. return put_user(s->dma_dac.fragSize << (s->dacChannels-1), (int *)arg);
  1496. else
  1497. return put_user(s->dma_adc.fragSize << (s->adcChannels-1), (int *)arg);
  1499. case SNDCTL_DSP_SETFRAGMENT:
  1500. /* we ignore fragment size request */
  1501. return 0;
  1503. case SNDCTL_DSP_SUBDIVIDE:
  1504. /* what is this for? [jsun] */
  1505. return 0;
  1507. case SOUND_PCM_READ_RATE:
  1508. return put_user((file->f_mode & FMODE_READ) ?
  1509. s->adcRate : s->dacRate, (int *)arg);
  1511. case SOUND_PCM_READ_CHANNELS:
  1512. if (file->f_mode & FMODE_READ)
  1513. return put_user(s->adcChannels, (int *)arg);
  1514. else
  1515. return put_user(s->dacChannels ? 2 : 1, (int *)arg);
  1516.     
  1517. case SOUND_PCM_READ_BITS:
  1518. return put_user(16, (int *)arg);
  1520. case SOUND_PCM_WRITE_FILTER:
  1521. case SNDCTL_DSP_SETSYNCRO:
  1522. case SOUND_PCM_READ_FILTER:
  1523. return -EINVAL;
  1524. }
  1526. return mixdev_ioctl(&s->codec, cmd, arg);
  1527. }
  1530. static int vrc5477_ac97_open(struct inode *inode, struct file *file)
  1531. {
  1532. int minor = MINOR(inode->i_rdev);
  1533. DECLARE_WAITQUEUE(wait, current);
  1534. unsigned long flags;
  1535. struct list_head *list;
  1536. struct vrc5477_ac97_state *s;
  1537. int ret=0;
  1538.     
  1539. for (list = devs.next; ; list = list->next) {
  1540. if (list == &devs)
  1541. return -ENODEV;
  1542. s = list_entry(list, struct vrc5477_ac97_state, devs);
  1543. if (!((s->dev_audio ^ minor) & ~0xf))
  1544. break;
  1545. }
  1546. file->private_data = s;
  1548. /* wait for device to become free */
  1549. down(&s->open_sem);
  1550. while (s->open_mode & file->f_mode) {
  1552. if (file->f_flags & O_NONBLOCK) {
  1553. up(&s->open_sem);
  1554. return -EBUSY;
  1555. }
  1556. add_wait_queue(&s->open_wait, &wait);
  1557. __set_current_state(TASK_INTERRUPTIBLE);
  1558. up(&s->open_sem);
  1559. schedule();
  1560. remove_wait_queue(&s->open_wait, &wait);
  1561. set_current_state(TASK_RUNNING);
  1562. if (signal_pending(current))
  1563. return -ERESTARTSYS;
  1564. down(&s->open_sem);
  1565. }
  1567. spin_lock_irqsave(&s->lock, flags);
  1569. if (file->f_mode & FMODE_READ) {
  1570. /* set default settings */
  1571. set_adc_rate(s, 48000);
  1572. s->adcChannels = 2;
  1574. ret = prog_dmabuf_adc(s);
  1575. if (ret) goto bailout;
  1576. }
  1577. if (file->f_mode & FMODE_WRITE) {
  1578. /* set default settings */
  1579. set_dac_rate(s, 48000);
  1580. s->dacChannels = 2;
  1582. ret = prog_dmabuf_dac(s);
  1583. if (ret) goto bailout;
  1584. }
  1586. s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
  1588.  bailout:
  1589. spin_unlock_irqrestore(&s->lock, flags);
  1591. up(&s->open_sem);
  1592. return ret;
  1593. }
  1595. static int vrc5477_ac97_release(struct inode *inode, struct file *file)
  1596. {
  1597. struct vrc5477_ac97_state *s = 
  1598. (struct vrc5477_ac97_state *)file->private_data;
  1600. lock_kernel();
  1601. if (file->f_mode & FMODE_WRITE)
  1602. drain_dac(s, file->f_flags & O_NONBLOCK);
  1603. down(&s->open_sem);
  1604. if (file->f_mode & FMODE_WRITE) {
  1605. stop_dac(s);
  1606. dealloc_dmabuf(s, &s->dma_dac);
  1607. }
  1608. if (file->f_mode & FMODE_READ) {
  1609. stop_adc(s);
  1610. dealloc_dmabuf(s, &s->dma_adc);
  1611. }
  1612. s->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
  1613. up(&s->open_sem);
  1614. wake_up(&s->open_wait);
  1615. unlock_kernel();
  1616. return 0;
  1617. }
  1619. static /*const*/ struct file_operations vrc5477_ac97_audio_fops = {
  1620. owner: THIS_MODULE,
  1621. llseek: vrc5477_ac97_llseek,
  1622. read: vrc5477_ac97_read,
  1623. write: vrc5477_ac97_write,
  1624. poll: vrc5477_ac97_poll,
  1625. ioctl: vrc5477_ac97_ioctl,
  1626. // mmap: vrc5477_ac97_mmap,
  1627. open: vrc5477_ac97_open,
  1628. release: vrc5477_ac97_release,
  1629. };
  1632. /* --------------------------------------------------------------------- */
  1635. /* --------------------------------------------------------------------- */
  1637. /*
  1638.  * for debugging purposes, we'll create a proc device that dumps the
  1639.  * CODEC chipstate
  1640.  */
  1642. #ifdef CONFIG_LL_DEBUG
  1644. struct {
  1645.        const char *regname;
  1646.        unsigned regaddr;
  1647. } vrc5477_ac97_regs[] = {
  1648. {"VRC5477_INT_STATUS", VRC5477_INT_STATUS},
  1649. {"VRC5477_CODEC_WR", VRC5477_CODEC_WR},
  1650. {"VRC5477_CODEC_RD", VRC5477_CODEC_RD},
  1651. {"VRC5477_CTRL", VRC5477_CTRL},
  1652. {"VRC5477_ACLINK_CTRL", VRC5477_ACLINK_CTRL},
  1653. {"VRC5477_INT_MASK", VRC5477_INT_MASK},
  1654. {"VRC5477_DAC1_CTRL", VRC5477_DAC1_CTRL},
  1655. {"VRC5477_DAC1L", VRC5477_DAC1L},
  1656. {"VRC5477_DAC1_BADDR", VRC5477_DAC1_BADDR},
  1657. {"VRC5477_DAC2_CTRL", VRC5477_DAC2_CTRL},
  1658. {"VRC5477_DAC2L", VRC5477_DAC2L},
  1659. {"VRC5477_DAC2_BADDR", VRC5477_DAC2_BADDR},
  1660. {"VRC5477_DAC3_CTRL", VRC5477_DAC3_CTRL},
  1661. {"VRC5477_DAC3L", VRC5477_DAC3L},
  1662. {"VRC5477_DAC3_BADDR", VRC5477_DAC3_BADDR},
  1663. {"VRC5477_ADC1_CTRL", VRC5477_ADC1_CTRL},
  1664. {"VRC5477_ADC1L", VRC5477_ADC1L},
  1665. {"VRC5477_ADC1_BADDR", VRC5477_ADC1_BADDR},
  1666. {"VRC5477_ADC2_CTRL", VRC5477_ADC2_CTRL},
  1667. {"VRC5477_ADC2L", VRC5477_ADC2L},
  1668. {"VRC5477_ADC2_BADDR", VRC5477_ADC2_BADDR},
  1669. {"VRC5477_ADC3_CTRL", VRC5477_ADC3_CTRL},
  1670. {"VRC5477_ADC3L", VRC5477_ADC3L},
  1671. {"VRC5477_ADC3_BADDR", VRC5477_ADC3_BADDR},
  1672. {NULL, 0x0}
  1673. };
  1675. static int proc_vrc5477_ac97_dump (char *buf, char **start, off_t fpos,
  1676.    int length, int *eof, void *data)
  1677. {
  1678. struct vrc5477_ac97_state *s;
  1679. int cnt, len = 0;
  1681. if (list_empty(&devs))
  1682. return 0;
  1683. s = list_entry(devs.next, struct vrc5477_ac97_state, devs);
  1685. /* print out header */
  1686. len += sprintf(buf + len, "nttVrc5477 Audio Debugnn");
  1688. // print out digital controller state
  1689. len += sprintf (buf + len, "NEC Vrc5477 Audio Controller registersn");
  1690. len += sprintf (buf + len, "---------------------------------n");
  1691. for (cnt=0; vrc5477_ac97_regs[cnt].regname != NULL; cnt++) {
  1692. len+= sprintf (buf + len, "%-20s = %08xn",
  1693.        vrc5477_ac97_regs[cnt].regname,
  1694.        inl(s->io + vrc5477_ac97_regs[cnt].regaddr));
  1695. }
  1696.    
  1697. /* print out driver state */
  1698. len += sprintf (buf + len, "NEC Vrc5477 Audio driver statesn");
  1699. len += sprintf (buf + len, "---------------------------------n");
  1700. len += sprintf (buf + len, "dacChannels  = %dn", s->dacChannels);
  1701. len += sprintf (buf + len, "adcChannels  = %dn", s->adcChannels);
  1702. len += sprintf (buf + len, "dacRate  = %dn", s->dacRate);
  1703. len += sprintf (buf + len, "adcRate  = %dn", s->adcRate);
  1705. len += sprintf (buf + len, "dma_dac is %s readyn",  
  1706.                 s->dma_dac.ready? "" : "not");
  1707.         if (s->dma_dac.ready) {
  1708. len += sprintf (buf + len, "dma_dac is %s stopped.n",  
  1709.                         s->dma_dac.stopped? "" : "not");
  1710. len += sprintf (buf + len, "dma_dac.fragSize = %xn", 
  1711.                                 s->dma_dac.fragSize);
  1712. len += sprintf (buf + len, "dma_dac.fragShift = %xn", 
  1713.                                 s->dma_dac.fragShift);
  1714. len += sprintf (buf + len, "dma_dac.numFrag = %xn", 
  1715.                                 s->dma_dac.numFrag);
  1716. len += sprintf (buf + len, "dma_dac.fragTotalSize = %xn", 
  1717.                                 s->dma_dac.fragTotalSize);
  1718. len += sprintf (buf + len, "dma_dac.nextIn = %xn", 
  1719.                                 s->dma_dac.nextIn);
  1720. len += sprintf (buf + len, "dma_dac.nextOut = %xn", 
  1721.                                 s->dma_dac.nextOut);
  1722. len += sprintf (buf + len, "dma_dac.count = %xn", 
  1723.                                 s->dma_dac.count);
  1724. }
  1726. len += sprintf (buf + len, "dma_adc is %s readyn",  
  1727.                 s->dma_adc.ready? "" : "not");
  1728.         if (s->dma_adc.ready) {
  1729. len += sprintf (buf + len, "dma_adc is %s stopped.n",  
  1730.                         s->dma_adc.stopped? "" : "not");
  1731. len += sprintf (buf + len, "dma_adc.fragSize = %xn", 
  1732.                                 s->dma_adc.fragSize);
  1733. len += sprintf (buf + len, "dma_adc.fragShift = %xn", 
  1734.                                 s->dma_adc.fragShift);
  1735. len += sprintf (buf + len, "dma_adc.numFrag = %xn", 
  1736.                                 s->dma_adc.numFrag);
  1737. len += sprintf (buf + len, "dma_adc.fragTotalSize = %xn", 
  1738.                                 s->dma_adc.fragTotalSize);
  1739. len += sprintf (buf + len, "dma_adc.nextIn = %xn", 
  1740.                                 s->dma_adc.nextIn);
  1741. len += sprintf (buf + len, "dma_adc.nextOut = %xn", 
  1742.                                 s->dma_adc.nextOut);
  1743. len += sprintf (buf + len, "dma_adc.count = %xn", 
  1744.                                 s->dma_adc.count);
  1745. }
  1746.  
  1747. /* print out CODEC state */
  1748. len += sprintf (buf + len, "nAC97 CODEC registersn");
  1749. len += sprintf (buf + len, "----------------------n");
  1750. for (cnt=0; cnt <= 0x7e; cnt = cnt +2)
  1751. len+= sprintf (buf + len, "reg %02x = %04xn",
  1752.        cnt, rdcodec(&s->codec, cnt));
  1754. if (fpos >=len){
  1755. *start = buf;
  1756. *eof =1;
  1757. return 0;
  1758. }
  1759. *start = buf + fpos;
  1760. if ((len -= fpos) > length)
  1761. return length;
  1762. *eof =1;
  1763. return len;
  1765. }
  1766. #endif /* CONFIG_LL_DEBUG */
  1768. /* --------------------------------------------------------------------- */
  1770. /* maximum number of devices; only used for command line params */
  1771. #define NR_DEVICE 5
  1773. static unsigned int devindex = 0;
  1775. MODULE_AUTHOR("Monta Vista Software, jsun@mvista.com or jsun@junsun.net");
  1776. MODULE_DESCRIPTION("NEC Vrc5477 audio (AC97) Driver");
  1777. MODULE_LICENSE("GPL");
  1779. /* --------------------------------------------------------------------- */
  1780. extern void jsun_scan_pci_bus(void);
  1781. extern void vrc5477_show_pci_regs(void);
  1782. extern void vrc5477_show_pdar_regs(void);
  1784. /* -------------------------------------------------------- */
  1785. #define         AC97_BASE               0xbb000000
  1786. #define         myinl(x)                  *(volatile u32*)(AC97_BASE + (x))
  1787. #define         myoutl(x,y)               *(volatile u32*)(AC97_BASE + (y)) = (x)
  1789. u16 myrdcodec(u8 addr)
  1790. {
  1791.         u32 result;
  1793.         /* wait until we can access codec registers */
  1794.         // while (inl(VRC5477_CODEC_WR) & 0x80000000);
  1796.         /* write the address and "read" command to codec */
  1797.         addr = addr & 0x7f;
  1798.         myoutl((addr << 16) | VRC5477_CODEC_WR_RWC, VRC5477_CODEC_WR);
  1800.         /* get the return result */
  1801.         udelay(100); /* workaround hardware bug */
  1802.         // dump_memory(0xbb000000, 48);
  1803.         while ( ((result=myinl(VRC5477_CODEC_RD)) & 0xc0000000) != 0xc0000000);
  1804.         MIPS_ASSERT(addr == ((result >> 16) & 0x7f) );
  1805.         return result & 0xffff;
  1806. }
  1808. void mywrcodec(u8 addr, u16 data)
  1809. {
  1810.         /* wait until we can access codec registers */
  1811.         while (myinl(VRC5477_CODEC_WR) & 0x80000000);
  1813.         /* write the address and value to codec */
  1814.         myoutl((addr << 16) | data, VRC5477_CODEC_WR);
  1816. }
  1819. void jsun_ac97_test(struct vrc5477_ac97_state *s)
  1820. {
  1821.         int i;
  1823.         /* reset codec */
  1824. /*
  1825.         wrcodec(&s->codec, 0, 0);
  1826.         while (inl(s->io + VRC5477_CODEC_WR) & 0x80000000);
  1827. */
  1828.         mywrcodec(0, 0);
  1829.         while (myinl(VRC5477_CODEC_WR) & 0x80000000);
  1831. for (i=0; i< 0x40; i+=4) {
  1832. MIPS_ASSERT(inl(s->io+i) == myinl(i));
  1833. }
  1835.         printk("codec registers : ");
  1836.         for (i=0; i<= 0x3a; i+=2) {
  1837.                 if ( (i%0x10) == 0) {
  1838.                         printk("n%02xt", i);
  1839.                 }
  1840.                 // printk("%04xt", rdcodec(&s->codec, i));
  1841.                 printk("%04xt", myrdcodec(i));
  1842.         }
  1843.         printk("nn");
  1844.         printk("codec registers : ");
  1845.         for (i=0; i<= 0x3a; i+=2) {
  1846.                 if ( (i%0x10) == 0) {
  1847.                         printk("n%02xt", i);
  1848.                 }
  1849.                 printk("%04xt", rdcodec(&s->codec, i));
  1850.         }
  1851.         printk("nn");
  1852. }
  1854. static int __devinit vrc5477_ac97_probe(struct pci_dev *pcidev,
  1855. const struct pci_device_id *pciid)
  1856. {
  1857. struct vrc5477_ac97_state *s;
  1858. char proc_str[80];
  1860. MIPS_DEBUG(printk("vrc5477_ac97_probe() invokedn"));
  1862. if (pcidev->irq == 0) 
  1863. return -1;
  1865. if (!(s = kmalloc(sizeof(struct vrc5477_ac97_state), GFP_KERNEL))) {
  1866. printk(KERN_ERR PFX "alloc of device struct failedn");
  1867. return -1;
  1868. }
  1869. memset(s, 0, sizeof(struct vrc5477_ac97_state));
  1871. init_waitqueue_head(&s->dma_adc.wait);
  1872. init_waitqueue_head(&s->dma_dac.wait);
  1873. init_waitqueue_head(&s->open_wait);
  1874. init_MUTEX(&s->open_sem);
  1875. spin_lock_init(&s->lock);
  1877. s->dev = pcidev;
  1878. s->io = pci_resource_start(pcidev, 0);
  1879. s->irq = pcidev->irq;
  1881. s->codec.private_data = s;
  1882. s->codec.id = 0;
  1883. s->codec.codec_read = rdcodec;
  1884. s->codec.codec_write = wrcodec;
  1885. s->codec.codec_wait = waitcodec;
  1887. /* setting some other default values such as
  1888.  * adcChannels, adcRate is done in open() so that
  1889.          * no persistent state across file opens.
  1890.  */
  1892. if (!request_region(s->io, pci_resource_len(pcidev,0),
  1893.     VRC5477_AC97_MODULE_NAME)) {
  1894. printk(KERN_ERR PFX "io ports %#lx->%#lx in usen",
  1895.        s->io, s->io + pci_resource_len(pcidev,0)-1);
  1896. goto err_region;
  1897. }
  1898. if (request_irq(s->irq, vrc5477_ac97_interrupt, SA_INTERRUPT,
  1899. VRC5477_AC97_MODULE_NAME, s)) {
  1900. printk(KERN_ERR PFX "irq %u in usen", s->irq);
  1901. goto err_irq;
  1902. }
  1904. printk(KERN_INFO PFX "IO at %#lx, IRQ %dn", s->io, s->irq);
  1906. /* register devices */
  1907. if ((s->dev_audio = register_sound_dsp(&vrc5477_ac97_audio_fops, -1)) < 0)
  1908. goto err_dev1;
  1909. if ((s->codec.dev_mixer =
  1910.      register_sound_mixer(&vrc5477_ac97_mixer_fops, -1)) < 0)
  1911. goto err_dev2;
  1913. #ifdef CONFIG_LL_DEBUG
  1914. /* intialize the debug proc device */
  1915. s->ps = create_proc_read_entry(VRC5477_AC97_MODULE_NAME, 0, NULL,
  1916.        proc_vrc5477_ac97_dump, NULL);
  1917. #endif /* CONFIG_LL_DEBUG */
  1919. /* enable pci io and bus mastering */
  1920. if (pci_enable_device(pcidev))
  1921. goto err_dev3;
  1922. pci_set_master(pcidev);
  1924. /*
  1925. jsun_scan_pci_bus();
  1926. vrc5477_show_pci_regs();
  1927. vrc5477_show_pdar_regs();
  1928. */
  1930. /* cold reset the AC97 */
  1931. outl(VRC5477_ACLINK_CTRL_RST_ON | VRC5477_ACLINK_CTRL_RST_TIME,
  1932.      s->io + VRC5477_ACLINK_CTRL);
  1933. while (inl(s->io + VRC5477_ACLINK_CTRL) & VRC5477_ACLINK_CTRL_RST_ON);
  1935. /*
  1936. jsun_ac97_test(s);
  1937. */
  1939. /* codec init */
  1940. if (!ac97_probe_codec(&s->codec))
  1941. goto err_dev3;
  1943. #ifdef CONFIG_LL_DEBUG
  1944. sprintf(proc_str, "driver/%s/%d/ac97", 
  1945. VRC5477_AC97_MODULE_NAME, s->codec.id);
  1946. s->ac97_ps = create_proc_read_entry (proc_str, 0, NULL,
  1947.      ac97_read_proc, &s->codec);
  1948. /* TODO : why this proc file does not show up? */
  1949. #endif
  1951.         /* let us get the default volumne louder */
  1952.         wrcodec(&s->codec, 0x2, 0);
  1953.         wrcodec(&s->codec, 0x18, 0x0707);
  1954. /* mute line in loopback to line out */
  1955. wrcodec(&s->codec, 0x10, 0x8000);
  1957. /* by default we select line in the input */
  1958. wrcodec(&s->codec, 0x1a, 0x0404);
  1959. /* pick middle value for record gain */
  1960. // wrcodec(&s->codec, 0x1c, 0x0707);
  1961. wrcodec(&s->codec, 0x1c, 0x0f0f);
  1962. wrcodec(&s->codec, 0x1e, 0x07);
  1964. /* enable the master interrupt but disable all others */
  1965. outl(VRC5477_INT_MASK_NMASK, s->io + VRC5477_INT_MASK);
  1967. /* store it in the driver field */
  1968. pci_set_drvdata(pcidev, s);
  1969. pcidev->dma_mask = 0xffffffff;
  1970. /* put it into driver list */
  1971. list_add_tail(&s->devs, &devs);
  1972. /* increment devindex */
  1973. if (devindex < NR_DEVICE-1)
  1974. devindex++;
  1975. return 0;
  1977.  err_dev3:
  1978. unregister_sound_mixer(s->codec.dev_mixer);
  1979.  err_dev2:
  1980. unregister_sound_dsp(s->dev_audio);
  1981.  err_dev1:
  1982. printk(KERN_ERR PFX "cannot register misc devicen");
  1983. free_irq(s->irq, s);
  1984.  err_irq:
  1985. release_region(s->io, pci_resource_len(pcidev,0));
  1986.  err_region:
  1987. kfree(s);
  1988. return -1;
  1989. }
  1991. static void __devinit vrc5477_ac97_remove(struct pci_dev *dev)
  1992. {
  1993. struct vrc5477_ac97_state *s = pci_get_drvdata(dev);
  1995. if (!s)
  1996. return;
  1997. list_del(&s->devs);
  1998. #ifdef CONFIG_LL_DEBUG
  1999. if (s->ps)
  2000. remove_proc_entry(VRC5477_AC97_MODULE_NAME, NULL);
  2001. #endif /* CONFIG_LL_DEBUG */
  2002. synchronize_irq();
  2003. free_irq(s->irq, s);
  2004. release_region(s->io, pci_resource_len(dev,0));
  2005. unregister_sound_dsp(s->dev_audio);
  2006. unregister_sound_mixer(s->codec.dev_mixer);
  2007. kfree(s);
  2008. pci_set_drvdata(dev, NULL);
  2009. }
  2012. #define PCI_VENDOR_ID_NEC 0x1033
  2013. #define PCI_DEVICE_ID_NEC_VRC5477_AC97 0x00A6
  2014. static struct pci_device_id id_table[] __devinitdata = {
  2015.     { PCI_VENDOR_ID_NEC, PCI_DEVICE_ID_NEC_VRC5477_AC97, 
  2016.       PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
  2017.     { 0, }
  2018. };
  2020. MODULE_DEVICE_TABLE(pci, id_table);
  2022. static struct pci_driver vrc5477_ac97_driver = {
  2023. name: VRC5477_AC97_MODULE_NAME,
  2024. id_table: id_table,
  2025. probe: vrc5477_ac97_probe,
  2026. remove: vrc5477_ac97_remove
  2027. };
  2029. static int __init init_vrc5477_ac97(void)
  2030. {
  2031. if (!pci_present())   /* No PCI bus in this machine! */
  2032. return -ENODEV;
  2033. printk("Vrc5477 AC97 driver: version v0.1 time " __TIME__ " " __DATE__ " by Jun Sunn");
  2034. return pci_module_init(&vrc5477_ac97_driver);
  2035. }
  2037. static void __exit cleanup_vrc5477_ac97(void)
  2038. {
  2039. printk(KERN_INFO PFX "unloadingn");
  2040. pci_unregister_driver(&vrc5477_ac97_driver);
  2041. }
  2043. module_init(init_vrc5477_ac97);
  2044. module_exit(cleanup_vrc5477_ac97);