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

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

Linux/Unix编程

开发平台：

Unix_Linux

ali5455.c：源码内容
  1. /*
  2.  * ALI  ali5455 and friends ICH driver for Linux
  3.  * LEI HU <Lei_Hu@ali.com.tw>
  4.  *
  5.  *  Built from:
  6.  * drivers/sound/i810_audio
  7.  *
  8.  *   The ALi 5455 is similar but not quite identical to the Intel ICH
  9.  * series of controllers. Its easier to keep the driver seperated from
  10.  * the i810 driver.
  11.  *
  12.  * This program is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU General Public License as published by
  14.  * the Free Software Foundation; either version 2 of the License, or
  15.  * (at your option) any later version.
  16.  *
  17.  * This program is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  * GNU General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with this program; if not, write to the Free Software
  24.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  *
  26.  *
  27.  * ALi 5455 theory of operation
  28.  *
  29.  * The chipset provides three DMA channels that talk to an AC97
  30.  * CODEC (AC97 is a digital/analog mixer standard). At its simplest
  31.  * you get 48Khz audio with basic volume and mixer controls. At the
  32.  * best you get rate adaption in the codec. We set the card up so
  33.  * that we never take completion interrupts but instead keep the card
  34.  * chasing its tail around a ring buffer. This is needed for mmap
  35.  * mode audio and happens to work rather well for non-mmap modes too.
  36.  *
  37.  * The board has one output channel for PCM audio (supported) and
  38.  * a stereo line in and mono microphone input. Again these are normally
  39.  * locked to 48Khz only. Right now recording is not finished.
  40.  *
  41.  * There is no midi support, no synth support. Use timidity. To get
  42.  * esd working you need to use esd -r 48000 as it won't probe 48KHz
  43.  * by default. mpg123 can't handle 48Khz only audio so use xmms.
  44.  *
  45.  * If you need to force a specific rate set the clocking= option
  46.  *
  47.  */
  49. #include <linux/module.h>
  50. #include <linux/version.h>
  51. #include <linux/string.h>
  52. #include <linux/ctype.h>
  53. #include <linux/ioport.h>
  54. #include <linux/sched.h>
  55. #include <linux/delay.h>
  56. #include <linux/sound.h>
  57. #include <linux/slab.h>
  58. #include <linux/soundcard.h>
  59. #include <linux/pci.h>
  60. #include <asm/io.h>
  61. #include <asm/dma.h>
  62. #include <linux/init.h>
  63. #include <linux/poll.h>
  64. #include <linux/spinlock.h>
  65. #include <linux/smp_lock.h>
  66. #include <linux/ac97_codec.h>
  67. #include <linux/wrapper.h>
  68. #include <asm/uaccess.h>
  69. #include <asm/hardirq.h>
  71. #ifndef PCI_DEVICE_ID_ALI_5455
  72. #define PCI_DEVICE_ID_ALI_5455 0x5455
  73. #endif
  75. #ifndef PCI_VENDOR_ID_ALI
  76. #define PCI_VENDOR_ID_ALI 0x10b9
  77. #endif
  79. static int strict_clocking = 0;
  80. static unsigned int clocking = 0;
  81. static unsigned int codec_pcmout_share_spdif_locked = 0;
  82. static unsigned int codec_independent_spdif_locked = 0;
  83. static unsigned int controller_pcmout_share_spdif_locked = 0;
  84. static unsigned int controller_independent_spdif_locked = 0;
  85. static unsigned int globel = 0;
  87. #define ADC_RUNNING 1
  88. #define DAC_RUNNING 2
  89. #define CODEC_SPDIFOUT_RUNNING 8
  90. #define CONTROLLER_SPDIFOUT_RUNNING 4
  92. #define SPDIF_ENABLE_OUTPUT 4 /* bits 0,1 are PCM */
  94. #define ALI5455_FMT_16BIT 1
  95. #define ALI5455_FMT_STEREO 2
  96. #define ALI5455_FMT_MASK 3
  98. #define SPDIF_ON 0x0004
  99. #define SURR_ON 0x0010
  100. #define CENTER_LFE_ON 0x0020
  101. #define VOL_MUTED 0x8000
  104. #define ALI_SPDIF_OUT_CH_STATUS 0xbf
  105. /* the 810's array of pointers to data buffers */
  107. struct sg_item {
  108. #define BUSADDR_MASK 0xFFFFFFFE
  109. u32 busaddr;
  110. #define CON_IOC  0x80000000 /* interrupt on completion */
  111. #define CON_BUFPAD 0x40000000 /* pad underrun with last sample, else 0 */
  112. #define CON_BUFLEN_MASK 0x0000ffff /* buffer length in samples */
  113. u32 control;
  114. };
  116. /* an instance of the ali channel */
  117. #define SG_LEN 32
  118. struct ali_channel {
  119. /* these sg guys should probably be allocated
  120.    seperately as nocache. Must be 8 byte aligned */
  121. struct sg_item sg[SG_LEN]; /* 32*8 */
  122. u32 offset; /* 4 */
  123. u32 port; /* 4 */
  124. u32 used;
  125. u32 num;
  126. };
  128. /*
  129.  * we have 3 seperate dma engines.  pcm in, pcm out, and mic.
  130.  * each dma engine has controlling registers.  These goofy
  131.  * names are from the datasheet, but make it easy to write
  132.  * code while leafing through it.
  133.  */
  135. #define ENUM_ENGINE(PRE,DIG) 
  136. enum {
  137. PRE##_BDBAR = 0x##DIG##0, /* Buffer Descriptor list Base Address */
  138. PRE##_CIV = 0x##DIG##4, /* Current Index Value */
  139. PRE##_LVI = 0x##DIG##5, /* Last Valid Index */
  140. PRE##_SR = 0x##DIG##6, /* Status Register */
  141. PRE##_PICB = 0x##DIG##8, /* Position In Current Buffer */
  142. PRE##_CR = 0x##DIG##b /* Control Register */
  143. }
  145. ENUM_ENGINE(OFF, 0); /* Offsets */
  146. ENUM_ENGINE(PI, 4); /* PCM In */
  147. ENUM_ENGINE(PO, 5); /* PCM Out */
  148. ENUM_ENGINE(MC, 6); /* Mic In */
  149. ENUM_ENGINE(CODECSPDIFOUT, 7); /* CODEC SPDIF OUT  */
  150. ENUM_ENGINE(CONTROLLERSPDIFIN, A); /* CONTROLLER SPDIF In */
  151. ENUM_ENGINE(CONTROLLERSPDIFOUT, B); /* CONTROLLER SPDIF OUT */
  154. enum {
  155. ALI_SCR = 0x00, /* System Control Register */
  156. ALI_SSR = 0x04, /* System Status Register  */
  157. ALI_DMACR = 0x08, /* DMA Control Register    */
  158. ALI_FIFOCR1 = 0x0c, /* FIFO Control Register 1  */
  159. ALI_INTERFACECR = 0x10, /* Interface Control Register */
  160. ALI_INTERRUPTCR = 0x14, /* Interrupt control Register */
  161. ALI_INTERRUPTSR = 0x18, /* Interrupt  Status Register */
  162. ALI_FIFOCR2 = 0x1c, /* FIFO Control Register 2   */
  163. ALI_CPR = 0x20, /* Command Port Register     */
  164. ALI_SPR = 0x24, /* Status Port Register      */
  165. ALI_FIFOCR3 = 0x2c, /* FIFO Control Register 3  */
  166. ALI_TTSR = 0x30, /* Transmit Tag Slot Register */
  167. ALI_RTSR = 0x34, /* Receive Tag Slot  Register */
  168. ALI_CSPSR = 0x38, /* Command/Status Port Status Register */
  169. ALI_CAS = 0x3c, /* Codec Write Semaphore Register */
  170. ALI_SPDIFCSR = 0xf8, /* spdif channel status register  */
  171. ALI_SPDIFICS = 0xfc /* spdif interface control/status  */
  172. };
  174. // x-status register(x:pcm in ,pcm out, mic in,)
  175. /* interrupts for a dma engine */
  176. #define DMA_INT_FIFO (1<<4) /* fifo under/over flow */
  177. #define DMA_INT_COMPLETE (1<<3) /* buffer read/write complete and ioc set */
  178. #define DMA_INT_LVI (1<<2) /* last valid done */
  179. #define DMA_INT_CELV (1<<1) /* last valid is current */
  180. #define DMA_INT_DCH (1) /* DMA Controller Halted (happens on LVI interrupts) */ //not eqult intel
  181. #define DMA_INT_MASK (DMA_INT_FIFO|DMA_INT_COMPLETE|DMA_INT_LVI)
  183. /* interrupts for the whole chip */// by interrupt status register finish
  185. #define INT_SPDIFOUT   (1<<23) /* controller spdif out INTERRUPT */
  186. #define INT_SPDIFIN   (1<<22)
  187. #define INT_CODECSPDIFOUT   (1<<19)
  188. #define INT_MICIN   (1<<18)
  189. #define INT_PCMOUT   (1<<17)
  190. #define INT_PCMIN   (1<<16)
  191. #define INT_CPRAIS   (1<<7)
  192. #define INT_SPRAIS   (1<<5)
  193. #define INT_GPIO    (1<<1)
  194. #define INT_MASK   (INT_SPDIFOUT|INT_CODECSPDIFOUT|INT_MICIN|INT_PCMOUT|INT_PCMIN)
  196. #define DRIVER_VERSION "0.02ac"
  198. /* magic numbers to protect our data structures */
  199. #define ALI5455_CARD_MAGIC 0x5072696E /* "Prin" */
  200. #define ALI5455_STATE_MAGIC 0x63657373 /* "cess" */
  201. #define ALI5455_DMA_MASK 0xffffffff /* DMA buffer mask for pci_alloc_consist */
  202. #define NR_HW_CH 5 //I think 5 channel
  204. /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
  205. #define NR_AC97 2
  207. /* Please note that an 8bit mono stream is not valid on this card, you must have a 16bit */
  208. /* stream at a minimum for this card to be happy */
  209. static const unsigned sample_size[] = { 1, 2, 2, 4 };
  210. /* Samples are 16bit values, so we are shifting to a word, not to a byte, hence shift */
  211. /* values are one less than might be expected */
  212. static const unsigned sample_shift[] = { -1, 0, 0, 1 };
  214. #define ALI5455
  215. static char *card_names[] = {
  216. "ALI 5455"
  217. };
  219. static struct pci_device_id ali_pci_tbl[] __initdata = {
  220. {PCI_VENDOR_ID_ALI, PCI_DEVICE_ID_ALI_5455,
  221.  PCI_ANY_ID, PCI_ANY_ID, 0, 0, ALI5455},
  222. {0,}
  223. };
  225. MODULE_DEVICE_TABLE(pci, ali_pci_tbl);
  227. #ifdef CONFIG_PM
  228. #define PM_SUSPENDED(card) (card->pm_suspended)
  229. #else
  230. #define PM_SUSPENDED(card) (0)
  231. #endif
  233. /* "software" or virtual channel, an instance of opened /dev/dsp */
  234. struct ali_state {
  235. unsigned int magic;
  236. struct ali_card *card; /* Card info */
  238. /* single open lock mechanism, only used for recording */
  239. struct semaphore open_sem;
  240. wait_queue_head_t open_wait;
  242. /* file mode */
  243. mode_t open_mode;
  245. /* virtual channel number */
  246. int virt;
  248. #ifdef CONFIG_PM
  249. unsigned int pm_saved_dac_rate, pm_saved_adc_rate;
  250. #endif
  251. struct dmabuf {
  252. /* wave sample stuff */
  253. unsigned int rate;
  254. unsigned char fmt, enable, trigger;
  256. /* hardware channel */
  257. struct ali_channel *read_channel;
  258. struct ali_channel *write_channel;
  259. struct ali_channel *codec_spdifout_channel;
  260. struct ali_channel *controller_spdifout_channel;
  262. /* OSS buffer management stuff */
  263. void *rawbuf;
  264. dma_addr_t dma_handle;
  265. unsigned buforder;
  266. unsigned numfrag;
  267. unsigned fragshift;
  269. /* our buffer acts like a circular ring */
  270. unsigned hwptr; /* where dma last started, updated by update_ptr */
  271. unsigned swptr; /* where driver last clear/filled, updated by read/write */
  272. int count; /* bytes to be consumed or been generated by dma machine */
  273. unsigned total_bytes; /* total bytes dmaed by hardware */
  275. unsigned error; /* number of over/underruns */
  276. wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
  278. /* redundant, but makes calculations easier */
  279. /* what the hardware uses */
  280. unsigned dmasize;
  281. unsigned fragsize;
  282. unsigned fragsamples;
  284. /* what we tell the user to expect */
  285. unsigned userfrags;
  286. unsigned userfragsize;
  288. /* OSS stuff */
  289. unsigned mapped:1;
  290. unsigned ready:1;
  291. unsigned update_flag;
  292. unsigned ossfragsize;
  293. unsigned ossmaxfrags;
  294. unsigned subdivision;
  295. } dmabuf;
  296. };
  299. struct ali_card {
  300. struct ali_channel channel[5];
  301. unsigned int magic;
  303. /* We keep ali5455 cards in a linked list */
  304. struct ali_card *next;
  306. /* The ali has a certain amount of cross channel interaction
  307.    so we use a single per card lock */
  308. spinlock_t lock;
  310. /* PCI device stuff */
  311. struct pci_dev *pci_dev;
  312. u16 pci_id;
  313. #ifdef CONFIG_PM
  314. u16 pm_suspended;
  315. u32 pm_save_state[64 / sizeof(u32)];
  316. int pm_saved_mixer_settings[SOUND_MIXER_NRDEVICES][NR_AC97];
  317. #endif
  318. /* soundcore stuff */
  319. int dev_audio;
  321. /* structures for abstraction of hardware facilities, codecs, banks and channels */
  322. struct ac97_codec *ac97_codec[NR_AC97];
  323. struct ali_state *states[NR_HW_CH];
  325. u16 ac97_features;
  326. u16 ac97_status;
  327. u16 channels;
  329. /* hardware resources */
  330. unsigned long iobase;
  332. u32 irq;
  334. /* Function support */
  335. struct ali_channel *(*alloc_pcm_channel) (struct ali_card *);
  336. struct ali_channel *(*alloc_rec_pcm_channel) (struct ali_card *);
  337. struct ali_channel *(*alloc_rec_mic_channel) (struct ali_card *);
  338. struct ali_channel *(*alloc_codec_spdifout_channel) (struct ali_card *);
  339. struct ali_channel *(*alloc_controller_spdifout_channel) (struct  ali_card *);
  340. void (*free_pcm_channel) (struct ali_card *, int chan);
  342. /* We have a *very* long init time possibly, so use this to block */
  343. /* attempts to open our devices before we are ready (stops oops'es) */
  344. int initializing;
  345. };
  348. static struct ali_card *devs = NULL;
  350. static int ali_open_mixdev(struct inode *inode, struct file *file);
  351. static int ali_ioctl_mixdev(struct inode *inode, struct file *file,
  352.     unsigned int cmd, unsigned long arg);
  353. static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg);
  354. static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
  356. static struct ali_channel *ali_alloc_pcm_channel(struct ali_card *card)
  357. {
  358. if (card->channel[1].used == 1)
  359. return NULL;
  360. card->channel[1].used = 1;
  361. return &card->channel[1];
  362. }
  364. static struct ali_channel *ali_alloc_rec_pcm_channel(struct ali_card *card)
  365. {
  366. if (card->channel[0].used == 1)
  367. return NULL;
  368. card->channel[0].used = 1;
  369. return &card->channel[0];
  370. }
  372. static struct ali_channel *ali_alloc_rec_mic_channel(struct ali_card *card)
  373. {
  374. if (card->channel[2].used == 1)
  375. return NULL;
  376. card->channel[2].used = 1;
  377. return &card->channel[2];
  378. }
  380. static struct ali_channel *ali_alloc_codec_spdifout_channel(struct ali_card *card)
  381. {
  382. if (card->channel[3].used == 1)
  383. return NULL;
  384. card->channel[3].used = 1;
  385. return &card->channel[3];
  386. }
  388. static struct ali_channel *ali_alloc_controller_spdifout_channel(struct ali_card *card)
  389. {
  390. if (card->channel[4].used == 1)
  391. return NULL;
  392. card->channel[4].used = 1;
  393. return &card->channel[4];
  394. }
  395. static void ali_free_pcm_channel(struct ali_card *card, int channel)
  396. {
  397. card->channel[channel].used = 0;
  398. }
  401. //add support  codec spdif out 
  402. static int ali_valid_spdif_rate(struct ac97_codec *codec, int rate)
  403. {
  404. unsigned long id = 0L;
  406. id = (ali_ac97_get(codec, AC97_VENDOR_ID1) << 16);
  407. id |= ali_ac97_get(codec, AC97_VENDOR_ID2) & 0xffff;
  408. switch (id) {
  409. case 0x41445361: /* AD1886 */
  410. if (rate == 48000) {
  411. return 1;
  412. }
  413. break;
  414. case 0x414c4720: /* ALC650 */
  415. if (rate == 48000) {
  416. return 1;
  417. }
  418. break;
  419. default: /* all other codecs, until we know otherwiae */
  420. if (rate == 48000 || rate == 44100 || rate == 32000) {
  421. return 1;
  422. }
  423. break;
  424. }
  425. return (0);
  426. }
  428. /* ali_set_spdif_output
  429.  * 
  430.  *  Configure the S/PDIF output transmitter. When we turn on
  431.  *  S/PDIF, we turn off the analog output. This may not be
  432.  *  the right thing to do.
  433.  *
  434.  *  Assumptions:
  435.  *     The DSP sample rate must already be set to a supported
  436.  *     S/PDIF rate (32kHz, 44.1kHz, or 48kHz) or we abort.
  437.  */
  438. static void ali_set_spdif_output(struct ali_state *state, int slots,
  439.  int rate)
  440. {
  441. int vol;
  442. int aud_reg;
  443. struct ac97_codec *codec = state->card->ac97_codec[0];
  445. if (!(state->card->ac97_features & 4)) {
  446. state->card->ac97_status &= ~SPDIF_ON;
  447. } else {
  448. if (slots == -1) { /* Turn off S/PDIF */
  449. aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
  450. ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
  452. /* If the volume wasn't muted before we turned on S/PDIF, unmute it */
  453. if (!(state->card->ac97_status & VOL_MUTED)) {
  454. aud_reg = ali_ac97_get(codec, AC97_MASTER_VOL_STEREO);
  455. ali_ac97_set(codec, AC97_MASTER_VOL_STEREO,
  456.      (aud_reg & ~VOL_MUTED));
  457. }
  458. state->card->ac97_status &= ~(VOL_MUTED | SPDIF_ON);
  459. return;
  460. }
  462. vol = ali_ac97_get(codec, AC97_MASTER_VOL_STEREO);
  463. state->card->ac97_status = vol & VOL_MUTED;
  465. /* Set S/PDIF transmitter sample rate */
  466. aud_reg = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
  467. switch (rate) {
  468. case 32000:
  469. aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_32K;
  470. break;
  471. case 44100:
  472. aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_44K;
  473. break;
  474. case 48000:
  475. aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_48K;
  476. break;
  477. default:
  478. /* turn off S/PDIF */
  479. aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
  480. ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
  481. state->card->ac97_status &= ~SPDIF_ON;
  482. return;
  483. }
  485. ali_ac97_set(codec, AC97_SPDIF_CONTROL, aud_reg);
  487. aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
  488. aud_reg = (aud_reg & AC97_EA_SLOT_MASK) | slots | AC97_EA_SPDIF;
  489. ali_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
  491. aud_reg = ali_ac97_get(codec, AC97_POWER_CONTROL);
  492. aud_reg |= 0x0002;
  493. ali_ac97_set(codec, AC97_POWER_CONTROL, aud_reg);
  494. udelay(1);
  496. state->card->ac97_status |= SPDIF_ON;
  498. /* Check to make sure the configuration is valid */
  499. aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
  500. if (!(aud_reg & 0x0400)) {
  501. /* turn off S/PDIF */
  502. ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
  503. state->card->ac97_status &= ~SPDIF_ON;
  504. return;
  505. }
  506. if (codec_independent_spdif_locked > 0) {
  507. aud_reg = ali_ac97_get(codec, 0x6a);
  508. ali_ac97_set(codec, 0x6a, (aud_reg & 0xefff));
  509. }
  510. /* Mute the analog output */
  511. /* Should this only mute the PCM volume??? */
  512. }
  513. }
  515. /* ali_set_dac_channels
  516.  *
  517.  *  Configure the codec's multi-channel DACs
  518.  *
  519.  *  The logic is backwards. Setting the bit to 1 turns off the DAC. 
  520.  *
  521.  *  What about the ICH? We currently configure it using the
  522.  *  SNDCTL_DSP_CHANNELS ioctl.  If we're turnning on the DAC, 
  523.  *  does that imply that we want the ICH set to support
  524.  *  these channels?
  525.  *  
  526.  *  TODO:
  527.  *    vailidate that the codec really supports these DACs
  528.  *    before turning them on. 
  529.  */
  530. static void ali_set_dac_channels(struct ali_state *state, int channel)
  531. {
  532. int aud_reg;
  533. struct ac97_codec *codec = state->card->ac97_codec[0];
  535. aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
  536. aud_reg |= AC97_EA_PRI | AC97_EA_PRJ | AC97_EA_PRK;
  537. state->card->ac97_status &= ~(SURR_ON | CENTER_LFE_ON);
  539. switch (channel) {
  540. case 2: /* always enabled */
  541. break;
  542. case 4:
  543. aud_reg &= ~AC97_EA_PRJ;
  544. state->card->ac97_status |= SURR_ON;
  545. break;
  546. case 6:
  547. aud_reg &= ~(AC97_EA_PRJ | AC97_EA_PRI | AC97_EA_PRK);
  548. state->card->ac97_status |= SURR_ON | CENTER_LFE_ON;
  549. break;
  550. default:
  551. break;
  552. }
  553. ali_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
  555. }
  557. /* set playback sample rate */
  558. static unsigned int ali_set_dac_rate(struct ali_state *state,
  559.      unsigned int rate)
  560. {
  561. struct dmabuf *dmabuf = &state->dmabuf;
  562. u32 new_rate;
  563. struct ac97_codec *codec = state->card->ac97_codec[0];
  565. if (!(state->card->ac97_features & 0x0001)) {
  566. dmabuf->rate = clocking;
  567. return clocking;
  568. }
  570. if (rate > 48000)
  571. rate = 48000;
  572. if (rate < 8000)
  573. rate = 8000;
  574. dmabuf->rate = rate;
  576. /*
  577.  *      Adjust for misclocked crap
  578.  */
  580. rate = (rate * clocking) / 48000;
  582. if (strict_clocking && rate < 8000) {
  583. rate = 8000;
  584. dmabuf->rate = (rate * 48000) / clocking;
  585. }
  587. new_rate = ac97_set_dac_rate(codec, rate);
  588. if (new_rate != rate) {
  589. dmabuf->rate = (new_rate * 48000) / clocking;
  590. }
  591. rate = new_rate;
  592. return dmabuf->rate;
  593. }
  595. /* set recording sample rate */
  596. static unsigned int ali_set_adc_rate(struct ali_state *state,
  597.      unsigned int rate)
  598. {
  599. struct dmabuf *dmabuf = &state->dmabuf;
  600. u32 new_rate;
  601. struct ac97_codec *codec = state->card->ac97_codec[0];
  603. if (!(state->card->ac97_features & 0x0001)) {
  604. dmabuf->rate = clocking;
  605. return clocking;
  606. }
  608. if (rate > 48000)
  609. rate = 48000;
  610. if (rate < 8000)
  611. rate = 8000;
  612. dmabuf->rate = rate;
  614. /*
  615.  *      Adjust for misclocked crap
  616.  */
  618. rate = (rate * clocking) / 48000;
  619. if (strict_clocking && rate < 8000) {
  620. rate = 8000;
  621. dmabuf->rate = (rate * 48000) / clocking;
  622. }
  624. new_rate = ac97_set_adc_rate(codec, rate);
  626. if (new_rate != rate) {
  627. dmabuf->rate = (new_rate * 48000) / clocking;
  628. rate = new_rate;
  629. }
  630. return dmabuf->rate;
  631. }
  633. /* set codec independent spdifout sample rate */
  634. static unsigned int ali_set_codecspdifout_rate(struct ali_state *state,
  635.        unsigned int rate)
  636. {
  637. struct dmabuf *dmabuf = &state->dmabuf;
  639. if (!(state->card->ac97_features & 0x0001)) {
  640. dmabuf->rate = clocking;
  641. return clocking;
  642. }
  644. if (rate > 48000)
  645. rate = 48000;
  646. if (rate < 8000)
  647. rate = 8000;
  648. dmabuf->rate = rate;
  650. return dmabuf->rate;
  651. }
  653. /* set  controller independent spdif out function sample rate */
  654. static void ali_set_spdifout_rate(struct ali_state *state,
  655.   unsigned int rate)
  656. {
  657. unsigned char ch_st_sel;
  658. unsigned short status_rate;
  660. switch (rate) {
  661. case 44100:
  662. status_rate = 0;
  663. break;
  664. case 32000:
  665. status_rate = 0x300;
  666. break;
  667. case 48000:
  668. default:
  669. status_rate = 0x200;
  670. break;
  671. }
  673. ch_st_sel = inb(state->card->iobase + ALI_SPDIFICS) & ALI_SPDIF_OUT_CH_STATUS; //select spdif_out
  675. ch_st_sel |= 0x80; //select right
  676. outb(ch_st_sel, (state->card->iobase + ALI_SPDIFICS));
  677. outb(status_rate | 0x20, (state->card->iobase + ALI_SPDIFCSR + 2));
  679. ch_st_sel &= (~0x80); //select left
  680. outb(ch_st_sel, (state->card->iobase + ALI_SPDIFICS));
  681. outw(status_rate | 0x10, (state->card->iobase + ALI_SPDIFCSR + 2));
  682. }
  684. /* get current playback/recording dma buffer pointer (byte offset from LBA),
  685.    called with spinlock held! */
  687. static inline unsigned ali_get_dma_addr(struct ali_state *state, int rec)
  688. {
  689. struct dmabuf *dmabuf = &state->dmabuf;
  690. unsigned int civ, offset, port, port_picb;
  691. unsigned int data;
  693. if (!dmabuf->enable)
  694. return 0;
  696. if (rec == 1)
  697. port = state->card->iobase + dmabuf->read_channel->port;
  698. else if (rec == 2)
  699. port = state->card->iobase + dmabuf->codec_spdifout_channel->port;
  700. else if (rec == 3)
  701. port = state->card->iobase + dmabuf->controller_spdifout_channel->port;
  702. else
  703. port = state->card->iobase + dmabuf->write_channel->port;
  705. port_picb = port + OFF_PICB;
  707. do {
  708. civ = inb(port + OFF_CIV) & 31;
  709. offset = inw(port_picb);
  710. /* Must have a delay here! */
  711. if (offset == 0)
  712. udelay(1);
  714. /* Reread both registers and make sure that that total
  715.  * offset from the first reading to the second is 0.
  716.  * There is an issue with SiS hardware where it will count
  717.  * picb down to 0, then update civ to the next value,
  718.  * then set the new picb to fragsize bytes.  We can catch
  719.  * it between the civ update and the picb update, making
  720.  * it look as though we are 1 fragsize ahead of where we
  721.  * are.  The next to we get the address though, it will
  722.  * be back in thdelay is more than long enough
  723.  * that we won't have to worry about the chip still being
  724.  * out of sync with reality ;-)
  725.  */
  726. } while (civ != (inb(port + OFF_CIV) & 31) || offset != inw(port_picb));
  728. data = ((civ + 1) * dmabuf->fragsize - (2 * offset)) % dmabuf->dmasize;
  729. if (inw(port_picb) == 0)
  730. data -= 2048;
  732. return data;
  733. }
  735. /* Stop recording (lock held) */
  736. static inline void __stop_adc(struct ali_state *state)
  737. {
  738. struct dmabuf *dmabuf = &state->dmabuf;
  739. struct ali_card *card = state->card;
  741. dmabuf->enable &= ~ADC_RUNNING;
  743. outl((1 << 18) | (1 << 16), card->iobase + ALI_DMACR);
  744. udelay(1);
  746. outb(0, card->iobase + PI_CR);
  747. while (inb(card->iobase + PI_CR) != 0);
  749. // now clear any latent interrupt bits (like the halt bit)
  750. outb(inb(card->iobase + PI_SR) | 0x001e, card->iobase + PI_SR);
  751. outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_PCMIN, card->iobase + ALI_INTERRUPTSR);
  752. }
  754. static void stop_adc(struct ali_state *state)
  755. {
  756. struct ali_card *card = state->card;
  757. unsigned long flags;
  758. spin_lock_irqsave(&card->lock, flags);
  759. __stop_adc(state);
  760. spin_unlock_irqrestore(&card->lock, flags);
  761. }
  763. static inline void __start_adc(struct ali_state *state)
  764. {
  765. struct dmabuf *dmabuf = &state->dmabuf;
  767. if (dmabuf->count < dmabuf->dmasize && dmabuf->ready
  768.     && !dmabuf->enable && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
  769. dmabuf->enable |= ADC_RUNNING;
  770. outb((1 << 4) | (1 << 2), state->card->iobase + PI_CR);
  771. if (state->card->channel[0].used == 1)
  772. outl(1, state->card->iobase + ALI_DMACR); // DMA CONTROL REGISTRER
  773. udelay(100);
  774. if (state->card->channel[2].used == 1)
  775. outl((1 << 2), state->card->iobase + ALI_DMACR); //DMA CONTROL REGISTER
  776. udelay(100);
  777. }
  778. }
  780. static void start_adc(struct ali_state *state)
  781. {
  782. struct ali_card *card = state->card;
  783. unsigned long flags;
  785. spin_lock_irqsave(&card->lock, flags);
  786. __start_adc(state);
  787. spin_unlock_irqrestore(&card->lock, flags);
  788. }
  790. /* stop playback (lock held) */
  791. static inline void __stop_dac(struct ali_state *state)
  792. {
  793. struct dmabuf *dmabuf = &state->dmabuf;
  794. struct ali_card *card = state->card;
  796. dmabuf->enable &= ~DAC_RUNNING;
  797. outl(0x00020000, card->iobase + 0x08);
  798. outb(0, card->iobase + PO_CR);
  799. while (inb(card->iobase + PO_CR) != 0)
  800. cpu_relax();
  802. outb(inb(card->iobase + PO_SR) | 0x001e, card->iobase + PO_SR);
  804. outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_PCMOUT, card->iobase + ALI_INTERRUPTSR);
  805. }
  807. static void stop_dac(struct ali_state *state)
  808. {
  809. struct ali_card *card = state->card;
  810. unsigned long flags;
  811. spin_lock_irqsave(&card->lock, flags);
  812. __stop_dac(state);
  813. spin_unlock_irqrestore(&card->lock, flags);
  814. }
  816. static inline void __start_dac(struct ali_state *state)
  817. {
  818. struct dmabuf *dmabuf = &state->dmabuf;
  819. if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
  820.     (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
  821. dmabuf->enable |= DAC_RUNNING;
  822. outb((1 << 4) | (1 << 2), state->card->iobase + PO_CR);
  823. outl((1 << 1), state->card->iobase + 0x08); //dma control register
  824. }
  825. }
  827. static void start_dac(struct ali_state *state)
  828. {
  829. struct ali_card *card = state->card;
  830. unsigned long flags;
  831. spin_lock_irqsave(&card->lock, flags);
  832. __start_dac(state);
  833. spin_unlock_irqrestore(&card->lock, flags);
  834. }
  836. /* stop codec and controller spdif out  (lock held) */
  837. static inline void __stop_spdifout(struct ali_state *state)
  838. {
  839. struct dmabuf *dmabuf = &state->dmabuf;
  840. struct ali_card *card = state->card;
  842. if (codec_independent_spdif_locked > 0) {
  843. dmabuf->enable &= ~CODEC_SPDIFOUT_RUNNING;
  844. outl((1 << 19), card->iobase + 0x08);
  845. outb(0, card->iobase + CODECSPDIFOUT_CR);
  847. while (inb(card->iobase + CODECSPDIFOUT_CR) != 0)
  848. cpu_relax();
  850. outb(inb(card->iobase + CODECSPDIFOUT_SR) | 0x001e, card->iobase + CODECSPDIFOUT_SR);
  851. outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_CODECSPDIFOUT, card->iobase + ALI_INTERRUPTSR);
  852. } else {
  853. if (controller_independent_spdif_locked > 0) {
  854. dmabuf->enable &= ~CONTROLLER_SPDIFOUT_RUNNING;
  855. outl((1 << 23), card->iobase + 0x08);
  856. outb(0, card->iobase + CONTROLLERSPDIFOUT_CR);
  857. while (inb(card->iobase + CONTROLLERSPDIFOUT_CR) != 0)
  858. cpu_relax();
  859. outb(inb(card->iobase + CONTROLLERSPDIFOUT_SR) | 0x001e, card->iobase + CONTROLLERSPDIFOUT_SR);
  860. outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_SPDIFOUT, card->iobase + ALI_INTERRUPTSR);
  861. }
  862. }
  863. }
  865. static void stop_spdifout(struct ali_state *state)
  866. {
  867. struct ali_card *card = state->card;
  868. unsigned long flags;
  869. spin_lock_irqsave(&card->lock, flags);
  870. __stop_spdifout(state);
  871. spin_unlock_irqrestore(&card->lock, flags);
  872. }
  874. static inline void __start_spdifout(struct ali_state *state)
  875. {
  876. struct dmabuf *dmabuf = &state->dmabuf;
  877. if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
  878.     (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
  879. if (codec_independent_spdif_locked > 0) {
  880. dmabuf->enable |= CODEC_SPDIFOUT_RUNNING;
  881. outb((1 << 4) | (1 << 2), state->card->iobase + CODECSPDIFOUT_CR);
  882. outl((1 << 3), state->card->iobase + 0x08); //dma control register
  883. } else {
  884. if (controller_independent_spdif_locked > 0) {
  885. dmabuf->enable |= CONTROLLER_SPDIFOUT_RUNNING;
  886. outb((1 << 4) | (1 << 2), state->card->iobase + CONTROLLERSPDIFOUT_CR);
  887. outl((1 << 7), state->card->iobase + 0x08); //dma control register
  888. }
  889. }
  890. }
  891. }
  893. static void start_spdifout(struct ali_state *state)
  894. {
  895. struct ali_card *card = state->card;
  896. unsigned long flags;
  897. spin_lock_irqsave(&card->lock, flags);
  898. __start_spdifout(state);
  899. spin_unlock_irqrestore(&card->lock, flags);
  900. }
  902. #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
  903. #define DMABUF_MINORDER 1
  905. /* allocate DMA buffer, playback , recording,spdif out  buffer should be allocated seperately */
  906. static int alloc_dmabuf(struct ali_state *state)
  907. {
  908. struct dmabuf *dmabuf = &state->dmabuf;
  909. void *rawbuf = NULL;
  910. int order, size;
  911. struct page *page, *pend;
  913. /* If we don't have any oss frag params, then use our default ones */
  914. if (dmabuf->ossmaxfrags == 0)
  915. dmabuf->ossmaxfrags = 4;
  916. if (dmabuf->ossfragsize == 0)
  917. dmabuf->ossfragsize = (PAGE_SIZE << DMABUF_DEFAULTORDER) / dmabuf->ossmaxfrags;
  918. size = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
  920. if (dmabuf->rawbuf && (PAGE_SIZE << dmabuf->buforder) == size)
  921. return 0;
  922. /* alloc enough to satisfy the oss params */
  923. for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
  924. if ((PAGE_SIZE << order) > size)
  925. continue;
  926. if ((rawbuf = pci_alloc_consistent(state->card->pci_dev,
  927.    PAGE_SIZE << order,
  928.    &dmabuf->dma_handle)))
  929. break;
  930. }
  931. if (!rawbuf)
  932. return -ENOMEM;
  934. dmabuf->ready = dmabuf->mapped = 0;
  935. dmabuf->rawbuf = rawbuf;
  936. dmabuf->buforder = order;
  938. /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
  939. pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
  940. for (page = virt_to_page(rawbuf); page <= pend; page++)
  941. mem_map_reserve(page);
  942. return 0;
  943. }
  945. /* free DMA buffer */
  946. static void dealloc_dmabuf(struct ali_state *state)
  947. {
  948. struct dmabuf *dmabuf = &state->dmabuf;
  949. struct page *page, *pend;
  951. if (dmabuf->rawbuf) {
  952. /* undo marking the pages as reserved */
  953. pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
  954. for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
  955. mem_map_unreserve(page);
  956. pci_free_consistent(state->card->pci_dev,
  957.     PAGE_SIZE << dmabuf->buforder,
  958.     dmabuf->rawbuf, dmabuf->dma_handle);
  959. }
  960. dmabuf->rawbuf = NULL;
  961. dmabuf->mapped = dmabuf->ready = 0;
  962. }
  964. static int prog_dmabuf(struct ali_state *state, unsigned rec)
  965. {
  966. struct dmabuf *dmabuf = &state->dmabuf;
  967. struct ali_channel *c = NULL;
  968. struct sg_item *sg;
  969. unsigned long flags;
  970. int ret;
  971. unsigned fragint;
  972. int i;
  974. spin_lock_irqsave(&state->card->lock, flags);
  975. if (dmabuf->enable & DAC_RUNNING)
  976. __stop_dac(state);
  977. if (dmabuf->enable & ADC_RUNNING)
  978. __stop_adc(state);
  979. if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
  980. __stop_spdifout(state);
  981. if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
  982. __stop_spdifout(state);
  984. dmabuf->total_bytes = 0;
  985. dmabuf->count = dmabuf->error = 0;
  986. dmabuf->swptr = dmabuf->hwptr = 0;
  987. spin_unlock_irqrestore(&state->card->lock, flags);
  989. /* allocate DMA buffer, let alloc_dmabuf determine if we are already
  990.  * allocated well enough or if we should replace the current buffer
  991.  * (assuming one is already allocated, if it isn't, then allocate it).
  992.  */
  993. if ((ret = alloc_dmabuf(state)))
  994. return ret;
  996. /* FIXME: figure out all this OSS fragment stuff */
  997. /* I did, it now does what it should according to the OSS API.  DL */
  998. /* We may not have realloced our dmabuf, but the fragment size to
  999.  * fragment number ratio may have changed, so go ahead and reprogram
  1000.  * things
  1001.  */
  1003. dmabuf->dmasize = PAGE_SIZE << dmabuf->buforder;
  1004. dmabuf->numfrag = SG_LEN;
  1005. dmabuf->fragsize = dmabuf->dmasize / dmabuf->numfrag;
  1006. dmabuf->fragsamples = dmabuf->fragsize >> 1;
  1007. dmabuf->userfragsize = dmabuf->ossfragsize;
  1008. dmabuf->userfrags = dmabuf->dmasize / dmabuf->ossfragsize;
  1010. memset(dmabuf->rawbuf, 0, dmabuf->dmasize);
  1012. if (dmabuf->ossmaxfrags == 4) {
  1013. fragint = 8;
  1014. dmabuf->fragshift = 2;
  1015. } else if (dmabuf->ossmaxfrags == 8) {
  1016. fragint = 4;
  1017. dmabuf->fragshift = 3;
  1018. } else if (dmabuf->ossmaxfrags == 16) {
  1019. fragint = 2;
  1020. dmabuf->fragshift = 4;
  1021. } else {
  1022. fragint = 1;
  1023. dmabuf->fragshift = 5;
  1024. }
  1025. /*
  1026.  *      Now set up the ring 
  1027.  */
  1029. if (rec == 1)
  1030. c = dmabuf->read_channel;
  1031. else if (rec == 2)
  1032. c = dmabuf->codec_spdifout_channel;
  1033. else if (rec == 3)
  1034. c = dmabuf->controller_spdifout_channel;
  1035. else if (rec == 0)
  1036. c = dmabuf->write_channel;
  1037. if (c != NULL) {
  1038. sg = &c->sg[0];
  1039. /*
  1040.  *      Load up 32 sg entries and take an interrupt at half
  1041.  *      way (we might want more interrupts later..) 
  1042.  */
  1043. for (i = 0; i < dmabuf->numfrag; i++) {
  1044. sg->busaddr =
  1045.     virt_to_bus(dmabuf->rawbuf +
  1046. dmabuf->fragsize * i);
  1047. // the card will always be doing 16bit stereo
  1048. sg->control = dmabuf->fragsamples;
  1049. sg->control |= CON_BUFPAD; //I modify
  1050. // set us up to get IOC interrupts as often as needed to
  1051. // satisfy numfrag requirements, no more
  1052. if (((i + 1) % fragint) == 0) {
  1053. sg->control |= CON_IOC;
  1054. }
  1055. sg++;
  1056. }
  1057. spin_lock_irqsave(&state->card->lock, flags);
  1058. outb(2, state->card->iobase + c->port + OFF_CR); /* reset DMA machine */
  1059. outl(virt_to_bus(&c->sg[0]), state->card->iobase + c->port + OFF_BDBAR);
  1060. outb(0, state->card->iobase + c->port + OFF_CIV);
  1061. outb(0, state->card->iobase + c->port + OFF_LVI);
  1062. spin_unlock_irqrestore(&state->card->lock, flags);
  1063. }
  1064. /* set the ready flag for the dma buffer */
  1065. dmabuf->ready = 1;
  1066. return 0;
  1067. }
  1069. static void __ali_update_lvi(struct ali_state *state, int rec)
  1070. {
  1071. struct dmabuf *dmabuf = &state->dmabuf;
  1072. int x, port;
  1073. port = state->card->iobase;
  1074. if (rec == 1)
  1075. port += dmabuf->read_channel->port;
  1076. else if (rec == 2)
  1077. port += dmabuf->codec_spdifout_channel->port;
  1078. else if (rec == 3)
  1079. port += dmabuf->controller_spdifout_channel->port;
  1080. else if (rec == 0)
  1081. port += dmabuf->write_channel->port;
  1082. /* if we are currently stopped, then our CIV is actually set to our
  1083.  * *last* sg segment and we are ready to wrap to the next.  However,
  1084.  * if we set our LVI to the last sg segment, then it won't wrap to
  1085.  * the next sg segment, it won't even get a start.  So, instead, when
  1086.  * we are stopped, we set both the LVI value and also we increment
  1087.  * the CIV value to the next sg segment to be played so that when
  1088.  * we call start_{dac,adc}, things will operate properly
  1089.  */
  1090. if (!dmabuf->enable && dmabuf->ready) {
  1091. if (rec && dmabuf->count < dmabuf->dmasize && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
  1092. outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
  1093. __start_adc(state);
  1094. while (! (inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
  1095. cpu_relax();
  1096. } else if (!rec && dmabuf->count && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
  1097. outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
  1098. __start_dac(state);
  1099. while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
  1100. cpu_relax();
  1101. } else if (rec && dmabuf->count && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
  1102. if (codec_independent_spdif_locked > 0) {
  1103. // outb((inb(port+OFF_CIV))&31, port+OFF_LVI);
  1104. outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
  1105. __start_spdifout(state);
  1106. while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
  1107. cpu_relax();
  1108. } else {
  1109. if (controller_independent_spdif_locked > 0) {
  1110. outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
  1111. __start_spdifout(state);
  1112. while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
  1113. cpu_relax();
  1114. }
  1115. }
  1116. }
  1117. }
  1119. /* swptr - 1 is the tail of our transfer */
  1120. x = (dmabuf->dmasize + dmabuf->swptr - 1) % dmabuf->dmasize;
  1121. x /= dmabuf->fragsize;
  1122. outb(x, port + OFF_LVI);
  1123. }
  1125. static void ali_update_lvi(struct ali_state *state, int rec)
  1126. {
  1127. struct dmabuf *dmabuf = &state->dmabuf;
  1128. unsigned long flags;
  1129. if (!dmabuf->ready)
  1130. return;
  1131. spin_lock_irqsave(&state->card->lock, flags);
  1132. __ali_update_lvi(state, rec);
  1133. spin_unlock_irqrestore(&state->card->lock, flags);
  1134. }
  1136. /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
  1137. static void ali_update_ptr(struct ali_state *state)
  1138. {
  1139. struct dmabuf *dmabuf = &state->dmabuf;
  1140. unsigned hwptr;
  1141. int diff;
  1143. /* error handling and process wake up for DAC */
  1144. if (dmabuf->enable == ADC_RUNNING) {
  1145. /* update hardware pointer */
  1146. hwptr = ali_get_dma_addr(state, 1);
  1147. diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
  1148. dmabuf->hwptr = hwptr;
  1149. dmabuf->total_bytes += diff;
  1150. dmabuf->count += diff;
  1151. if (dmabuf->count > dmabuf->dmasize) {
  1152. /* buffer underrun or buffer overrun */
  1153. /* this is normal for the end of a read */
  1154. /* only give an error if we went past the */
  1155. /* last valid sg entry */
  1156. if ((inb(state->card->iobase + PI_CIV) & 31) != (inb(state->card->iobase + PI_LVI) & 31)) {
  1157. printk(KERN_WARNING "ali_audio: DMA overrun on readn");
  1158. dmabuf->error++;
  1159. }
  1160. }
  1161. if (dmabuf->count > dmabuf->userfragsize)
  1162. wake_up(&dmabuf->wait);
  1163. }
  1164. /* error handling and process wake up for DAC */
  1165. if (dmabuf->enable == DAC_RUNNING) {
  1166. /* update hardware pointer */
  1167. hwptr = ali_get_dma_addr(state, 0);
  1168. diff =
  1169.     (dmabuf->dmasize + hwptr -
  1170.      dmabuf->hwptr) % dmabuf->dmasize;
  1171. #if defined(DEBUG_INTERRUPTS) || defined(DEBUG_MMAP)
  1172. printk("DAC HWP %d,%d,%dn", hwptr, dmabuf->hwptr, diff);
  1173. #endif
  1174. dmabuf->hwptr = hwptr;
  1175. dmabuf->total_bytes += diff;
  1176. dmabuf->count -= diff;
  1177. if (dmabuf->count < 0) {
  1178. /* buffer underrun or buffer overrun */
  1179. /* this is normal for the end of a write */
  1180. /* only give an error if we went past the */
  1181. /* last valid sg entry */
  1182. if ((inb(state->card->iobase + PO_CIV) & 31) != (inb(state->card->iobase + PO_LVI) & 31)) {
  1183. printk(KERN_WARNING "ali_audio: DMA overrun on writen");
  1184. printk(KERN_DEBUG "ali_audio: CIV %d, LVI %d, hwptr %x, count %dn",
  1185.       inb(state->card->iobase + PO_CIV) & 31,
  1186.       inb(state->card->iobase + PO_LVI) & 31, 
  1187. dmabuf->hwptr,
  1188. dmabuf->count);
  1189. dmabuf->error++;
  1190. }
  1191. }
  1192. if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
  1193.      wake_up(&dmabuf->wait);
  1194. }
  1196. /* error handling and process wake up for CODEC SPDIF OUT */
  1197. if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
  1198. /* update hardware pointer */
  1199. hwptr = ali_get_dma_addr(state, 2);
  1200. diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
  1201. dmabuf->hwptr = hwptr;
  1202. dmabuf->total_bytes += diff;
  1203. dmabuf->count -= diff;
  1204. if (dmabuf->count < 0) {
  1205. /* buffer underrun or buffer overrun */
  1206. /* this is normal for the end of a write */
  1207. /* only give an error if we went past the */
  1208. /* last valid sg entry */
  1209. if ((inb(state->card->iobase + CODECSPDIFOUT_CIV) & 31) != (inb(state->card->iobase + CODECSPDIFOUT_LVI) & 31)) {
  1210. printk(KERN_WARNING "ali_audio: DMA overrun on writen");
  1211. printk(KERN_DEBUG "ali_audio: CIV %d, LVI %d, hwptr %x, count %dn", 
  1212.         inb(state->card->iobase + CODECSPDIFOUT_CIV) & 31,
  1213. inb(state->card->iobase + CODECSPDIFOUT_LVI) & 31,
  1214. dmabuf->hwptr, dmabuf->count);
  1215. dmabuf->error++;
  1216. }
  1217. }
  1218. if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
  1219. wake_up(&dmabuf->wait);
  1220. }
  1221. /* error handling and process wake up for CONTROLLER SPDIF OUT */
  1222. if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
  1223. /* update hardware pointer */
  1224. hwptr = ali_get_dma_addr(state, 3);
  1225. diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
  1226. dmabuf->hwptr = hwptr;
  1227. dmabuf->total_bytes += diff;
  1228. dmabuf->count -= diff;
  1229. if (dmabuf->count < 0) {
  1230. /* buffer underrun or buffer overrun */
  1231. /* this is normal for the end of a write */
  1232. /* only give an error if we went past the */
  1233. /* last valid sg entry */
  1234. if ((inb(state->card->iobase + CONTROLLERSPDIFOUT_CIV) & 31) != (inb(state->card->iobase + CONTROLLERSPDIFOUT_LVI) & 31)) {
  1235. printk(KERN_WARNING
  1236.        "ali_audio: DMA overrun on writen");
  1237. printk("ali_audio: CIV %d, LVI %d, hwptr %x, "
  1238. "count %dn",
  1239.       inb(state->card->iobase + CONTROLLERSPDIFOUT_CIV) & 31,
  1240.       inb(state->card->iobase + CONTROLLERSPDIFOUT_LVI) & 31,
  1241.       dmabuf->hwptr, dmabuf->count);
  1242. dmabuf->error++;
  1243. }
  1244. }
  1245. if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
  1246. wake_up(&dmabuf->wait);
  1247. }
  1248. }
  1250. static inline int ali_get_free_write_space(struct
  1251.    ali_state
  1252.    *state)
  1253. {
  1254. struct dmabuf *dmabuf = &state->dmabuf;
  1255. int free;
  1256. ali_update_ptr(state);
  1257. // catch underruns during playback
  1258. if (dmabuf->count < 0) {
  1259. dmabuf->count = 0;
  1260. dmabuf->swptr = dmabuf->hwptr;
  1261. }
  1262. free = dmabuf->dmasize - dmabuf->count;
  1263. free -= (dmabuf->hwptr % dmabuf->fragsize);
  1264. if (free < 0)
  1265. return (0);
  1266. return (free);
  1267. }
  1269. static inline int ali_get_available_read_data(struct
  1270.       ali_state
  1271.       *state)
  1272. {
  1273. struct dmabuf *dmabuf = &state->dmabuf;
  1274. int avail;
  1275. ali_update_ptr(state);
  1276. // catch overruns during record
  1277. if (dmabuf->count > dmabuf->dmasize) {
  1278. dmabuf->count = dmabuf->dmasize;
  1279. dmabuf->swptr = dmabuf->hwptr;
  1280. }
  1281. avail = dmabuf->count;
  1282. avail -= (dmabuf->hwptr % dmabuf->fragsize);
  1283. if (avail < 0)
  1284. return (0);
  1285. return (avail);
  1286. }
  1288. static int drain_dac(struct ali_state *state, int signals_allowed)
  1289. {
  1291. DECLARE_WAITQUEUE(wait, current);
  1292. struct dmabuf *dmabuf = &state->dmabuf;
  1293. unsigned long flags;
  1294. unsigned long tmo;
  1295. int count;
  1296. if (!dmabuf->ready)
  1297. return 0;
  1298. if (dmabuf->mapped) {
  1299. stop_dac(state);
  1300. return 0;
  1301. }
  1302. add_wait_queue(&dmabuf->wait, &wait);
  1303. for (;;) {
  1305. spin_lock_irqsave(&state->card->lock, flags);
  1306. ali_update_ptr(state);
  1307. count = dmabuf->count;
  1308. spin_unlock_irqrestore(&state->card->lock, flags);
  1309. if (count <= 0)
  1310. break;
  1311. /* 
  1312.  * This will make sure that our LVI is correct, that our
  1313.  * pointer is updated, and that the DAC is running.  We
  1314.  * have to force the setting of dmabuf->trigger to avoid
  1315.  * any possible deadlocks.
  1316.  */
  1317. if (!dmabuf->enable) {
  1318. dmabuf->trigger = PCM_ENABLE_OUTPUT;
  1319. ali_update_lvi(state, 0);
  1320. }
  1321. if (signal_pending(current) && signals_allowed) {
  1322. break;
  1323. }
  1325. /* It seems that we have to set the current state to
  1326.  * TASK_INTERRUPTIBLE every time to make the process
  1327.  * really go to sleep.  This also has to be *after* the
  1328.  * update_ptr() call because update_ptr is likely to
  1329.  * do a wake_up() which will unset this before we ever
  1330.  * try to sleep, resuling in a tight loop in this code
  1331.  * instead of actually sleeping and waiting for an
  1332.  * interrupt to wake us up!
  1333.  */
  1334. set_current_state(TASK_INTERRUPTIBLE);
  1335. /*
  1336.  * set the timeout to significantly longer than it *should*
  1337.  * take for the DAC to drain the DMA buffer
  1338.  */
  1339. tmo = (count * HZ) / (dmabuf->rate);
  1340. if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
  1341. printk(KERN_ERR "ali_audio: drain_dac, dma timeout?n");
  1342. count = 0;
  1343. break;
  1344. }
  1345. }
  1346. set_current_state(TASK_RUNNING);
  1347. remove_wait_queue(&dmabuf->wait, &wait);
  1348. if (count > 0 && signal_pending(current) && signals_allowed)
  1349. return -ERESTARTSYS;
  1350. stop_dac(state);
  1351. return 0;
  1352. }
  1355. static int drain_spdifout(struct ali_state *state, int signals_allowed)
  1356. {
  1358. DECLARE_WAITQUEUE(wait, current);
  1359. struct dmabuf *dmabuf = &state->dmabuf;
  1360. unsigned long flags;
  1361. unsigned long tmo;
  1362. int count;
  1363. if (!dmabuf->ready)
  1364. return 0;
  1365. if (dmabuf->mapped) {
  1366. stop_spdifout(state);
  1367. return 0;
  1368. }
  1369. add_wait_queue(&dmabuf->wait, &wait);
  1370. for (;;) {
  1372. spin_lock_irqsave(&state->card->lock, flags);
  1373. ali_update_ptr(state);
  1374. count = dmabuf->count;
  1375. spin_unlock_irqrestore(&state->card->lock, flags);
  1376. if (count <= 0)
  1377. break;
  1378. /* 
  1379.  * This will make sure that our LVI is correct, that our
  1380.  * pointer is updated, and that the DAC is running.  We
  1381.  * have to force the setting of dmabuf->trigger to avoid
  1382.  * any possible deadlocks.
  1383.  */
  1384. if (!dmabuf->enable) {
  1385. if (codec_independent_spdif_locked > 0) {
  1386. dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
  1387. ali_update_lvi(state, 2);
  1388. } else {
  1389. if (controller_independent_spdif_locked > 0) {
  1390. dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
  1391. ali_update_lvi(state, 3);
  1392. }
  1393. }
  1394. }
  1395. if (signal_pending(current) && signals_allowed) {
  1396. break;
  1397. }
  1399. /* It seems that we have to set the current state to
  1400.  * TASK_INTERRUPTIBLE every time to make the process
  1401.  * really go to sleep.  This also has to be *after* the
  1402.  * update_ptr() call because update_ptr is likely to
  1403.  * do a wake_up() which will unset this before we ever
  1404.  * try to sleep, resuling in a tight loop in this code
  1405.  * instead of actually sleeping and waiting for an
  1406.  * interrupt to wake us up!
  1407.  */
  1408. set_current_state(TASK_INTERRUPTIBLE);
  1409. /*
  1410.  * set the timeout to significantly longer than it *should*
  1411.  * take for the DAC to drain the DMA buffer
  1412.  */
  1413. tmo = (count * HZ) / (dmabuf->rate);
  1414. if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
  1415. printk(KERN_ERR "ali_audio: drain_spdifout, dma timeout?n");
  1416. count = 0;
  1417. break;
  1418. }
  1419. }
  1420. set_current_state(TASK_RUNNING);
  1421. remove_wait_queue(&dmabuf->wait, &wait);
  1422. if (count > 0 && signal_pending(current) && signals_allowed)
  1423. return -ERESTARTSYS;
  1424. stop_spdifout(state);
  1425. return 0;
  1426. }
  1428. static void ali_channel_interrupt(struct ali_card *card)
  1429. {
  1430. int i, count;
  1432. for (i = 0; i < NR_HW_CH; i++) {
  1433. struct ali_state *state = card->states[i];
  1434. struct ali_channel *c = NULL;
  1435. struct dmabuf *dmabuf;
  1436. unsigned long port = card->iobase;
  1437. u16 status;
  1438. if (!state)
  1439. continue;
  1440. if (!state->dmabuf.ready)
  1441. continue;
  1442. dmabuf = &state->dmabuf;
  1443. if (codec_independent_spdif_locked > 0) {
  1444. if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
  1445. c = dmabuf->codec_spdifout_channel;
  1446. }
  1447. } else {
  1448. if (controller_independent_spdif_locked > 0) {
  1449. if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
  1450. c = dmabuf->controller_spdifout_channel;
  1451. } else {
  1452. if (dmabuf->enable & DAC_RUNNING) {
  1453. c = dmabuf->write_channel;
  1454. } else if (dmabuf->enable & ADC_RUNNING) {
  1455. c = dmabuf->read_channel;
  1456. } else
  1457. continue;
  1458. }
  1459. }
  1460. port += c->port;
  1462. status = inw(port + OFF_SR);
  1464. if (status & DMA_INT_COMPLETE) {
  1465. /* only wake_up() waiters if this interrupt signals
  1466.  * us being beyond a userfragsize of data open or
  1467.  * available, and ali_update_ptr() does that for
  1468.  * us
  1469.  */
  1470. ali_update_ptr(state);
  1471. }
  1473. if (status & DMA_INT_LVI) {
  1474. ali_update_ptr(state);
  1475. wake_up(&dmabuf->wait);
  1477. if (dmabuf->enable & DAC_RUNNING)
  1478. count = dmabuf->count;
  1479. else if (dmabuf->enable & ADC_RUNNING)
  1480. count = dmabuf->dmasize - dmabuf->count;
  1481. else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
  1482. count = dmabuf->count;
  1483. else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
  1484. count = dmabuf->count;
  1485. else count = 0;
  1487. if (count > 0) {
  1488. if (dmabuf->enable & DAC_RUNNING)
  1489. outl((1 << 1), state->card->iobase + ALI_DMACR);
  1490. else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
  1491. outl((1 << 3), state->card->iobase + ALI_DMACR);
  1492. else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
  1493. outl((1 << 7), state->card->iobase + ALI_DMACR);
  1494. } else {
  1495. if (dmabuf->enable & DAC_RUNNING)
  1496. __stop_dac(state);
  1497. if (dmabuf->enable & ADC_RUNNING)
  1498. __stop_adc(state);
  1499. if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
  1500. __stop_spdifout(state);
  1501. if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
  1502. __stop_spdifout(state);
  1503. dmabuf->enable = 0;
  1504. wake_up(&dmabuf->wait);
  1505. }
  1507. }
  1508. if (!(status & DMA_INT_DCH)) {
  1509. ali_update_ptr(state);
  1510. wake_up(&dmabuf->wait);
  1511. if (dmabuf->enable & DAC_RUNNING)
  1512. count = dmabuf->count;
  1513. else if (dmabuf->enable & ADC_RUNNING)
  1514. count = dmabuf->dmasize - dmabuf->count;
  1515. else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
  1516. count = dmabuf->count;
  1517. else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
  1518. count = dmabuf->count;
  1519. else
  1520. count = 0;
  1522. if (count > 0) {
  1523. if (dmabuf->enable & DAC_RUNNING)
  1524. outl((1 << 1), state->card->iobase + ALI_DMACR);
  1525. else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
  1526. outl((1 << 3), state->card->iobase + ALI_DMACR);
  1527. else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
  1528. outl((1 << 7), state->card->iobase + ALI_DMACR);
  1529. } else {
  1530. if (dmabuf->enable & DAC_RUNNING)
  1531. __stop_dac(state);
  1532. if (dmabuf->enable & ADC_RUNNING)
  1533. __stop_adc(state);
  1534. if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
  1535. __stop_spdifout(state);
  1536. if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
  1537. __stop_spdifout(state);
  1538. dmabuf->enable = 0;
  1539. wake_up(&dmabuf->wait);
  1540. }
  1541. }
  1542. outw(status & DMA_INT_MASK, port + OFF_SR);
  1543. }
  1544. }
  1546. static void ali_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  1547. {
  1548. struct ali_card *card = (struct ali_card *) dev_id;
  1549. u32 status;
  1550. u16 status2;
  1552. spin_lock(&card->lock);
  1553. status = inl(card->iobase + ALI_INTERRUPTSR);
  1554. if (!(status & INT_MASK)) {
  1555. spin_unlock(&card->lock);
  1556. return; /* not for us */
  1557. }
  1559. if (codec_independent_spdif_locked > 0) {
  1560. if (globel == 0) {
  1561. globel += 1;
  1562. status2 = inw(card->iobase + 0x76);
  1563. outw(status2 | 0x000c, card->iobase + 0x76);
  1564. } else {
  1565. if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
  1566. ali_channel_interrupt(card);
  1567. }
  1568. } else {
  1569. if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
  1570. ali_channel_interrupt(card);
  1571. }
  1573. /* clear 'em */
  1574. outl(status & INT_MASK, card->iobase + ALI_INTERRUPTSR);
  1575. spin_unlock(&card->lock);
  1576. }
  1578. /* in this loop, dmabuf.count signifies the amount of data that is
  1579.    waiting to be copied to the user's buffer.  It is filled by the dma
  1580.    machine and drained by this loop. */
  1582. static ssize_t ali_read(struct file *file, char *buffer,
  1583. size_t count, loff_t * ppos)
  1584. {
  1585. struct ali_state *state = (struct ali_state *) file->private_data;
  1586. struct ali_card *card = state ? state->card : 0;
  1587. struct dmabuf *dmabuf = &state->dmabuf;
  1588. ssize_t ret;
  1589. unsigned long flags;
  1590. unsigned int swptr;
  1591. int cnt;
  1592. DECLARE_WAITQUEUE(waita, current);
  1593. #ifdef DEBUG2
  1594. printk("ali_audio: ali_read called, count = %dn", count);
  1595. #endif
  1596. if (ppos != &file->f_pos)
  1597. return -ESPIPE;
  1598. if (dmabuf->mapped)
  1599. return -ENXIO;
  1600. if (dmabuf->enable & DAC_RUNNING)
  1601. return -ENODEV;
  1602. if (!dmabuf->read_channel) {
  1603. dmabuf->ready = 0;
  1604. dmabuf->read_channel = card->alloc_rec_pcm_channel(card);
  1605. if (!dmabuf->read_channel) {
  1606. return -EBUSY;
  1607. }
  1608. }
  1609. if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
  1610. return ret;
  1611. if (!access_ok(VERIFY_WRITE, buffer, count))
  1612. return -EFAULT;
  1613. ret = 0;
  1614. add_wait_queue(&dmabuf->wait, &waita);
  1615. while (count > 0) {
  1616. set_current_state(TASK_INTERRUPTIBLE);
  1617. spin_lock_irqsave(&card->lock, flags);
  1618. if (PM_SUSPENDED(card)) {
  1619. spin_unlock_irqrestore(&card->lock, flags);
  1620. schedule();
  1621. if (signal_pending(current)) {
  1622. if (!ret)
  1623. ret = -EAGAIN;
  1624. break;
  1625. }
  1626. continue;
  1627. }
  1628. swptr = dmabuf->swptr;
  1629. cnt = ali_get_available_read_data(state);
  1630. // this is to make the copy_to_user simpler below
  1631. if (cnt > (dmabuf->dmasize - swptr))
  1632. cnt = dmabuf->dmasize - swptr;
  1633. spin_unlock_irqrestore(&card->lock, flags);
  1634. if (cnt > count)
  1635. cnt = count;
  1636. /* Lop off the last two bits to force the code to always
  1637.  * write in full samples.  This keeps software that sets
  1638.  * O_NONBLOCK but doesn't check the return value of the
  1639.  * write call from getting things out of state where they
  1640.  * think a full 4 byte sample was written when really only
  1641.  * a portion was, resulting in odd sound and stereo
  1642.  * hysteresis.
  1643.  */
  1644. cnt &= ~0x3;
  1645. if (cnt <= 0) {
  1646. unsigned long tmo;
  1647. /*
  1648.  * Don't let us deadlock.  The ADC won't start if
  1649.  * dmabuf->trigger isn't set.  A call to SETTRIGGER
  1650.  * could have turned it off after we set it to on
  1651.  * previously.
  1652.  */
  1653. dmabuf->trigger = PCM_ENABLE_INPUT;
  1654. /*
  1655.  * This does three things.  Updates LVI to be correct,
  1656.  * makes sure the ADC is running, and updates the
  1657.  * hwptr.
  1658.  */
  1659. ali_update_lvi(state, 1);
  1660. if (file->f_flags & O_NONBLOCK) {
  1661. if (!ret)
  1662. ret = -EAGAIN;
  1663. goto done;
  1664. }
  1665. /* Set the timeout to how long it would take to fill
  1666.  * two of our buffers.  If we haven't been woke up
  1667.  * by then, then we know something is wrong.
  1668.  */
  1669. tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
  1670.     
  1671. /* There are two situations when sleep_on_timeout returns, one is when
  1672.    the interrupt is serviced correctly and the process is waked up by
  1673.    ISR ON TIME. Another is when timeout is expired, which means that
  1674.    either interrupt is NOT serviced correctly (pending interrupt) or it
  1675.    is TOO LATE for the process to be scheduled to run (scheduler latency)
  1676.    which results in a (potential) buffer overrun. And worse, there is
  1677.    NOTHING we can do to prevent it. */
  1678. if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
  1679. printk(KERN_ERR
  1680.        "ali_audio: recording schedule timeout, "
  1681.        "dmasz %u fragsz %u count %i hwptr %u swptr %un",
  1682.        dmabuf->dmasize, dmabuf->fragsize,
  1683.        dmabuf->count, dmabuf->hwptr,
  1684.        dmabuf->swptr);
  1685. /* a buffer overrun, we delay the recovery until next time the
  1686.    while loop begin and we REALLY have space to record */
  1687. }
  1688. if (signal_pending(current)) {
  1689. ret = ret ? ret : -ERESTARTSYS;
  1690. goto done;
  1691. }
  1692. continue;
  1693. }
  1695. if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
  1696. if (!ret)
  1697. ret = -EFAULT;
  1698. goto done;
  1699. }
  1701. swptr = (swptr + cnt) % dmabuf->dmasize;
  1702. spin_lock_irqsave(&card->lock, flags);
  1703. if (PM_SUSPENDED(card)) {
  1704. spin_unlock_irqrestore(&card->lock, flags);
  1705. continue;
  1706. }
  1707. dmabuf->swptr = swptr;
  1708. dmabuf->count -= cnt;
  1709. spin_unlock_irqrestore(&card->lock, flags);
  1710. count -= cnt;
  1711. buffer += cnt;
  1712. ret += cnt;
  1713. }
  1714. done:
  1715. ali_update_lvi(state, 1);
  1716. set_current_state(TASK_RUNNING);
  1717. remove_wait_queue(&dmabuf->wait, &waita);
  1718. return ret;
  1719. }
  1721. /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
  1722.    the soundcard.  it is drained by the dma machine and filled by this loop. */
  1723. static ssize_t ali_write(struct file *file,
  1724.  const char *buffer, size_t count, loff_t * ppos)
  1725. {
  1726. struct ali_state *state = (struct ali_state *) file->private_data;
  1727. struct ali_card *card = state ? state->card : 0;
  1728. struct dmabuf *dmabuf = &state->dmabuf;
  1729. ssize_t ret;
  1730. unsigned long flags;
  1731. unsigned int swptr = 0;
  1732. int cnt, x;
  1733. DECLARE_WAITQUEUE(waita, current);
  1734. #ifdef DEBUG2
  1735. printk("ali_audio: ali_write called, count = %dn", count);
  1736. #endif
  1737. if (ppos != &file->f_pos)
  1738. return -ESPIPE;
  1739. if (dmabuf->mapped)
  1740. return -ENXIO;
  1741. if (dmabuf->enable & ADC_RUNNING)
  1742. return -ENODEV;
  1743. if (codec_independent_spdif_locked > 0) {
  1744. if (!dmabuf->codec_spdifout_channel) {
  1745. dmabuf->ready = 0;
  1746. dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card);
  1747. if (!dmabuf->codec_spdifout_channel)
  1748. return -EBUSY;
  1749. }
  1750. } else {
  1751. if (controller_independent_spdif_locked > 0) {
  1752. if (!dmabuf->controller_spdifout_channel) {
  1753. dmabuf->ready = 0;
  1754. dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card);
  1755. if (!dmabuf->controller_spdifout_channel)
  1756. return -EBUSY;
  1757. }
  1758. } else {
  1759. if (!dmabuf->write_channel) {
  1760. dmabuf->ready = 0;
  1761. dmabuf->write_channel =
  1762.     card->alloc_pcm_channel(card);
  1763. if (!dmabuf->write_channel)
  1764. return -EBUSY;
  1765. }
  1766. }
  1767. }
  1769. if (codec_independent_spdif_locked > 0) {
  1770. if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
  1771. return ret;
  1772. } else {
  1773. if (controller_independent_spdif_locked > 0) {
  1774. if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
  1775. return ret;
  1776. } else {
  1778. if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
  1779. return ret;
  1780. }
  1781. }
  1782. if (!access_ok(VERIFY_READ, buffer, count))
  1783. return -EFAULT;
  1784. ret = 0;
  1785. add_wait_queue(&dmabuf->wait, &waita);
  1786. while (count > 0) {
  1787. set_current_state(TASK_INTERRUPTIBLE);
  1788. spin_lock_irqsave(&state->card->lock, flags);
  1789. if (PM_SUSPENDED(card)) {
  1790. spin_unlock_irqrestore(&card->lock, flags);
  1791. schedule();
  1792. if (signal_pending(current)) {
  1793. if (!ret)
  1794. ret = -EAGAIN;
  1795. break;
  1796. }
  1797. continue;
  1798. }
  1800. swptr = dmabuf->swptr;
  1801. cnt = ali_get_free_write_space(state);
  1802. /* Bound the maximum size to how much we can copy to the
  1803.  * dma buffer before we hit the end.  If we have more to
  1804.  * copy then it will get done in a second pass of this
  1805.  * loop starting from the beginning of the buffer.
  1806.  */
  1807. if (cnt > (dmabuf->dmasize - swptr))
  1808. cnt = dmabuf->dmasize - swptr;
  1809. spin_unlock_irqrestore(&state->card->lock, flags);
  1810. #ifdef DEBUG2
  1811. printk(KERN_INFO
  1812.        "ali_audio: ali_write: %d bytes available spacen",
  1813.        cnt);
  1814. #endif
  1815. if (cnt > count)
  1816. cnt = count;
  1817. /* Lop off the last two bits to force the code to always
  1818.  * write in full samples.  This keeps software that sets
  1819.  * O_NONBLOCK but doesn't check the return value of the
  1820.  * write call from getting things out of state where they
  1821.  * think a full 4 byte sample was written when really only
  1822.  * a portion was, resulting in odd sound and stereo
  1823.  * hysteresis.
  1824.  */
  1825. cnt &= ~0x3;
  1826. if (cnt <= 0) {
  1827. unsigned long tmo;
  1828. // There is data waiting to be played
  1829. /*
  1830.  * Force the trigger setting since we would
  1831.  * deadlock with it set any other way
  1832.  */
  1833. if (codec_independent_spdif_locked > 0) {
  1834. dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
  1835. ali_update_lvi(state, 2);
  1836. } else {
  1837. if (controller_independent_spdif_locked > 0) {
  1838. dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
  1839. ali_update_lvi(state, 3);
  1840. } else {
  1842. dmabuf->trigger = PCM_ENABLE_OUTPUT;
  1843. ali_update_lvi(state, 0);
  1844. }
  1845. }
  1846. if (file->f_flags & O_NONBLOCK) {
  1847. if (!ret)
  1848. ret = -EAGAIN;
  1849. goto ret;
  1850. }
  1851. /* Not strictly correct but works */
  1852. tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
  1853. /* There are two situations when sleep_on_timeout returns, one is when
  1854.    the interrupt is serviced correctly and the process is waked up by
  1855.    ISR ON TIME. Another is when timeout is expired, which means that
  1856.    either interrupt is NOT serviced correctly (pending interrupt) or it
  1857.    is TOO LATE for the process to be scheduled to run (scheduler latency)
  1858.    which results in a (potential) buffer underrun. And worse, there is
  1859.    NOTHING we can do to prevent it. */
  1860.    
  1861. /* FIXME - do timeout handling here !! */
  1863. if (signal_pending(current)) {
  1864. if (!ret)
  1865. ret = -ERESTARTSYS;
  1866. goto ret;
  1867. }
  1868. continue;
  1869. }
  1870. if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
  1871. if (!ret)
  1872. ret = -EFAULT;
  1873. goto ret;
  1874. }
  1876. swptr = (swptr + cnt) % dmabuf->dmasize;
  1877. spin_lock_irqsave(&state->card->lock, flags);
  1878. if (PM_SUSPENDED(card)) {
  1879. spin_unlock_irqrestore(&card->lock, flags);
  1880. continue;
  1881. }
  1883. dmabuf->swptr = swptr;
  1884. dmabuf->count += cnt;
  1885. count -= cnt;
  1886. buffer += cnt;
  1887. ret += cnt;
  1888. spin_unlock_irqrestore(&state->card->lock, flags);
  1889. }
  1890. if (swptr % dmabuf->fragsize) {
  1891. x = dmabuf->fragsize - (swptr % dmabuf->fragsize);
  1892. memset(dmabuf->rawbuf + swptr, '', x);
  1893. }
  1894. ret:
  1895. if (codec_independent_spdif_locked > 0) {
  1896. ali_update_lvi(state, 2);
  1897. } else {
  1898. if (controller_independent_spdif_locked > 0) {
  1899. ali_update_lvi(state, 3);
  1900. } else {
  1901. ali_update_lvi(state, 0);
  1902. }
  1903. }
  1904. set_current_state(TASK_RUNNING);
  1905. remove_wait_queue(&dmabuf->wait, &waita);
  1906. return ret;
  1907. }
  1909. /* No kernel lock - we have our own spinlock */
  1910. static unsigned int ali_poll(struct file *file, struct poll_table_struct
  1911.      *wait)
  1912. {
  1913. struct ali_state *state = (struct ali_state *) file->private_data;
  1914. struct dmabuf *dmabuf = &state->dmabuf;
  1915. unsigned long flags;
  1916. unsigned int mask = 0;
  1917. if (!dmabuf->ready)
  1918. return 0;
  1919. poll_wait(file, &dmabuf->wait, wait);
  1920. spin_lock_irqsave(&state->card->lock, flags);
  1921. ali_update_ptr(state);
  1922. if (file->f_mode & FMODE_READ && dmabuf->enable & ADC_RUNNING) {
  1923. if (dmabuf->count >= (signed) dmabuf->fragsize)
  1924. mask |= POLLIN | POLLRDNORM;
  1925. }
  1926. if (file->f_mode & FMODE_WRITE  && (dmabuf->enable & (DAC_RUNNING|CODEC_SPDIFOUT_RUNNING|CONTROLLER_SPDIFOUT_RUNNING))) {
  1927. if ((signed) dmabuf->dmasize >= dmabuf->count + (signed) dmabuf->fragsize)
  1928. mask |= POLLOUT | POLLWRNORM;
  1929. }
  1930. spin_unlock_irqrestore(&state->card->lock, flags);
  1931. return mask;
  1932. }
  1934. static int ali_mmap(struct file *file, struct vm_area_struct *vma)
  1935. {
  1936. struct ali_state *state = (struct ali_state *) file->private_data;
  1937. struct dmabuf *dmabuf = &state->dmabuf;
  1938. int ret = -EINVAL;
  1939. unsigned long size;
  1940. lock_kernel();
  1941. if (vma->vm_flags & VM_WRITE) {
  1942. if (!dmabuf->write_channel && (dmabuf->write_channel = state->card->alloc_pcm_channel(state->card)) == NULL) {
  1943. ret = -EBUSY;
  1944. goto out;
  1945. }
  1946. }
  1947. if (vma->vm_flags & VM_READ) {
  1948. if (!dmabuf->read_channel && (dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card)) == NULL) {
  1949. ret = -EBUSY;
  1950. goto out;
  1951. }
  1952. }
  1953. if ((ret = prog_dmabuf(state, 0)) != 0)
  1954. goto out;
  1955. ret = -EINVAL;
  1956. if (vma->vm_pgoff != 0)
  1957. goto out;
  1958. size = vma->vm_end - vma->vm_start;
  1959. if (size > (PAGE_SIZE << dmabuf->buforder))
  1960. goto out;
  1961. ret = -EAGAIN;
  1962. if (remap_page_range(vma->vm_start, virt_to_phys(dmabuf->rawbuf), size, vma->vm_page_prot))
  1963. goto out;
  1964. dmabuf->mapped = 1;
  1965. dmabuf->trigger = 0;
  1966. ret = 0;
  1967. out:
  1968. unlock_kernel();
  1969. return ret;
  1970. }
  1972. static int ali_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  1973. {
  1974. struct ali_state *state = (struct ali_state *) file->private_data;
  1975. struct ali_channel *c = NULL;
  1976. struct dmabuf *dmabuf = &state->dmabuf;
  1977. unsigned long flags;
  1978. audio_buf_info abinfo;
  1979. count_info cinfo;
  1980. unsigned int i_scr;
  1981. int val = 0, ret;
  1982. struct ac97_codec *codec = state->card->ac97_codec[0];
  1983. #ifdef DEBUG
  1984. printk("ali_audio: ali_ioctl, arg=0x%x, cmd=",
  1985.        arg ? *(int *) arg : 0);
  1986. #endif
  1987. switch (cmd) {
  1988. case OSS_GETVERSION:
  1989. #ifdef DEBUG
  1990. printk("OSS_GETVERSIONn");
  1991. #endif
  1992. return put_user(SOUND_VERSION, (int *) arg);
  1993. case SNDCTL_DSP_RESET:
  1994. #ifdef DEBUG
  1995. printk("SNDCTL_DSP_RESETn");
  1996. #endif
  1997. spin_lock_irqsave(&state->card->lock, flags);
  1998. if (dmabuf->enable == DAC_RUNNING) {
  1999. c = dmabuf->write_channel;
  2000. __stop_dac(state);
  2001. }
  2002. if (dmabuf->enable == ADC_RUNNING) {
  2003. c = dmabuf->read_channel;
  2004. __stop_adc(state);
  2005. }
  2006. if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
  2007. c = dmabuf->codec_spdifout_channel;
  2008. __stop_spdifout(state);
  2009. }
  2010. if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
  2011. c = dmabuf->controller_spdifout_channel;
  2012. __stop_spdifout(state);
  2013. }
  2014. if (c != NULL) {
  2015. outb(2, state->card->iobase + c->port + OFF_CR); /* reset DMA machine */
  2016. outl(virt_to_bus(&c->sg[0]),
  2017.      state->card->iobase + c->port + OFF_BDBAR);
  2018. outb(0, state->card->iobase + c->port + OFF_CIV);
  2019. outb(0, state->card->iobase + c->port + OFF_LVI);
  2020. }
  2022. spin_unlock_irqrestore(&state->card->lock, flags);
  2023. synchronize_irq();
  2024. dmabuf->ready = 0;
  2025. dmabuf->swptr = dmabuf->hwptr = 0;
  2026. dmabuf->count = dmabuf->total_bytes = 0;
  2027. return 0;
  2028. case SNDCTL_DSP_SYNC:
  2029. #ifdef DEBUG
  2030. printk("SNDCTL_DSP_SYNCn");
  2031. #endif
  2032. if (codec_independent_spdif_locked > 0) {
  2033. if (dmabuf->enable != CODEC_SPDIFOUT_RUNNING
  2034.     || file->f_flags & O_NONBLOCK)
  2035. return 0;
  2036. if ((val = drain_spdifout(state, 1)))
  2037. return val;
  2038. } else {
  2039. if (controller_independent_spdif_locked > 0) {
  2040. if (dmabuf->enable !=
  2041.     CONTROLLER_SPDIFOUT_RUNNING
  2042.     || file->f_flags & O_NONBLOCK)
  2043. return 0;
  2044. if ((val = drain_spdifout(state, 1)))
  2045. return val;
  2046. } else {
  2047. if (dmabuf->enable != DAC_RUNNING
  2048.     || file->f_flags & O_NONBLOCK)
  2049. return 0;
  2050. if ((val = drain_dac(state, 1)))
  2051. return val;
  2052. }
  2053. }
  2054. dmabuf->total_bytes = 0;
  2055. return 0;
  2056. case SNDCTL_DSP_SPEED: /* set smaple rate */
  2057. #ifdef DEBUG
  2058. printk("SNDCTL_DSP_SPEEDn");
  2059. #endif
  2060. if (get_user(val, (int *) arg))
  2061. return -EFAULT;
  2062. if (val >= 0) {
  2063. if (file->f_mode & FMODE_WRITE) {
  2064. if ((state->card->ac97_status & SPDIF_ON)) { /* S/PDIF Enabled */
  2065. /* RELTEK ALC650 only support 48000, need to check that */
  2066. if (ali_valid_spdif_rate(codec, val)) {
  2067. if (codec_independent_spdif_locked > 0) {
  2068. ali_set_spdif_output(state, -1, 0);
  2069. stop_spdifout(state);
  2070. dmabuf->ready = 0;
  2071. /* I add test codec independent spdif out */
  2072. spin_lock_irqsave(&state->card->lock, flags);
  2073. ali_set_codecspdifout_rate(state, val); // I modified
  2074. spin_unlock_irqrestore(&state->card->lock, flags);
  2075. /* Set S/PDIF transmitter rate. */
  2076. i_scr = inl(state->card->iobase + ALI_SCR);
  2077. if ((i_scr & 0x00300000) == 0x00100000) {
  2078. ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
  2079. } else {
  2080. if ((i_scr&0x00300000)  == 0x00200000)
  2081. {
  2082. ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
  2083. } else {
  2084. if ((i_scr & 0x00300000) == 0x00300000) {
  2085. ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
  2086. } else {
  2087. ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
  2088. }
  2089. }
  2090. }
  2092. if (!(state->card->ac97_status & SPDIF_ON)) {
  2093. val = dmabuf->rate;
  2094. }
  2095. } else {
  2096. if (controller_independent_spdif_locked > 0) 
  2097. {
  2098. stop_spdifout(state);
  2099. dmabuf->ready = 0;
  2100. spin_lock_irqsave(&state->card->lock, flags);
  2101. ali_set_spdifout_rate(state, controller_independent_spdif_locked);
  2102. spin_unlock_irqrestore(&state->card->lock, flags);
  2103. } else {
  2104. /* Set DAC rate */
  2105. ali_set_spdif_output(state, -1, 0);
  2106. stop_dac(state);
  2107. dmabuf->ready = 0;
  2108. spin_lock_irqsave(&state->card->lock, flags);
  2109. ali_set_dac_rate(state, val);
  2110. spin_unlock_irqrestore(&state->card->lock, flags);
  2111. /* Set S/PDIF transmitter rate. */
  2112. ali_set_spdif_output(state, AC97_EA_SPSA_3_4, val);
  2113. if (!(state->card->ac97_status & SPDIF_ON))
  2114. {
  2115. val = dmabuf->rate;
  2116. }
  2117. }
  2118. }
  2119. } else { /* Not a valid rate for S/PDIF, ignore it */
  2120. val = dmabuf->rate;
  2121. }
  2122. } else {
  2123. stop_dac(state);
  2124. dmabuf->ready = 0;
  2125. spin_lock_irqsave(&state->card->lock, flags);
  2126. ali_set_dac_rate(state, val);
  2127. spin_unlock_irqrestore(&state->card->lock, flags);
  2128. }
  2129. }
  2130. if (file->f_mode & FMODE_READ) {
  2131. stop_adc(state);
  2132. dmabuf->ready = 0;
  2133. spin_lock_irqsave(&state->card->lock, flags);
  2134. ali_set_adc_rate(state, val);
  2135. spin_unlock_irqrestore(&state->card->lock, flags);
  2136. }
  2137. }
  2138. return put_user(dmabuf->rate, (int *) arg);
  2139. case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
  2140. #ifdef DEBUG
  2141. printk("SNDCTL_DSP_STEREOn");
  2142. #endif
  2143. if (dmabuf->enable & DAC_RUNNING) {
  2144. stop_dac(state);
  2145. }
  2146. if (dmabuf->enable & ADC_RUNNING) {
  2147. stop_adc(state);
  2148. }
  2149. if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
  2150. stop_spdifout(state);
  2151. }
  2152. if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
  2153. stop_spdifout(state);
  2154. }
  2155. return put_user(1, (int *) arg);
  2156. case SNDCTL_DSP_GETBLKSIZE:
  2157. if (file->f_mode & FMODE_WRITE) {
  2158. if (codec_independent_spdif_locked > 0) {
  2159. if (!dmabuf->ready && (val = prog_dmabuf(state, 2)))
  2160. return val;
  2161. } else {
  2162. if (controller_independent_spdif_locked > 0) {
  2163. if (!dmabuf->ready && (val = prog_dmabuf(state, 3)))
  2164. return val;
  2165. } else {
  2166. if (!dmabuf->ready && (val = prog_dmabuf(state, 0)))
  2167. return val;
  2168. }
  2169. }
  2170. }
  2172. if (file->f_mode & FMODE_READ) {
  2173. if (!dmabuf->ready && (val = prog_dmabuf(state, 1)))
  2174. return val;
  2175. }
  2176. #ifdef DEBUG
  2177. printk("SNDCTL_DSP_GETBLKSIZE %dn", dmabuf->userfragsize);
  2178. #endif
  2179. return put_user(dmabuf->userfragsize, (int *) arg);
  2180. case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format */
  2181. #ifdef DEBUG
  2182. printk("SNDCTL_DSP_GETFMTSn");
  2183. #endif
  2184. return put_user(AFMT_S16_LE, (int *) arg);
  2185. case SNDCTL_DSP_SETFMT: /* Select sample format */
  2186. #ifdef DEBUG
  2187. printk("SNDCTL_DSP_SETFMTn");
  2188. #endif
  2189. return put_user(AFMT_S16_LE, (int *) arg);
  2190. case SNDCTL_DSP_CHANNELS: // add support 4,6 channel 
  2191. #ifdef DEBUG
  2192. printk("SNDCTL_DSP_CHANNELSn");
  2193. #endif
  2194. if (get_user(val, (int *) arg))
  2195. return -EFAULT;
  2196. if (val > 0) {
  2197. if (dmabuf->enable & DAC_RUNNING) {
  2198. stop_dac(state);
  2199. }
  2200. if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
  2201. stop_spdifout(state);
  2202. }
  2203. if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
  2204. stop_spdifout(state);
  2205. }
  2206. if (dmabuf->enable & ADC_RUNNING) {
  2207. stop_adc(state);
  2208. }
  2209. } else {
  2210. return put_user(state->card->channels, (int *) arg);
  2211. }
  2213. i_scr = inl(state->card->iobase + ALI_SCR);
  2214. /* Current # of channels enabled */
  2215. if (i_scr & 0x00000100)
  2216. ret = 4;
  2217. else if (i_scr & 0x00000200)
  2218. ret = 6;
  2219. else
  2220. ret = 2;
  2221. switch (val) {
  2222. case 2: /* 2 channels is always supported */
  2223. if (codec_independent_spdif_locked > 0) {
  2224. outl(((i_scr & 0xfffffcff) | 0x00100000), (state->card->iobase + ALI_SCR));
  2225. } else
  2226. outl((i_scr & 0xfffffcff), (state->card->iobase + ALI_SCR));
  2227. /* Do we need to change mixer settings????  */
  2228. break;
  2229. case 4: /* Supported on some chipsets, better check first */
  2230. if (codec_independent_spdif_locked > 0) {
  2231. outl(((i_scr & 0xfffffcff) | 0x00000100 | 0x00200000), (state->card->iobase + ALI_SCR));
  2232. } else
  2233. outl(((i_scr & 0xfffffcff) | 0x00000100), (state->card->iobase + ALI_SCR));
  2234. break;
  2235. case 6: /* Supported on some chipsets, better check first */
  2236. if (codec_independent_spdif_locked > 0) {
  2237. outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000 | 0x00300000), (state->card->iobase + ALI_SCR));
  2238. } else
  2239. outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000), (state->card->iobase + ALI_SCR));
  2240. break;
  2241. default: /* nothing else is ever supported by the chipset */
  2242. val = ret;
  2243. break;
  2244. }
  2245. return put_user(val, (int *) arg);
  2246. case SNDCTL_DSP_POST: /* the user has sent all data and is notifying us */
  2247. /* we update the swptr to the end of the last sg segment then return */
  2248. #ifdef DEBUG
  2249. printk("SNDCTL_DSP_POSTn");
  2250. #endif
  2251. if (codec_independent_spdif_locked > 0) {
  2252. if (!dmabuf->ready || (dmabuf->enable != CODEC_SPDIFOUT_RUNNING))
  2253. return 0;
  2254. } else {
  2255. if (controller_independent_spdif_locked > 0) {
  2256. if (!dmabuf->ready || (dmabuf->enable != CONTROLLER_SPDIFOUT_RUNNING))
  2257. return 0;
  2258. } else {
  2259. if (!dmabuf->ready || (dmabuf->enable != DAC_RUNNING))
  2260. return 0;
  2261. }
  2262. }
  2263. if ((dmabuf->swptr % dmabuf->fragsize) != 0) {
  2264. val = dmabuf->fragsize - (dmabuf->swptr % dmabuf->fragsize);
  2265. dmabuf->swptr += val;
  2266. dmabuf->count += val;
  2267. }
  2268. return 0;
  2269. case SNDCTL_DSP_SUBDIVIDE:
  2270. if (dmabuf->subdivision)
  2271. return -EINVAL;
  2272. if (get_user(val, (int *) arg))
  2273. return -EFAULT;
  2274. if (val != 1 && val != 2 && val != 4)
  2275. return -EINVAL;
  2276. #ifdef DEBUG
  2277. printk("SNDCTL_DSP_SUBDIVIDE %dn", val);
  2278. #endif
  2279. dmabuf->subdivision = val;
  2280. dmabuf->ready = 0;
  2281. return 0;
  2282. case SNDCTL_DSP_SETFRAGMENT:
  2283. if (get_user(val, (int *) arg))
  2284. return -EFAULT;
  2285. dmabuf->ossfragsize = 1 << (val & 0xffff);
  2286. dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
  2287. if (!dmabuf->ossfragsize || !dmabuf->ossmaxfrags)
  2288. return -EINVAL;
  2289. /*
  2290.  * Bound the frag size into our allowed range of 256 - 4096
  2291.  */
  2292. if (dmabuf->ossfragsize < 256)
  2293. dmabuf->ossfragsize = 256;
  2294. else if (dmabuf->ossfragsize > 4096)
  2295. dmabuf->ossfragsize = 4096;
  2296. /*
  2297.  * The numfrags could be something reasonable, or it could
  2298.  * be 0xffff meaning "Give me as much as possible".  So,
  2299.  * we check the numfrags * fragsize doesn't exceed our
  2300.  * 64k buffer limit, nor is it less than our 8k minimum.
  2301.  * If it fails either one of these checks, then adjust the
  2302.  * number of fragments, not the size of them.  It's OK if
  2303.  * our number of fragments doesn't equal 32 or anything
  2304.  * like our hardware based number now since we are using
  2305.  * a different frag count for the hardware.  Before we get
  2306.  * into this though, bound the maxfrags to avoid overflow
  2307.  * issues.  A reasonable bound would be 64k / 256 since our
  2308.  * maximum buffer size is 64k and our minimum frag size is
  2309.  * 256.  On the other end, our minimum buffer size is 8k and
  2310.  * our maximum frag size is 4k, so the lower bound should
  2311.  * be 2.
  2312.  */
  2313. if (dmabuf->ossmaxfrags > 256)
  2314. dmabuf->ossmaxfrags = 256;
  2315. else if (dmabuf->ossmaxfrags < 2)
  2316. dmabuf->ossmaxfrags = 2;
  2317. val = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
  2318. while (val < 8192) {
  2319. val <<= 1;
  2320. dmabuf->ossmaxfrags <<= 1;
  2321. }
  2322. while (val > 65536) {
  2323. val >>= 1;
  2324. dmabuf->ossmaxfrags >>= 1;
  2325. }
  2326. dmabuf->ready = 0;
  2327. #ifdef DEBUG
  2328. printk("SNDCTL_DSP_SETFRAGMENT 0x%x, %d, %dn", val,
  2329.        dmabuf->ossfragsize, dmabuf->ossmaxfrags);
  2330. #endif
  2331. return 0;
  2332. case SNDCTL_DSP_GETOSPACE:
  2333. if (!(file->f_mode & FMODE_WRITE))
  2334. return -EINVAL;
  2335. if (codec_independent_spdif_locked > 0) {
  2336. if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
  2337. return val;
  2338. } else {
  2339. if (controller_independent_spdif_locked > 0) {
  2340. if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
  2341. return val;
  2342. } else {
  2343. if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
  2344. return val;
  2345. }
  2346. }
  2347. spin_lock_irqsave(&state->card->lock, flags);
  2348. ali_update_ptr(state);
  2349. abinfo.fragsize = dmabuf->userfragsize;
  2350. abinfo.fragstotal = dmabuf->userfrags;
  2351. if (dmabuf->mapped)
  2352. abinfo.bytes = dmabuf->dmasize;
  2353. else
  2354. abinfo.bytes = ali_get_free_write_space(state);
  2355. abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
  2356. spin_unlock_irqrestore(&state->card->lock, flags);
  2357. #if defined(DEBUG) || defined(DEBUG_MMAP)
  2358. printk("SNDCTL_DSP_GETOSPACE %d, %d, %d, %dn",
  2359.        abinfo.bytes, abinfo.fragsize, abinfo.fragments,
  2360.        abinfo.fragstotal);
  2361. #endif
  2362. return copy_to_user((void *) arg, &abinfo,
  2363.     sizeof(abinfo)) ? -EFAULT : 0;
  2364. case SNDCTL_DSP_GETOPTR:
  2365. if (!(file->f_mode & FMODE_WRITE))
  2366. return -EINVAL;
  2367. if (codec_independent_spdif_locked > 0) {
  2368. if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
  2369. return val;
  2370. } else {
  2371. if (controller_independent_spdif_locked > 0) {
  2372. if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
  2373. return val;
  2374. } else {
  2375. if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
  2376. return val;
  2377. }
  2378. }
  2379. spin_lock_irqsave(&state->card->lock, flags);
  2380. val = ali_get_free_write_space(state);
  2381. cinfo.bytes = dmabuf->total_bytes;
  2382. cinfo.ptr = dmabuf->hwptr;
  2383. cinfo.blocks = val / dmabuf->userfragsize;
  2384. if (codec_independent_spdif_locked > 0) {
  2385. if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
  2386. dmabuf->count += val;
  2387. dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
  2388. __ali_update_lvi(state, 2);
  2389. }
  2390. } else {
  2391. if (controller_independent_spdif_locked > 0) {
  2392. if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
  2393. dmabuf->count += val;
  2394. dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
  2395. __ali_update_lvi(state, 3);
  2396. }
  2397. } else {
  2398. if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
  2399. dmabuf->count += val;
  2400. dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
  2401. __ali_update_lvi(state, 0);
  2402. }
  2403. }
  2404. }
  2405. spin_unlock_irqrestore(&state->card->lock, flags);
  2406. #if defined(DEBUG) || defined(DEBUG_MMAP)
  2407. printk("SNDCTL_DSP_GETOPTR %d, %d, %d, %dn", cinfo.bytes,
  2408.        cinfo.blocks, cinfo.ptr, dmabuf->count);
  2409. #endif
  2410. return copy_to_user((void *) arg, &cinfo, sizeof(cinfo));
  2411. case SNDCTL_DSP_GETISPACE:
  2412. if (!(file->f_mode & FMODE_READ))
  2413. return -EINVAL;
  2414. if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
  2415. return val;
  2416. spin_lock_irqsave(&state->card->lock, flags);
  2417. abinfo.bytes = ali_get_available_read_data(state);
  2418. abinfo.fragsize = dmabuf->userfragsize;
  2419. abinfo.fragstotal = dmabuf->userfrags;
  2420. abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
  2421. spin_unlock_irqrestore(&state->card->lock, flags);
  2422. #if defined(DEBUG) || defined(DEBUG_MMAP)
  2423. printk("SNDCTL_DSP_GETISPACE %d, %d, %d, %dn",
  2424.        abinfo.bytes, abinfo.fragsize, abinfo.fragments,
  2425.        abinfo.fragstotal);
  2426. #endif
  2427. return copy_to_user((void *) arg, &abinfo,
  2428.     sizeof(abinfo)) ? -EFAULT : 0;
  2429. case SNDCTL_DSP_GETIPTR:
  2430. if (!(file->f_mode & FMODE_READ))
  2431. return -EINVAL;
  2432. if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
  2433. return val;
  2434. spin_lock_irqsave(&state->card->lock, flags);
  2435. val = ali_get_available_read_data(state);
  2436. cinfo.bytes = dmabuf->total_bytes;
  2437. cinfo.blocks = val / dmabuf->userfragsize;
  2438. cinfo.ptr = dmabuf->hwptr;
  2439. if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
  2440. dmabuf->count -= val;
  2441. dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
  2442. __ali_update_lvi(state, 1);
  2443. }
  2444. spin_unlock_irqrestore(&state->card->lock, flags);
  2445. #if defined(DEBUG) || defined(DEBUG_MMAP)
  2446. printk("SNDCTL_DSP_GETIPTR %d, %d, %d, %dn", cinfo.bytes,
  2447.        cinfo.blocks, cinfo.ptr, dmabuf->count);
  2448. #endif
  2449. return copy_to_user((void *) arg, &cinfo, sizeof(cinfo));
  2450. case SNDCTL_DSP_NONBLOCK:
  2451. #ifdef DEBUG
  2452. printk("SNDCTL_DSP_NONBLOCKn");
  2453. #endif
  2454. file->f_flags |= O_NONBLOCK;
  2455. return 0;
  2456. case SNDCTL_DSP_GETCAPS:
  2457. #ifdef DEBUG
  2458. printk("SNDCTL_DSP_GETCAPSn");
  2459. #endif
  2460. return put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
  2461. DSP_CAP_MMAP | DSP_CAP_BIND, (int *) arg);
  2462. case SNDCTL_DSP_GETTRIGGER:
  2463. val = 0;
  2464. #ifdef DEBUG
  2465. printk("SNDCTL_DSP_GETTRIGGER 0x%xn", dmabuf->trigger);
  2466. #endif
  2467. return put_user(dmabuf->trigger, (int *) arg);
  2468. case SNDCTL_DSP_SETTRIGGER:
  2469. if (get_user(val, (int *) arg))
  2470. return -EFAULT;
  2471. #if defined(DEBUG) || defined(DEBUG_MMAP)
  2472. printk("SNDCTL_DSP_SETTRIGGER 0x%xn", val);
  2473. #endif
  2474. if (!(val & PCM_ENABLE_INPUT) && dmabuf->enable == ADC_RUNNING) {
  2475. stop_adc(state);
  2476. }
  2477. if (!(val & PCM_ENABLE_OUTPUT) && dmabuf->enable == DAC_RUNNING) {
  2478. stop_dac(state);
  2479. }
  2480. if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
  2481. stop_spdifout(state);
  2482. }
  2483. if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
  2484. stop_spdifout(state);
  2485. }
  2486. dmabuf->trigger = val;
  2487. if (val & PCM_ENABLE_OUTPUT && !(dmabuf->enable & DAC_RUNNING)) {
  2488. if (!dmabuf->write_channel) {
  2489. dmabuf->ready = 0;
  2490. dmabuf->write_channel = state->card->alloc_pcm_channel(state->card);
  2491. if (!dmabuf->write_channel)
  2492. return -EBUSY;
  2493. }
  2494. if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
  2495. return ret;
  2496. if (dmabuf->mapped) {
  2497. spin_lock_irqsave(&state->card->lock, flags);
  2498. ali_update_ptr(state);
  2499. dmabuf->count = 0;
  2500. dmabuf->swptr = dmabuf->hwptr;
  2501. dmabuf->count = ali_get_free_write_space(state);
  2502. dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
  2503. __ali_update_lvi(state, 0);
  2504. spin_unlock_irqrestore(&state->card->lock,
  2505.        flags);
  2506. } else
  2507. start_dac(state);
  2508. }
  2509. if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CODEC_SPDIFOUT_RUNNING)) {
  2510. if (!dmabuf->codec_spdifout_channel) {
  2511. dmabuf->ready = 0;
  2512. dmabuf->codec_spdifout_channel = state->card->alloc_codec_spdifout_channel(state->card);
  2513. if (!dmabuf->codec_spdifout_channel)
  2514. return -EBUSY;
  2515. }
  2516. if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
  2517. return ret;
  2518. if (dmabuf->mapped) {
  2519. spin_lock_irqsave(&state->card->lock, flags);
  2520. ali_update_ptr(state);
  2521. dmabuf->count = 0;
  2522. dmabuf->swptr = dmabuf->hwptr;
  2523. dmabuf->count = ali_get_free_write_space(state);
  2524. dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
  2525. __ali_update_lvi(state, 2);
  2526. spin_unlock_irqrestore(&state->card->lock,
  2527.        flags);
  2528. } else
  2529. start_spdifout(state);
  2530. }
  2531. if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)) {
  2532. if (!dmabuf->controller_spdifout_channel) {
  2533. dmabuf->ready = 0;
  2534. dmabuf->controller_spdifout_channel = state->card->alloc_controller_spdifout_channel(state->card);
  2535. if (!dmabuf->controller_spdifout_channel)
  2536. return -EBUSY;
  2537. }
  2538. if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
  2539. return ret;
  2540. if (dmabuf->mapped) {
  2541. spin_lock_irqsave(&state->card->lock, flags);
  2542. ali_update_ptr(state);
  2543. dmabuf->count = 0;
  2544. dmabuf->swptr = dmabuf->hwptr;
  2545. dmabuf->count = ali_get_free_write_space(state);
  2546. dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
  2547. __ali_update_lvi(state, 3);
  2548. spin_unlock_irqrestore(&state->card->lock, flags);
  2549. } else
  2550. start_spdifout(state);
  2551. }
  2552. if (val & PCM_ENABLE_INPUT && !(dmabuf->enable & ADC_RUNNING)) {
  2553. if (!dmabuf->read_channel) {
  2554. dmabuf->ready = 0;
  2555. dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card);
  2556. if (!dmabuf->read_channel)
  2557. return -EBUSY;
  2558. }
  2559. if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
  2560. return ret;
  2561. if (dmabuf->mapped) {
  2562. spin_lock_irqsave(&state->card->lock,
  2563.   flags);
  2564. ali_update_ptr(state);
  2565. dmabuf->swptr = dmabuf->hwptr;
  2566. dmabuf->count = 0;
  2567. spin_unlock_irqrestore(&state->card->lock, flags);
  2568. }
  2569. ali_update_lvi(state, 1);
  2570. start_adc(state);
  2571. }
  2572. return 0;
  2573. case SNDCTL_DSP_SETDUPLEX:
  2574. #ifdef DEBUG
  2575. printk("SNDCTL_DSP_SETDUPLEXn");
  2576. #endif
  2577. return -EINVAL;
  2578. case SNDCTL_DSP_GETODELAY:
  2579. if (!(file->f_mode & FMODE_WRITE))
  2580. return -EINVAL;
  2581. spin_lock_irqsave(&state->card->lock, flags);
  2582. ali_update_ptr(state);
  2583. val = dmabuf->count;
  2584. spin_unlock_irqrestore(&state->card->lock, flags);
  2585. #ifdef DEBUG
  2586. printk("SNDCTL_DSP_GETODELAY %dn", dmabuf->count);
  2587. #endif
  2588. return put_user(val, (int *) arg);
  2589. case SOUND_PCM_READ_RATE:
  2590. #ifdef DEBUG
  2591. printk("SOUND_PCM_READ_RATE %dn", dmabuf->rate);
  2592. #endif
  2593. return put_user(dmabuf->rate, (int *) arg);
  2594. case SOUND_PCM_READ_CHANNELS:
  2595. #ifdef DEBUG
  2596. printk("SOUND_PCM_READ_CHANNELSn");
  2597. #endif
  2598. return put_user(2, (int *) arg);
  2599. case SOUND_PCM_READ_BITS:
  2600. #ifdef DEBUG
  2601. printk("SOUND_PCM_READ_BITSn");
  2602. #endif
  2603. return put_user(AFMT_S16_LE, (int *) arg);
  2604. case SNDCTL_DSP_SETSPDIF: /* Set S/PDIF Control register */
  2605. #ifdef DEBUG
  2606. printk("SNDCTL_DSP_SETSPDIFn");
  2607. #endif
  2608. if (get_user(val, (int *) arg))
  2609. return -EFAULT;
  2610. /* Check to make sure the codec supports S/PDIF transmitter */
  2611. if ((state->card->ac97_features & 4)) {
  2612. /* mask out the transmitter speed bits so the user can't set them */
  2613. val &= ~0x3000;
  2614. /* Add the current transmitter speed bits to the passed value */
  2615. ret = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
  2616. val |= (ret & 0x3000);
  2617. ali_ac97_set(codec, AC97_SPDIF_CONTROL, val);
  2618. if (ali_ac97_get(codec, AC97_SPDIF_CONTROL) != val) {
  2619. printk(KERN_ERR "ali_audio: Unable to set S/PDIF configuration to 0x%04x.n", val);
  2620. return -EFAULT;
  2621. }
  2622. }
  2623. #ifdef DEBUG
  2624. else
  2625. printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.n");
  2626. #endif
  2627. return put_user(val, (int *) arg);
  2628. case SNDCTL_DSP_GETSPDIF: /* Get S/PDIF Control register */
  2629. #ifdef DEBUG
  2630. printk("SNDCTL_DSP_GETSPDIFn");
  2631. #endif
  2632. if (get_user(val, (int *) arg))
  2633. return -EFAULT;
  2634. /* Check to make sure the codec supports S/PDIF transmitter */
  2635. if (!(state->card->ac97_features & 4)) {
  2636. #ifdef DEBUG
  2637. printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.n");
  2638. #endif
  2639. val = 0;
  2640. } else {
  2641. val = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
  2642. }
  2644. return put_user(val, (int *) arg);
  2645. //end add support spdif out
  2646. //add support 4,6 channel
  2647. case SNDCTL_DSP_GETCHANNELMASK:
  2648. #ifdef DEBUG
  2649. printk("SNDCTL_DSP_GETCHANNELMASKn");
  2650. #endif
  2651. if (get_user(val, (int *) arg))
  2652. return -EFAULT;
  2653. /* Based on AC'97 DAC support, not ICH hardware */
  2654. val = DSP_BIND_FRONT;
  2655. if (state->card->ac97_features & 0x0004)
  2656. val |= DSP_BIND_SPDIF;
  2657. if (state->card->ac97_features & 0x0080)
  2658. val |= DSP_BIND_SURR;
  2659. if (state->card->ac97_features & 0x0140)
  2660. val |= DSP_BIND_CENTER_LFE;
  2661. return put_user(val, (int *) arg);
  2662. case SNDCTL_DSP_BIND_CHANNEL:
  2663. #ifdef DEBUG
  2664. printk("SNDCTL_DSP_BIND_CHANNELn");
  2665. #endif
  2666. if (get_user(val, (int *) arg))
  2667. return -EFAULT;
  2668. if (val == DSP_BIND_QUERY) {
  2669. val = DSP_BIND_FRONT; /* Always report this as being enabled */
  2670. if (state->card->ac97_status & SPDIF_ON)
  2671. val |= DSP_BIND_SPDIF;
  2672. else {
  2673. if (state->card->ac97_status & SURR_ON)
  2674. val |= DSP_BIND_SURR;
  2675. if (state->card->
  2676.     ac97_status & CENTER_LFE_ON)
  2677. val |= DSP_BIND_CENTER_LFE;
  2678. }
  2679. } else { /* Not a query, set it */
  2680. if (!(file->f_mode & FMODE_WRITE))
  2681. return -EINVAL;
  2682. if (dmabuf->enable == DAC_RUNNING) {
  2683. stop_dac(state);
  2684. }
  2685. if (val & DSP_BIND_SPDIF) { /* Turn on SPDIF */
  2686. /*  Ok, this should probably define what slots
  2687.  *  to use. For now, we'll only set it to the
  2688.  *  defaults:
  2689.  * 
  2690.  *   non multichannel codec maps to slots 3&4
  2691.  *   2 channel codec maps to slots 7&8
  2692.  *   4 channel codec maps to slots 6&9
  2693.  *   6 channel codec maps to slots 10&11
  2694.  *
  2695.  *  there should be some way for the app to
  2696.  *  select the slot assignment.
  2697.  */
  2698. i_scr = inl(state->card->iobase + ALI_SCR);
  2699. if (codec_independent_spdif_locked > 0) {
  2701. if ((i_scr & 0x00300000) == 0x00100000) {
  2702. ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
  2703. } else {
  2704. if ((i_scr & 0x00300000) == 0x00200000) {
  2705. ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
  2706. } else {
  2707. if ((i_scr & 0x00300000) == 0x00300000) {
  2708. ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
  2709. }
  2710. }
  2711. }
  2712. } else { /* codec spdif out (pcm out share ) */
  2713. ali_set_spdif_output(state, AC97_EA_SPSA_3_4, dmabuf->rate); //I do not modify
  2714. }
  2716. if (!(state->card->ac97_status & SPDIF_ON))
  2717. val &= ~DSP_BIND_SPDIF;
  2718. } else {
  2719. int mask;
  2720. int channels;
  2721. /* Turn off S/PDIF if it was on */
  2722. if (state->card->ac97_status & SPDIF_ON)
  2723. ali_set_spdif_output(state, -1, 0);
  2724. mask =
  2725.     val & (DSP_BIND_FRONT | DSP_BIND_SURR |
  2726.    DSP_BIND_CENTER_LFE);
  2727. switch (mask) {
  2728. case DSP_BIND_FRONT:
  2729. channels = 2;
  2730. break;
  2731. case DSP_BIND_FRONT | DSP_BIND_SURR:
  2732. channels = 4;
  2733. break;
  2734. case DSP_BIND_FRONT | DSP_BIND_SURR | DSP_BIND_CENTER_LFE:
  2735. channels = 6;
  2736. break;
  2737. default:
  2738. val = DSP_BIND_FRONT;
  2739. channels = 2;
  2740. break;
  2741. }
  2742. ali_set_dac_channels(state, channels);
  2743. /* check that they really got turned on */
  2744. if (!state->card->ac97_status & SURR_ON)
  2745. val &= ~DSP_BIND_SURR;
  2746. if (!state->card->
  2747.     ac97_status & CENTER_LFE_ON)
  2748. val &= ~DSP_BIND_CENTER_LFE;
  2749. }
  2750. }
  2751. return put_user(val, (int *) arg);
  2752. case SNDCTL_DSP_MAPINBUF:
  2753. case SNDCTL_DSP_MAPOUTBUF:
  2754. case SNDCTL_DSP_SETSYNCRO:
  2755. case SOUND_PCM_WRITE_FILTER:
  2756. case SOUND_PCM_READ_FILTER:
  2757. return -EINVAL;
  2758. }
  2759. return -EINVAL;
  2760. }
  2762. static int ali_open(struct inode *inode, struct file *file)
  2763. {
  2764. int i = 0;
  2765. struct ali_card *card = devs;
  2766. struct ali_state *state = NULL;
  2767. struct dmabuf *dmabuf = NULL;
  2768. unsigned int i_scr;
  2770. /* find an available virtual channel (instance of /dev/dsp) */
  2772. while (card != NULL) {
  2774. /*
  2775.  * If we are initializing and then fail, card could go
  2776.  * away unuexpectedly while we are in the for() loop.
  2777.  * So, check for card on each iteration before we check
  2778.  * for card->initializing to avoid a possible oops.
  2779.  * This usually only matters for times when the driver is
  2780.  * autoloaded by kmod.
  2781.  */
  2782. for (i = 0; i < 50 && card && card->initializing; i++) {
  2783. set_current_state(TASK_UNINTERRUPTIBLE);
  2784. schedule_timeout(HZ / 20);
  2785. }
  2787. for (i = 0; i < NR_HW_CH && card && !card->initializing; i++) {
  2788. if (card->states[i] == NULL) {
  2789. state = card->states[i] = (struct ali_state *) kmalloc(sizeof(struct ali_state), GFP_KERNEL);
  2790. if (state == NULL)
  2791. return -ENOMEM;
  2792. memset(state, 0, sizeof(struct ali_state));
  2793. dmabuf = &state->dmabuf;
  2794. goto found_virt;
  2795. }
  2796. }
  2797. card = card->next;
  2798. }
  2800. /* no more virtual channel avaiable */
  2801. if (!state)
  2802. return -ENODEV;
  2803. found_virt:
  2804. /* initialize the virtual channel */
  2806. state->virt = i;
  2807. state->card = card;
  2808. state->magic = ALI5455_STATE_MAGIC;
  2809. init_waitqueue_head(&dmabuf->wait);
  2810. init_MUTEX(&state->open_sem);
  2811. file->private_data = state;
  2812. dmabuf->trigger = 0;
  2813. /* allocate hardware channels */
  2814. if (file->f_mode & FMODE_READ) {
  2815. if ((dmabuf->read_channel =
  2816.      card->alloc_rec_pcm_channel(card)) == NULL) {
  2817. kfree(card->states[i]);
  2818. card->states[i] = NULL;
  2819. return -EBUSY;
  2820. }
  2821. dmabuf->trigger |= PCM_ENABLE_INPUT;
  2822. ali_set_adc_rate(state, 8000);
  2823. }
  2824. if (file->f_mode & FMODE_WRITE) {
  2825. if (codec_independent_spdif_locked > 0) {
  2826. if ((dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card)) == NULL) {
  2827. kfree(card->states[i]);
  2828. card->states[i] = NULL;
  2829. return -EBUSY;
  2830. }
  2831. dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
  2832. ali_set_codecspdifout_rate(state, codec_independent_spdif_locked); //It must add
  2833. i_scr = inl(state->card->iobase + ALI_SCR);
  2834. if ((i_scr & 0x00300000) == 0x00100000) {
  2835. ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
  2836. } else {
  2837. if ((i_scr & 0x00300000) == 0x00200000) {
  2838. ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
  2839. } else {
  2840. if ((i_scr & 0x00300000) == 0x00300000) {
  2841. ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
  2842. } else {
  2843. ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
  2844. }
  2845. }
  2847. }
  2848. } else {
  2849. if (controller_independent_spdif_locked > 0) {
  2850. if ((dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card)) == NULL) {
  2851. kfree(card->states[i]);
  2852. card->states[i] = NULL;
  2853. return -EBUSY;
  2854. }
  2855. dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
  2856. ali_set_spdifout_rate(state, controller_independent_spdif_locked);
  2857. } else {
  2858. if ((dmabuf->write_channel = card->alloc_pcm_channel(card)) == NULL) {
  2859. kfree(card->states[i]);
  2860. card->states[i] = NULL;
  2861. return -EBUSY;
  2862. }
  2863. /* Initialize to 8kHz?  What if we don't support 8kHz? */
  2864. /*  Let's change this to check for S/PDIF stuff */
  2866. dmabuf->trigger |= PCM_ENABLE_OUTPUT;
  2867. if (codec_pcmout_share_spdif_locked) {
  2868. ali_set_dac_rate(state, codec_pcmout_share_spdif_locked);
  2869. ali_set_spdif_output(state, AC97_EA_SPSA_3_4, codec_pcmout_share_spdif_locked);
  2870. } else {
  2871. ali_set_dac_rate(state, 8000);
  2872. }
  2873. }
  2875. }
  2876. }
  2878. /* set default sample format. According to OSS Programmer's Guide  /dev/dsp
  2879.    should be default to unsigned 8-bits, mono, with sample rate 8kHz and
  2880.    /dev/dspW will accept 16-bits sample, but we don't support those so we
  2881.    set it immediately to stereo and 16bit, which is all we do support */
  2882. dmabuf->fmt |= ALI5455_FMT_16BIT | ALI5455_FMT_STEREO;
  2883. dmabuf->ossfragsize = 0;
  2884. dmabuf->ossmaxfrags = 0;
  2885. dmabuf->subdivision = 0;
  2886. state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
  2887. outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
  2888. outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
  2889. return 0;
  2890. }
  2892. static int ali_release(struct inode *inode, struct file *file)
  2893. {
  2894. struct ali_state *state = (struct ali_state *) file->private_data;
  2895. struct ali_card *card = state->card;
  2896. struct dmabuf *dmabuf = &state->dmabuf;
  2897. unsigned long flags;
  2898. lock_kernel();
  2900. /* stop DMA state machine and free DMA buffers/channels */
  2901. if (dmabuf->trigger & PCM_ENABLE_OUTPUT)
  2902. drain_dac(state, 0);
  2904. if (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)
  2905. drain_spdifout(state, 0);
  2907. if (dmabuf->trigger & PCM_ENABLE_INPUT)
  2908. stop_adc(state);
  2910. spin_lock_irqsave(&card->lock, flags);
  2911. dealloc_dmabuf(state);
  2912. if (file->f_mode & FMODE_WRITE) {
  2913. if (codec_independent_spdif_locked > 0) {
  2914. state->card->free_pcm_channel(state->card, dmabuf->codec_spdifout_channel->num);
  2915. } else {
  2916. if (controller_independent_spdif_locked > 0)
  2917. state->card->free_pcm_channel(state->card,
  2918.       dmabuf->controller_spdifout_channel->num);
  2919. else state->card->free_pcm_channel(state->card,
  2920.       dmabuf->write_channel->num);
  2921. }
  2922. }
  2923. if (file->f_mode & FMODE_READ)
  2924. state->card->free_pcm_channel(state->card, dmabuf->read_channel->num);
  2926. state->card->states[state->virt] = NULL;
  2927. kfree(state);
  2928. spin_unlock_irqrestore(&card->lock, flags);
  2929. unlock_kernel();
  2930. return 0;
  2931. }
  2933. static /*const */ struct file_operations ali_audio_fops = {
  2934. owner:THIS_MODULE, 
  2935. llseek:no_llseek, 
  2936. read:ali_read,
  2937. write:ali_write, 
  2938. poll:ali_poll,
  2939. ioctl:ali_ioctl,
  2940. mmap:ali_mmap,
  2941. open:ali_open,
  2942. release:ali_release,
  2943. };
  2945. /* Read AC97 codec registers */
  2946. static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg)
  2947. {
  2948. struct ali_card *card = dev->private_data;
  2949. int count1 = 100;
  2950. char val;
  2951. unsigned short int data, count, addr1, addr2;
  2953. while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
  2954. udelay(1);
  2956. addr1 = reg;
  2957. reg |= 0x0080;
  2958. for (count = 0; count < 0x7f; count++) {
  2959. val = inb(card->iobase + ALI_CSPSR);
  2960. if (val & 0x08)
  2961. break;
  2962. }
  2963. if (count == 0x7f)
  2964. return -1;
  2965. outw(reg, (card->iobase + ALI_CPR) + 2);
  2966. for (count = 0; count < 0x7f; count++) {
  2967. val = inb(card->iobase + ALI_CSPSR);
  2968. if (val & 0x02) {
  2969. data = inw(card->iobase + ALI_SPR);
  2970. addr2 = inw((card->iobase + ALI_SPR) + 2);
  2971. break;
  2972. }
  2973. }
  2974. if (count == 0x7f)
  2975. return -1;
  2976. if (addr2 != addr1)
  2977. return -1;
  2978. return ((u16) data);
  2979. }
  2981. /* write ac97 codec register   */
  2983. static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data)
  2984. {
  2985. struct ali_card *card = dev->private_data;
  2986. int count1 = 100;
  2987. unsigned long flags;
  2988. char val;
  2989. unsigned short int count;
  2991. while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
  2992. udelay(1);
  2994. for (count = 0; count < 0x7f; count++) {
  2995. val = inb(card->iobase + ALI_CSPSR);
  2996. if (val & 0x08)
  2997. break;
  2998. }
  2999. if (count == 0x7f) {
  3000. printk(KERN_WARNING "ali_ac96_set: AC97 codec register access timed out. n");
  3001. return;
  3002. }
  3003. outw(data, (card->iobase + ALI_CPR));
  3004. outb(reg, (card->iobase + ALI_CPR) + 2);
  3005. for (count = 0; count < 0x7f; count++) {
  3006. val = inb(card->iobase + ALI_CSPSR);
  3007. if (val & 0x01)
  3008. break;
  3009. }
  3010. if (count == 0x7f) {
  3011. printk(KERN_WARNING "ali_ac96_set: AC97 codec register access timed out. n");
  3012. return;
  3013. }
  3014. return;
  3015. }
  3017. /* OSS /dev/mixer file operation methods */
  3019. static int ali_open_mixdev(struct inode *inode, struct file *file)
  3020. {
  3021. int i;
  3022. int minor = MINOR(inode->i_rdev);
  3023. struct ali_card *card = devs;
  3024. for (card = devs; card != NULL; card = card->next) {
  3025. /*
  3026.  * If we are initializing and then fail, card could go
  3027.  * away unuexpectedly while we are in the for() loop.
  3028.  * So, check for card on each iteration before we check
  3029.  * for card->initializing to avoid a possible oops.
  3030.  * This usually only matters for times when the driver is
  3031.  * autoloaded by kmod.
  3032.  */
  3033. for (i = 0; i < 50 && card && card->initializing; i++) {
  3034. set_current_state(TASK_UNINTERRUPTIBLE);
  3035. schedule_timeout(HZ / 20);
  3036. }
  3037. for (i = 0; i < NR_AC97 && card && !card->initializing; i++)
  3038. if (card->ac97_codec[i] != NULL
  3039.     && card->ac97_codec[i]->dev_mixer == minor) {
  3040. file->private_data = card->ac97_codec[i];
  3041. return 0;
  3042. }
  3043. }
  3044. return -ENODEV;
  3045. }
  3047. static int ali_ioctl_mixdev(struct inode *inode,
  3048.     struct file *file,
  3049.     unsigned int cmd, unsigned long arg)
  3050. {
  3051. struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
  3052. return codec->mixer_ioctl(codec, cmd, arg);
  3053. }
  3055. static /*const */ struct file_operations ali_mixer_fops = {
  3056. owner:THIS_MODULE, 
  3057. llseek:no_llseek, 
  3058. ioctl:ali_ioctl_mixdev,
  3059. open:ali_open_mixdev,
  3060. };
  3062. /* AC97 codec initialisation.  These small functions exist so we don't
  3063.    duplicate code between module init and apm resume */
  3065. static inline int ali_ac97_exists(struct ali_card *card, int ac97_number)
  3066. {
  3067. unsigned int i = 1;
  3068. u32 reg = inl(card->iobase + ALI_RTSR);
  3069. if (ac97_number) {
  3070. while (i < 100) {
  3072. reg = inl(card->iobase + ALI_RTSR);
  3073. if (reg & 0x40) {
  3074. break;
  3075. } else {
  3076. outl(reg | 0x00000040,
  3077.      card->iobase + 0x34);
  3078. udelay(1);
  3079. }
  3080. i++;
  3081. }
  3083. } else {
  3084. while (i < 100) {
  3085. reg = inl(card->iobase + ALI_RTSR);
  3086. if (reg & 0x80) {
  3087. break;
  3088. } else {
  3089. outl(reg | 0x00000080,
  3090.      card->iobase + 0x34);
  3091. udelay(1);
  3092. }
  3093. i++;
  3094. }
  3095. }
  3097. if (ac97_number)
  3098. return reg & 0x40;
  3099. else
  3100. return reg & 0x80;
  3101. }
  3103. static inline int ali_ac97_enable_variable_rate(struct ac97_codec *codec)
  3104. {
  3105. ali_ac97_set(codec, AC97_EXTENDED_STATUS, 9);
  3106. ali_ac97_set(codec, AC97_EXTENDED_STATUS, ali_ac97_get(codec, AC97_EXTENDED_STATUS) | 0xE800);
  3107. return (ali_ac97_get(codec, AC97_EXTENDED_STATUS) & 1);
  3108. }
  3111. static int ali_ac97_probe_and_powerup(struct ali_card *card, struct ac97_codec *codec)
  3112. {
  3113. /* Returns 0 on failure */
  3114. int i;
  3115. u16 addr;
  3116. if (ac97_probe_codec(codec) == 0)
  3117. return 0;
  3118. /* ac97_probe_codec is success ,then begin to init codec */
  3119. ali_ac97_set(codec, AC97_RESET, 0xffff);
  3120. if (card->channel[0].used == 1) {
  3121. ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
  3122. ali_ac97_set(codec, AC97_LINEIN_VOL, 0x0808);
  3123. ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
  3124. }
  3126. if (card->channel[2].used == 1) //if MICin then init codec
  3127. {
  3128. ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
  3129. ali_ac97_set(codec, AC97_MIC_VOL, 0x8808);
  3130. ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
  3131. ali_ac97_set(codec, AC97_RECORD_GAIN_MIC, 0x0000);
  3132. }
  3134. ali_ac97_set(codec, AC97_MASTER_VOL_STEREO, 0x0000);
  3135. ali_ac97_set(codec, AC97_HEADPHONE_VOL, 0x0000);
  3136. ali_ac97_set(codec, AC97_PCMOUT_VOL, 0x0000);
  3137. ali_ac97_set(codec, AC97_CD_VOL, 0x0808);
  3138. ali_ac97_set(codec, AC97_VIDEO_VOL, 0x0808);
  3139. ali_ac97_set(codec, AC97_AUX_VOL, 0x0808);
  3140. ali_ac97_set(codec, AC97_PHONE_VOL, 0x8048);
  3141. ali_ac97_set(codec, AC97_PCBEEP_VOL, 0x0000);
  3142. ali_ac97_set(codec, AC97_GENERAL_PURPOSE, AC97_GP_MIX);
  3143. ali_ac97_set(codec, AC97_MASTER_VOL_MONO, 0x0000);
  3144. ali_ac97_set(codec, 0x38, 0x0000);
  3145. addr = ali_ac97_get(codec, 0x2a);
  3146. ali_ac97_set(codec, 0x2a, addr | 0x0001);
  3147. addr = ali_ac97_get(codec, 0x2a);
  3148. addr = ali_ac97_get(codec, 0x28);
  3149. ali_ac97_set(codec, 0x2c, 0xbb80);
  3150. addr = ali_ac97_get(codec, 0x2c);
  3151. /* power it all up */
  3152. ali_ac97_set(codec, AC97_POWER_CONTROL,
  3153.      ali_ac97_get(codec, AC97_POWER_CONTROL) & ~0x7f00);
  3154. /* wait for analog ready */
  3155. for (i = 10; i && ((ali_ac97_get(codec, AC97_POWER_CONTROL) & 0xf) != 0xf); i--) {
  3156. set_current_state(TASK_UNINTERRUPTIBLE);
  3157. schedule_timeout(HZ / 20);
  3158. }
  3159. /* FIXME !! */
  3160. i++;
  3161. return i;
  3162. }
  3165. /* I clone ali5455(2.4.7 )  not clone i810_audio(2.4.18)  */
  3167. static int ali_reset_5455(struct ali_card *card)
  3168. {
  3169. outl(0x80000003, card->iobase + ALI_SCR);
  3170. outl(0x83838383, card->iobase + ALI_FIFOCR1);
  3171. outl(0x83838383, card->iobase + ALI_FIFOCR2);
  3172. if (controller_pcmout_share_spdif_locked > 0) {
  3173. outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
  3174.      card->iobase + ALI_SPDIFICS);
  3175. outl(0x0408000a, card->iobase + ALI_INTERFACECR);
  3176. } else {
  3177. if (codec_independent_spdif_locked > 0) {
  3178. outl((inl(card->iobase + ALI_SCR) | 0x00100000), card->iobase + ALI_SCR); // now I select slot 7 & 8
  3179. outl(0x00200000, card->iobase + ALI_INTERFACECR); //enable codec independent spdifout 
  3180. } else
  3181. outl(0x04080002, card->iobase + ALI_INTERFACECR);
  3182. }
  3184. outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
  3185. outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
  3186. if (controller_independent_spdif_locked > 0)
  3187. outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
  3188.      card->iobase + ALI_SPDIFICS);
  3189. return 1;
  3190. }
  3193. static int ali_ac97_random_init_stuff(struct ali_card
  3194.       *card)
  3195. {
  3196. u32 reg = inl(card->iobase + ALI_SCR);
  3197. int i = 0;
  3198. reg = inl(card->iobase + ALI_SCR);
  3199. if ((reg & 2) == 0) /* Cold required */
  3200. reg |= 2;
  3201. else
  3202. reg |= 1; /* Warm */
  3203. reg &= ~0x80000000; /* ACLink on */
  3204. outl(reg, card->iobase + ALI_SCR);
  3206. while (i < 10) {
  3207. if ((inl(card->iobase + 0x18) & (1 << 1)) == 0)
  3208. break;
  3209. current->state = TASK_UNINTERRUPTIBLE;
  3210. schedule_timeout(HZ / 20);
  3211. i++;
  3212. }
  3213. if (i == 10) {
  3214. printk(KERN_ERR "ali_audio: AC'97 reset failed.n");
  3215. return 0;
  3216. }
  3218. set_current_state(TASK_UNINTERRUPTIBLE);
  3219. schedule_timeout(HZ / 2);
  3220. return 1;
  3221. }
  3223. /* AC97 codec initialisation. */
  3225. static int __init ali_ac97_init(struct ali_card *card)
  3226. {
  3227. int num_ac97 = 0;
  3228. int total_channels = 0;
  3229. struct ac97_codec *codec;
  3230. u16 eid;
  3232. if (!ali_ac97_random_init_stuff(card))
  3233. return 0;
  3235. /* Number of channels supported */
  3236. /* What about the codec?  Just because the ICH supports */
  3237. /* multiple channels doesn't mean the codec does.       */
  3238. /* we'll have to modify this in the codec section below */
  3239. /* to reflect what the codec has.                       */
  3240. /* ICH and ICH0 only support 2 channels so don't bother */
  3241. /* to check....                                         */
  3242. inl(card->iobase + ALI_CPR);
  3243. card->channels = 2;
  3245. for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
  3247. /* Assume codec isn't available until we go through the
  3248.  * gauntlet below */
  3249. card->ac97_codec[num_ac97] = NULL;
  3250. /* The ICH programmer's reference says you should   */
  3251. /* check the ready status before probing. So we chk */
  3252. /*   What do we do if it's not ready?  Wait and try */
  3253. /*   again, or abort?                               */
  3254. if (!ali_ac97_exists(card, num_ac97)) {
  3255. if (num_ac97 == 0)
  3256. printk(KERN_ERR "ali_audio: Primary codec not ready.n");
  3257. break;
  3258. }
  3260. if ((codec = kmalloc(sizeof(struct ac97_codec), GFP_KERNEL)) == NULL)
  3261. return -ENOMEM;
  3262. memset(codec, 0, sizeof(struct ac97_codec));
  3263. /* initialize some basic codec information, other fields will be filled
  3264.    in ac97_probe_codec */
  3265. codec->private_data = card;
  3266. codec->id = num_ac97;
  3267. codec->codec_read = ali_ac97_get;
  3268. codec->codec_write = ali_ac97_set;
  3269. if (!ali_ac97_probe_and_powerup(card, codec)) {
  3270. printk(KERN_ERR "ali_audio: timed out waiting for codec %d analog ready",
  3271.      num_ac97);
  3272. kfree(codec);
  3273. break; /* it didn't work */
  3274. }
  3276. /* Store state information about S/PDIF transmitter */
  3277. card->ac97_status = 0;
  3278. /* Don't attempt to get eid until powerup is complete */
  3279. eid = ali_ac97_get(codec, AC97_EXTENDED_ID);
  3280. if (eid == 0xFFFFFF) {
  3281. printk(KERN_ERR "ali_audio: no codec attached ?n");
  3282. kfree(codec);
  3283. break;
  3284. }
  3286. card->ac97_features = eid;
  3287. /* Now check the codec for useful features to make up for
  3288.    the dumbness of the ali5455 hardware engine */
  3289. if (!(eid & 0x0001))
  3290. printk(KERN_WARNING
  3291.        "ali_audio: only 48Khz playback available.n");
  3292. else {
  3293. if (!ali_ac97_enable_variable_rate(codec)) {
  3294. printk(KERN_WARNING
  3295.        "ali_audio: Codec refused to allow VRA, using 48Khz only.n");
  3296. card->ac97_features &= ~1;
  3297. }
  3298. }
  3300. /* Determine how many channels the codec(s) support   */
  3301. /*   - The primary codec always supports 2            */
  3302. /*   - If the codec supports AMAP, surround DACs will */
  3303. /*     automaticlly get assigned to slots.            */
  3304. /*     * Check for surround DACs and increment if     */
  3305. /*       found.                                       */
  3306. /*   - Else check if the codec is revision 2.2        */
  3307. /*     * If surround DACs exist, assign them to slots */
  3308. /*       and increment channel count.                 */
  3310. /* All of this only applies to ICH2 and above. ICH    */
  3311. /* and ICH0 only support 2 channels.  ICH2 will only  */
  3312. /* support multiple codecs in a "split audio" config. */
  3313. /* as described above.                                */
  3315. /* TODO: Remove all the debugging messages!           */
  3317. if ((eid & 0xc000) == 0) /* primary codec */
  3318. total_channels += 2;
  3319. if ((codec->dev_mixer = register_sound_mixer(&ali_mixer_fops, -1)) < 0) {
  3320. printk(KERN_ERR "ali_audio: couldn't register mixer!n");
  3321. kfree(codec);
  3322. break;
  3323. }
  3324. card->ac97_codec[num_ac97] = codec;
  3325. }
  3326. /* pick the minimum of channels supported by ICHx or codec(s) */
  3327. card->channels = (card->channels > total_channels) ? total_channels : card->channels;
  3328. return num_ac97;
  3329. }
  3331. static void __init ali_configure_clocking(void)
  3332. {
  3333. struct ali_card *card;
  3334. struct ali_state *state;
  3335. struct dmabuf *dmabuf;
  3336. unsigned int i, offset, new_offset;
  3337. unsigned long flags;
  3338. card = devs;
  3340. /* We could try to set the clocking for multiple cards, but can you even have
  3341.  * more than one ali in a machine?  Besides, clocking is global, so unless
  3342.  * someone actually thinks more than one ali in a machine is possible and
  3343.  * decides to rewrite that little bit, setting the rate for more than one card
  3344.  * is a waste of time.
  3345.  */
  3346. if (card != NULL) {
  3347. state = card->states[0] = (struct ali_state *)
  3348.     kmalloc(sizeof(struct ali_state), GFP_KERNEL);
  3349. if (state == NULL)
  3350. return;
  3351. memset(state, 0, sizeof(struct ali_state));
  3352. dmabuf = &state->dmabuf;
  3353. dmabuf->write_channel = card->alloc_pcm_channel(card);
  3354. state->virt = 0;
  3355. state->card = card;
  3356. state->magic = ALI5455_STATE_MAGIC;
  3357. init_waitqueue_head(&dmabuf->wait);
  3358. init_MUTEX(&state->open_sem);
  3359. dmabuf->fmt = ALI5455_FMT_STEREO | ALI5455_FMT_16BIT;
  3360. dmabuf->trigger = PCM_ENABLE_OUTPUT;
  3361. ali_set_dac_rate(state, 48000);
  3362. if (prog_dmabuf(state, 0) != 0)
  3363. goto config_out_nodmabuf;
  3365. if (dmabuf->dmasize < 16384)
  3366. goto config_out;
  3368. dmabuf->count = dmabuf->dmasize;
  3369. outb(31, card->iobase + dmabuf->write_channel->port + OFF_LVI);
  3371. save_flags(flags);
  3372. cli();
  3373. start_dac(state);
  3374. offset = ali_get_dma_addr(state, 0);
  3375. mdelay(50);
  3376. new_offset = ali_get_dma_addr(state, 0);
  3377. stop_dac(state);
  3379. outb(2, card->iobase + dmabuf->write_channel->port + OFF_CR);
  3380. restore_flags(flags);
  3382. i = new_offset - offset;
  3384. if (i == 0)
  3385. goto config_out;
  3386. i = i / 4 * 20;
  3387. if (i > 48500 || i < 47500) {
  3388. clocking = clocking * clocking / i;
  3389. }
  3390. config_out:
  3391. dealloc_dmabuf(state);
  3392. config_out_nodmabuf:
  3393. state->card->free_pcm_channel(state->card, state->dmabuf. write_channel->num);
  3394. kfree(state);
  3395. card->states[0] = NULL;
  3396. }
  3397. }
  3399. /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered 
  3400.    until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
  3402. static int __init ali_probe(struct pci_dev *pci_dev, const struct pci_device_id
  3403.     *pci_id)
  3404. {
  3405. struct ali_card *card;
  3406. if (pci_enable_device(pci_dev))
  3407. return -EIO;
  3408. if (pci_set_dma_mask(pci_dev, ALI5455_DMA_MASK)) {
  3409. printk(KERN_ERR "ali5455: architecture does not support"
  3410.        " 32bit PCI busmaster DMAn");
  3411. return -ENODEV;
  3412. }
  3414. if ((card = kmalloc(sizeof(struct ali_card), GFP_KERNEL)) == NULL) {
  3415. printk(KERN_ERR "ali_audio: out of memoryn");
  3416. return -ENOMEM;
  3417. }
  3418. memset(card, 0, sizeof(*card));
  3419. card->initializing = 1;
  3420. card->iobase = pci_resource_start(pci_dev, 0);
  3421. card->pci_dev = pci_dev;
  3422. card->pci_id = pci_id->device;
  3423. card->irq = pci_dev->irq;
  3424. card->next = devs;
  3425. card->magic = ALI5455_CARD_MAGIC;
  3426. #ifdef CONFIG_PM
  3427. card->pm_suspended = 0;
  3428. #endif
  3429. spin_lock_init(&card->lock);
  3430. devs = card;
  3431. pci_set_master(pci_dev);
  3432. printk(KERN_INFO "ali: %s found at IO 0x%04lx, IRQ %dn",
  3433.        card_names[pci_id->driver_data], card->iobase, card->irq);
  3434. card->alloc_pcm_channel = ali_alloc_pcm_channel;
  3435. card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
  3436. card->alloc_rec_mic_channel = ali_alloc_rec_mic_channel;
  3437. card->alloc_codec_spdifout_channel = ali_alloc_codec_spdifout_channel;
  3438. card->alloc_controller_spdifout_channel = ali_alloc_controller_spdifout_channel;
  3439. card->free_pcm_channel = ali_free_pcm_channel;
  3440. card->channel[0].offset = 0;
  3441. card->channel[0].port = 0x40;
  3442. card->channel[0].num = 0;
  3443. card->channel[1].offset = 0;
  3444. card->channel[1].port = 0x50;
  3445. card->channel[1].num = 1;
  3446. card->channel[2].offset = 0;
  3447. card->channel[2].port = 0x60;
  3448. card->channel[2].num = 2;
  3449. card->channel[3].offset = 0;
  3450. card->channel[3].port = 0x70;
  3451. card->channel[3].num = 3;
  3452. card->channel[4].offset = 0;
  3453. card->channel[4].port = 0xb0;
  3454. card->channel[4].num = 4;
  3455. /* claim our iospace and irq */
  3456. request_region(card->iobase, 256, card_names[pci_id->driver_data]);
  3457. if (request_irq(card->irq, &ali_interrupt, SA_SHIRQ,
  3458. card_names[pci_id->driver_data], card)) {
  3459. printk(KERN_ERR "ali_audio: unable to allocate irq %dn",
  3460.        card->irq);
  3461. release_region(card->iobase, 256);
  3462. kfree(card);
  3463. return -ENODEV;
  3464. }
  3466. if (ali_reset_5455(card) <= 0) {
  3467. unregister_sound_dsp(card->dev_audio);
  3468. release_region(card->iobase, 256);
  3469. free_irq(card->irq, card);
  3470. kfree(card);
  3471. return -ENODEV;
  3472. }
  3474. /* initialize AC97 codec and register /dev/mixer */
  3475. if (ali_ac97_init(card) < 0) {
  3476. release_region(card->iobase, 256);
  3477. free_irq(card->irq, card);
  3478. kfree(card);
  3479. return -ENODEV;
  3480. }
  3482. pci_set_drvdata(pci_dev, card);
  3484. if (clocking == 0) {
  3485. clocking = 48000;
  3486. ali_configure_clocking();
  3487. }
  3489. /* register /dev/dsp */
  3490. if ((card->dev_audio = register_sound_dsp(&ali_audio_fops, -1)) < 0) {
  3491. int i;
  3492. printk(KERN_ERR"ali_audio: couldn't register DSP device!n");
  3493. release_region(card->iobase, 256);
  3494. free_irq(card->irq, card);
  3495. for (i = 0; i < NR_AC97; i++)
  3496. if (card->ac97_codec[i] != NULL) {
  3497. unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
  3498. kfree(card->ac97_codec[i]);
  3499. }
  3500. kfree(card);
  3501. return -ENODEV;
  3502. }
  3503. card->initializing = 0;
  3504. return 0;
  3505. }
  3507. static void __devexit ali_remove(struct pci_dev *pci_dev)
  3508. {
  3509. int i;
  3510. struct ali_card *card = pci_get_drvdata(pci_dev);
  3511. /* free hardware resources */
  3512. free_irq(card->irq, devs);
  3513. release_region(card->iobase, 256);
  3514. /* unregister audio devices */
  3515. for (i = 0; i < NR_AC97; i++)
  3516. if (card->ac97_codec[i] != NULL) {
  3517. unregister_sound_mixer(card->ac97_codec[i]->
  3518.        dev_mixer);
  3519. kfree(card->ac97_codec[i]);
  3520. card->ac97_codec[i] = NULL;
  3521. }
  3522. unregister_sound_dsp(card->dev_audio);
  3523. kfree(card);
  3524. }
  3526. #ifdef CONFIG_PM
  3527. static int ali_pm_suspend(struct pci_dev *dev, u32 pm_state)
  3528. {
  3529. struct ali_card *card = pci_get_drvdata(dev);
  3530. struct ali_state *state;
  3531. unsigned long flags;
  3532. struct dmabuf *dmabuf;
  3533. int i, num_ac97;
  3535. if (!card)
  3536. return 0;
  3537. spin_lock_irqsave(&card->lock, flags);
  3538. card->pm_suspended = 1;
  3539. for (i = 0; i < NR_HW_CH; i++) {
  3540. state = card->states[i];
  3541. if (!state)
  3542. continue;
  3543. /* this happens only if there are open files */
  3544. dmabuf = &state->dmabuf;
  3545. if (dmabuf->enable & DAC_RUNNING ||
  3546.     (dmabuf->count
  3547.      && (dmabuf->trigger & PCM_ENABLE_OUTPUT))) {
  3548. state->pm_saved_dac_rate = dmabuf->rate;
  3549. stop_dac(state);
  3550. } else {
  3551. state->pm_saved_dac_rate = 0;
  3552. }
  3553. if (dmabuf->enable & ADC_RUNNING) {
  3554. state->pm_saved_adc_rate = dmabuf->rate;
  3555. stop_adc(state);
  3556. } else {
  3557. state->pm_saved_adc_rate = 0;
  3558. }
  3559. dmabuf->ready = 0;
  3560. dmabuf->swptr = dmabuf->hwptr = 0;
  3561. dmabuf->count = dmabuf->total_bytes = 0;
  3562. }
  3564. spin_unlock_irqrestore(&card->lock, flags);
  3565. /* save mixer settings */
  3566. for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
  3567. struct ac97_codec *codec = card->ac97_codec[num_ac97];
  3568. if (!codec)
  3569. continue;
  3570. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
  3571. if ((supported_mixer(codec, i)) && (codec->read_mixer)) {
  3572. card->pm_saved_mixer_settings[i][num_ac97] = codec->read_mixer(codec, i);
  3573. }
  3574. }
  3575. }
  3576. pci_save_state(dev, card->pm_save_state); /* XXX do we need this? */
  3577. pci_disable_device(dev); /* disable busmastering */
  3578. pci_set_power_state(dev, 3); /* Zzz. */
  3579. return 0;
  3580. }
  3583. static int ali_pm_resume(struct pci_dev *dev)
  3584. {
  3585. int num_ac97, i = 0;
  3586. struct ali_card *card = pci_get_drvdata(dev);
  3587. pci_enable_device(dev);
  3588. pci_restore_state(dev, card->pm_save_state);
  3589. /* observation of a toshiba portege 3440ct suggests that the 
  3590.    hardware has to be more or less completely reinitialized from
  3591.    scratch after an apm suspend.  Works For Me.   -dan */
  3592. ali_ac97_random_init_stuff(card);
  3593. for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
  3594. struct ac97_codec *codec = card->ac97_codec[num_ac97];
  3595. /* check they haven't stolen the hardware while we were
  3596.    away */
  3597. if (!codec || !ali_ac97_exists(card, num_ac97)) {
  3598. if (num_ac97)
  3599. continue;
  3600. else
  3601. BUG();
  3602. }
  3603. if (!ali_ac97_probe_and_powerup(card, codec))
  3604. BUG();
  3605. if ((card->ac97_features & 0x0001)) {
  3606. /* at probe time we found we could do variable
  3607.    rates, but APM suspend has made it forget
  3608.    its magical powers */
  3609. if (!ali_ac97_enable_variable_rate(codec))
  3610. BUG();
  3611. }
  3612. /* we lost our mixer settings, so restore them */
  3613. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
  3614. if (supported_mixer(codec, i)) {
  3615. int val = card->pm_saved_mixer_settings[i][num_ac97];
  3616. codec->mixer_state[i] = val;
  3617. codec->write_mixer(codec, i,
  3618.    (val & 0xff),
  3619.    ((val >> 8) & 0xff));
  3620. }
  3621. }
  3622. }
  3624. /* we need to restore the sample rate from whatever it was */
  3625. for (i = 0; i < NR_HW_CH; i++) {
  3626. struct ali_state *state = card->states[i];
  3627. if (state) {
  3628. if (state->pm_saved_adc_rate)
  3629. ali_set_adc_rate(state, state->pm_saved_adc_rate);
  3630. if (state->pm_saved_dac_rate)
  3631. ali_set_dac_rate(state, state->pm_saved_dac_rate);
  3632. }
  3633. }
  3635. card->pm_suspended = 0;
  3636. /* any processes that were reading/writing during the suspend
  3637.    probably ended up here */
  3638. for (i = 0; i < NR_HW_CH; i++) {
  3639. struct ali_state *state = card->states[i];
  3640. if (state)
  3641. wake_up(&state->dmabuf.wait);
  3642. }
  3643. return 0;
  3644. }
  3645. #endif /* CONFIG_PM */
  3647. MODULE_AUTHOR("");
  3648. MODULE_DESCRIPTION("ALI 5455 audio support");
  3649. MODULE_LICENSE("GPL");
  3650. MODULE_PARM(clocking, "i");
  3651. MODULE_PARM(strict_clocking, "i");
  3652. MODULE_PARM(codec_pcmout_share_spdif_locked, "i");
  3653. MODULE_PARM(codec_independent_spdif_locked, "i");
  3654. MODULE_PARM(controller_pcmout_share_spdif_locked, "i");
  3655. MODULE_PARM(controller_independent_spdif_locked, "i");
  3656. #define ALI5455_MODULE_NAME "ali5455"
  3657. static struct pci_driver ali_pci_driver = {
  3658. name:ALI5455_MODULE_NAME, id_table:ali_pci_tbl, probe:ali_probe,
  3659.     remove:__devexit_p(ali_remove),
  3660. #ifdef CONFIG_PM
  3661. suspend:ali_pm_suspend, resume:ali_pm_resume,
  3662. #endif /* CONFIG_PM */
  3663. };
  3665. static int __init ali_init_module(void)
  3666. {
  3667. if (!pci_present()) /* No PCI bus in this machine! */
  3668. return -ENODEV;
  3669. printk(KERN_INFO "ALI 5455 + AC97 Audio, version "
  3670.        DRIVER_VERSION ", " __TIME__ " " __DATE__ "n");
  3672. if (codec_independent_spdif_locked > 0) {
  3673. if (codec_independent_spdif_locked == 32000
  3674.     || codec_independent_spdif_locked == 44100
  3675.     || codec_independent_spdif_locked == 48000) {
  3676. printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.n", codec_independent_spdif_locked);
  3677. } else {
  3678. printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.n");
  3679. codec_independent_spdif_locked = 0;
  3680. }
  3681. }
  3682. if (controller_independent_spdif_locked > 0) {
  3683. if (controller_independent_spdif_locked == 32000
  3684.     || controller_independent_spdif_locked == 44100
  3685.     || controller_independent_spdif_locked == 48000) {
  3686. printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.n", controller_independent_spdif_locked);
  3687. } else {
  3688. printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.n");
  3689. controller_independent_spdif_locked = 0;
  3690. }
  3691. }
  3693. if (codec_pcmout_share_spdif_locked > 0) {
  3694. if (codec_pcmout_share_spdif_locked == 32000
  3695.     || codec_pcmout_share_spdif_locked == 44100
  3696.     || codec_pcmout_share_spdif_locked == 48000) {
  3697. printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.n", codec_pcmout_share_spdif_locked);
  3698. } else {
  3699. printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.n");
  3700. codec_pcmout_share_spdif_locked = 0;
  3701. }
  3702. }
  3703. if (controller_pcmout_share_spdif_locked > 0) {
  3704. if (controller_pcmout_share_spdif_locked == 32000
  3705.     || controller_pcmout_share_spdif_locked == 44100
  3706.     || controller_pcmout_share_spdif_locked == 48000) {
  3707. printk(KERN_INFO "ali_audio: Enabling controller S/PDIF at sample rate %dHz.n", controller_pcmout_share_spdif_locked);
  3708. } else {
  3709. printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.n");
  3710. controller_pcmout_share_spdif_locked = 0;
  3711. }
  3712. }
  3713. if (!pci_register_driver(&ali_pci_driver)) {
  3714. pci_unregister_driver(&ali_pci_driver);
  3715. return -ENODEV;
  3716. }
  3717. return 0;
  3718. }
  3720. static void __exit ali_cleanup_module(void)
  3721. {
  3722. pci_unregister_driver(&ali_pci_driver);
  3723. }
  3725. module_init(ali_init_module);
  3726. module_exit(ali_cleanup_module);
  3727. /*
  3728. Local Variables:
  3729. c-basic-offset: 8
  3730. End:
  3731. */