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

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

Linux/Unix编程

开发平台：

Unix_Linux

ymfpci.c：源码内容
  1. /*
  2.  *  Copyright 1999 Jaroslav Kysela <perex@suse.cz>
  3.  *  Copyright 2000 Alan Cox <alan@redhat.com>
  4.  *  Copyright 2001 Kai Germaschewski <kai@tp1.ruhr-uni-bochum.de>
  5.  *  Copyright 2002 Pete Zaitcev <zaitcev@yahoo.com>
  6.  *
  7.  *  Yamaha YMF7xx driver.
  8.  *
  9.  *  This code is a result of high-speed collision
  10.  *  between ymfpci.c of ALSA and cs46xx.c of Linux.
  11.  *  -- Pete Zaitcev <zaitcev@yahoo.com>; 2000/09/18
  12.  *
  13.  *   This program is free software; you can redistribute it and/or modify
  14.  *   it under the terms of the GNU General Public License as published by
  15.  *   the Free Software Foundation; either version 2 of the License, or
  16.  *   (at your option) any later version.
  17.  *
  18.  *   This program is distributed in the hope that it will be useful,
  19.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  *   GNU General Public License for more details.
  22.  *
  23.  *   You should have received a copy of the GNU General Public License
  24.  *   along with this program; if not, write to the Free Software
  25.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26.  *
  27.  * TODO:
  28.  *  - Use P44Slot for 44.1 playback (beware of idle buzzing in P44Slot).
  29.  *  - 96KHz playback for DVD - use pitch of 2.0.
  30.  *  - Retain DMA buffer on close, do not wait the end of frame.
  31.  *  - Resolve XXX tagged questions.
  32.  *  - Cannot play 5133Hz.
  33.  *  - 2001/01/07 Consider if we can remove voice_lock, like so:
  34.  *     : Allocate/deallocate voices in open/close under semafore.
  35.  *     : We access voices in interrupt, that only for pcms that open.
  36.  *    voice_lock around playback_prepare closes interrupts for insane duration.
  37.  *  - Revisit the way voice_alloc is done - too confusing, overcomplicated.
  38.  *    Should support various channel types, however.
  39.  *  - Remove prog_dmabuf from read/write, leave it in open.
  40.  *  - 2001/01/07 Replace the OPL3 part of CONFIG_SOUND_YMFPCI_LEGACY code with
  41.  *    native synthesizer through a playback slot.
  42.  *  - 2001/11/29 ac97_save_state
  43.  *    Talk to Kai to remove ac97_save_state before it's too late!
  44.  *  - Second AC97
  45.  *  - Restore S/PDIF - Toshibas have it.
  46.  *
  47.  * Kai used pci_alloc_consistent for DMA buffer, which sounds a little
  48.  * unconventional. However, given how small our fragments can be,
  49.  * a little uncached access is perhaps better than endless flushing.
  50.  * On i386 and other I/O-coherent architectures pci_alloc_consistent
  51.  * is entirely harmless.
  52.  */
  54. #include <linux/config.h>
  55. #include <linux/module.h>
  56. #include <linux/init.h>
  57. #include <linux/ioport.h>
  58. #include <linux/delay.h>
  59. #include <linux/pci.h>
  60. #include <linux/slab.h>
  61. #include <linux/poll.h>
  62. #include <linux/soundcard.h>
  63. #include <linux/ac97_codec.h>
  64. #include <linux/sound.h>
  66. #include <asm/io.h>
  67. #include <asm/dma.h>
  68. #include <asm/uaccess.h>
  70. #ifdef CONFIG_SOUND_YMFPCI_LEGACY
  71. # include "sound_config.h"
  72. # include "mpu401.h"
  73. #endif
  74. #include "ymfpci.h"
  76. /*
  77.  * I do not believe in debug levels as I never can guess what
  78.  * part of the code is going to be problematic in the future.
  79.  * Don't forget to run your klogd with -c 8.
  80.  *
  81.  * Example (do not remove):
  82.  * #define YMFDBG(fmt, arg...)  do{ printk(KERN_DEBUG fmt, ##arg); }while(0)
  83.  */
  84. #define YMFDBGW(fmt, arg...)  /* */ /* write counts */
  85. #define YMFDBGI(fmt, arg...)  /* */ /* interrupts */
  86. #define YMFDBGX(fmt, arg...)  /* */ /* ioctl */
  88. static int ymf_playback_trigger(ymfpci_t *unit, struct ymf_pcm *ypcm, int cmd);
  89. static void ymf_capture_trigger(ymfpci_t *unit, struct ymf_pcm *ypcm, int cmd);
  90. static void ymfpci_voice_free(ymfpci_t *unit, ymfpci_voice_t *pvoice);
  91. static int ymf_capture_alloc(struct ymf_unit *unit, int *pbank);
  92. static int ymf_playback_prepare(struct ymf_state *state);
  93. static int ymf_capture_prepare(struct ymf_state *state);
  94. static struct ymf_state *ymf_state_alloc(ymfpci_t *unit);
  96. static void ymfpci_aclink_reset(struct pci_dev * pci);
  97. static void ymfpci_disable_dsp(ymfpci_t *unit);
  98. static void ymfpci_download_image(ymfpci_t *codec);
  99. static void ymf_memload(ymfpci_t *unit);
  101. static LIST_HEAD(ymf_devs);
  103. /*
  104.  *  constants
  105.  */
  107. static struct pci_device_id ymf_id_tbl[] __devinitdata = {
  108. #define DEV(v, d, data) 
  109.   { PCI_VENDOR_ID_##v, PCI_DEVICE_ID_##v##_##d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (unsigned long)data }
  110. DEV (YAMAHA, 724,  "YMF724"),
  111. DEV (YAMAHA, 724F, "YMF724F"),
  112. DEV (YAMAHA, 740,  "YMF740"),
  113. DEV (YAMAHA, 740C, "YMF740C"),
  114. DEV (YAMAHA, 744,  "YMF744"),
  115. DEV (YAMAHA, 754,  "YMF754"),
  116. #undef DEV
  117. { }
  118. };
  119. MODULE_DEVICE_TABLE(pci, ymf_id_tbl);
  121. /*
  122.  *  common I/O routines
  123.  */
  125. static inline u8 ymfpci_readb(ymfpci_t *codec, u32 offset)
  126. {
  127. return readb(codec->reg_area_virt + offset);
  128. }
  130. static inline void ymfpci_writeb(ymfpci_t *codec, u32 offset, u8 val)
  131. {
  132. writeb(val, codec->reg_area_virt + offset);
  133. }
  135. static inline u16 ymfpci_readw(ymfpci_t *codec, u32 offset)
  136. {
  137. return readw(codec->reg_area_virt + offset);
  138. }
  140. static inline void ymfpci_writew(ymfpci_t *codec, u32 offset, u16 val)
  141. {
  142. writew(val, codec->reg_area_virt + offset);
  143. }
  145. static inline u32 ymfpci_readl(ymfpci_t *codec, u32 offset)
  146. {
  147. return readl(codec->reg_area_virt + offset);
  148. }
  150. static inline void ymfpci_writel(ymfpci_t *codec, u32 offset, u32 val)
  151. {
  152. writel(val, codec->reg_area_virt + offset);
  153. }
  155. static int ymfpci_codec_ready(ymfpci_t *codec, int secondary, int sched)
  156. {
  157. signed long end_time;
  158. u32 reg = secondary ? YDSXGR_SECSTATUSADR : YDSXGR_PRISTATUSADR;
  160. end_time = jiffies + 3 * (HZ / 4);
  161. do {
  162. if ((ymfpci_readw(codec, reg) & 0x8000) == 0)
  163. return 0;
  164. if (sched) {
  165. set_current_state(TASK_UNINTERRUPTIBLE);
  166. schedule_timeout(1);
  167. }
  168. } while (end_time - (signed long)jiffies >= 0);
  169. printk(KERN_ERR "ymfpci_codec_ready: codec %i is not ready [0x%x]n",
  170.     secondary, ymfpci_readw(codec, reg));
  171. return -EBUSY;
  172. }
  174. static void ymfpci_codec_write(struct ac97_codec *dev, u8 reg, u16 val)
  175. {
  176. ymfpci_t *codec = dev->private_data;
  177. u32 cmd;
  179. /* XXX Do make use of dev->id */
  180. ymfpci_codec_ready(codec, 0, 0);
  181. cmd = ((YDSXG_AC97WRITECMD | reg) << 16) | val;
  182. ymfpci_writel(codec, YDSXGR_AC97CMDDATA, cmd);
  183. }
  185. static u16 ymfpci_codec_read(struct ac97_codec *dev, u8 reg)
  186. {
  187. ymfpci_t *unit = dev->private_data;
  188. int i;
  190. if (ymfpci_codec_ready(unit, 0, 0))
  191. return ~0;
  192. ymfpci_writew(unit, YDSXGR_AC97CMDADR, YDSXG_AC97READCMD | reg);
  193. if (ymfpci_codec_ready(unit, 0, 0))
  194. return ~0;
  195. if (unit->pci->device == PCI_DEVICE_ID_YAMAHA_744 && unit->rev < 2) {
  196. for (i = 0; i < 600; i++)
  197. ymfpci_readw(unit, YDSXGR_PRISTATUSDATA);
  198. }
  199. return ymfpci_readw(unit, YDSXGR_PRISTATUSDATA);
  200. }
  202. /*
  203.  *  Misc routines
  204.  */
  206. /*
  207.  * Calculate the actual sampling rate relatetively to the base clock (48kHz).
  208.  */
  209. static u32 ymfpci_calc_delta(u32 rate)
  210. {
  211. switch (rate) {
  212. case 8000: return 0x02aaab00;
  213. case 11025: return 0x03accd00;
  214. case 16000: return 0x05555500;
  215. case 22050: return 0x07599a00;
  216. case 32000: return 0x0aaaab00;
  217. case 44100: return 0x0eb33300;
  218. default: return ((rate << 16) / 48000) << 12;
  219. }
  220. }
  222. static u32 def_rate[8] = {
  223. 100, 2000, 8000, 11025, 16000, 22050, 32000, 48000
  224. };
  226. static u32 ymfpci_calc_lpfK(u32 rate)
  227. {
  228. u32 i;
  229. static u32 val[8] = {
  230. 0x00570000, 0x06AA0000, 0x18B20000, 0x20930000,
  231. 0x2B9A0000, 0x35A10000, 0x3EAA0000, 0x40000000
  232. };
  234. if (rate == 44100)
  235. return 0x40000000; /* FIXME: What's the right value? */
  236. for (i = 0; i < 8; i++)
  237. if (rate <= def_rate[i])
  238. return val[i];
  239. return val[0];
  240. }
  242. static u32 ymfpci_calc_lpfQ(u32 rate)
  243. {
  244. u32 i;
  245. static u32 val[8] = {
  246. 0x35280000, 0x34A70000, 0x32020000, 0x31770000,
  247. 0x31390000, 0x31C90000, 0x33D00000, 0x40000000
  248. };
  250. if (rate == 44100)
  251. return 0x370A0000;
  252. for (i = 0; i < 8; i++)
  253. if (rate <= def_rate[i])
  254. return val[i];
  255. return val[0];
  256. }
  258. static u32 ymf_calc_lend(u32 rate)
  259. {
  260. return (rate * YMF_SAMPF) / 48000;
  261. }
  263. /*
  264.  * We ever allow only a few formats, but let's be generic, for smaller surprise.
  265.  */
  266. static int ymf_pcm_format_width(int format)
  267. {
  268. static int mask16 = AFMT_S16_LE|AFMT_S16_BE|AFMT_U16_LE|AFMT_U16_BE;
  270. if ((format & (format-1)) != 0) {
  271. printk(KERN_ERR "ymfpci: format 0x%x is not a power of 2n", format);
  272. return 8;
  273. }
  275. if (format == AFMT_IMA_ADPCM) return 4;
  276. if ((format & mask16) != 0) return 16;
  277. return 8;
  278. }
  280. static void ymf_pcm_update_shift(struct ymf_pcm_format *f)
  281. {
  282. f->shift = 0;
  283. if (f->voices == 2)
  284. f->shift++;
  285. if (ymf_pcm_format_width(f->format) == 16)
  286. f->shift++;
  287. }
  289. /* Are you sure 32K is not too much? See if mpg123 skips on loaded systems. */
  290. #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
  291. #define DMABUF_MINORDER 1
  293. /*
  294.  * Allocate DMA buffer
  295.  */
  296. static int alloc_dmabuf(ymfpci_t *unit, struct ymf_dmabuf *dmabuf)
  297. {
  298. void *rawbuf = NULL;
  299. dma_addr_t dma_addr;
  300. int order;
  301. struct page *map, *mapend;
  303. /* alloc as big a chunk as we can */
  304. for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
  305. rawbuf = pci_alloc_consistent(unit->pci, PAGE_SIZE << order, &dma_addr);
  306. if (rawbuf)
  307. break;
  308. }
  309. if (!rawbuf)
  310. return -ENOMEM;
  312. #if 0
  313. printk(KERN_DEBUG "ymfpci: allocated %ld (order = %d) bytes at %pn",
  314.        PAGE_SIZE << order, order, rawbuf);
  315. #endif
  317. dmabuf->ready  = dmabuf->mapped = 0;
  318. dmabuf->rawbuf = rawbuf;
  319. dmabuf->dma_addr = dma_addr;
  320. dmabuf->buforder = order;
  322. /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
  323. mapend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
  324. for (map = virt_to_page(rawbuf); map <= mapend; map++)
  325. set_bit(PG_reserved, &map->flags);
  327. return 0;
  328. }
  330. /*
  331.  * Free DMA buffer
  332.  */
  333. static void dealloc_dmabuf(ymfpci_t *unit, struct ymf_dmabuf *dmabuf)
  334. {
  335. struct page *map, *mapend;
  337. if (dmabuf->rawbuf) {
  338. /* undo marking the pages as reserved */
  339. mapend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
  340. for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
  341. clear_bit(PG_reserved, &map->flags);
  343. pci_free_consistent(unit->pci, PAGE_SIZE << dmabuf->buforder,
  344.     dmabuf->rawbuf, dmabuf->dma_addr);
  345. }
  346. dmabuf->rawbuf = NULL;
  347. dmabuf->mapped = dmabuf->ready = 0;
  348. }
  350. static int prog_dmabuf(struct ymf_state *state, int rec)
  351. {
  352. struct ymf_dmabuf *dmabuf;
  353. int w_16;
  354. unsigned bufsize;
  355. unsigned long flags;
  356. int redzone, redfrags;
  357. int ret;
  359. w_16 = ymf_pcm_format_width(state->format.format) == 16;
  360. dmabuf = rec ? &state->rpcm.dmabuf : &state->wpcm.dmabuf;
  362. spin_lock_irqsave(&state->unit->reg_lock, flags);
  363. dmabuf->hwptr = dmabuf->swptr = 0;
  364. dmabuf->total_bytes = 0;
  365. dmabuf->count = 0;
  366. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  368. /* allocate DMA buffer if not allocated yet */
  369. if (!dmabuf->rawbuf)
  370. if ((ret = alloc_dmabuf(state->unit, dmabuf)))
  371. return ret;
  373. /*
  374.  * Create fake fragment sizes and numbers for OSS ioctls.
  375.  * Import what Doom might have set with SNDCTL_DSP_SETFRAGMENT.
  376.  */
  377. bufsize = PAGE_SIZE << dmabuf->buforder;
  378. /* By default we give 4 big buffers. */
  379. dmabuf->fragshift = (dmabuf->buforder + PAGE_SHIFT - 2);
  380. if (dmabuf->ossfragshift > 3 &&
  381.     dmabuf->ossfragshift < dmabuf->fragshift) {
  382. /* If OSS set smaller fragments, give more smaller buffers. */
  383. dmabuf->fragshift = dmabuf->ossfragshift;
  384. }
  385. dmabuf->fragsize = 1 << dmabuf->fragshift;
  387. dmabuf->numfrag = bufsize >> dmabuf->fragshift;
  388. dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
  390. if (dmabuf->ossmaxfrags >= 2) {
  391. redzone = ymf_calc_lend(state->format.rate);
  392. redzone <<= state->format.shift;
  393. redzone *= 3;
  394. redfrags = (redzone + dmabuf->fragsize-1) >> dmabuf->fragshift;
  396. if (dmabuf->ossmaxfrags + redfrags < dmabuf->numfrag) {
  397. dmabuf->numfrag = dmabuf->ossmaxfrags + redfrags;
  398. dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
  399. }
  400. }
  402. memset(dmabuf->rawbuf, w_16 ? 0 : 0x80, dmabuf->dmasize);
  404. /*
  405.  * Now set up the ring 
  406.  */
  408. /* XXX   ret = rec? cap_pre(): pbk_pre();  */
  409. spin_lock_irqsave(&state->unit->voice_lock, flags);
  410. if (rec) {
  411. if ((ret = ymf_capture_prepare(state)) != 0) {
  412. spin_unlock_irqrestore(&state->unit->voice_lock, flags);
  413. return ret;
  414. }
  415. } else {
  416. if ((ret = ymf_playback_prepare(state)) != 0) {
  417. spin_unlock_irqrestore(&state->unit->voice_lock, flags);
  418. return ret;
  419. }
  420. }
  421. spin_unlock_irqrestore(&state->unit->voice_lock, flags);
  423. /* set the ready flag for the dma buffer (this comment is not stupid) */
  424. dmabuf->ready = 1;
  426. #if 0
  427. printk(KERN_DEBUG "prog_dmabuf: rate %d format 0x%x,"
  428.     " numfrag %d fragsize %d dmasize %dn",
  429.        state->format.rate, state->format.format, dmabuf->numfrag,
  430.        dmabuf->fragsize, dmabuf->dmasize);
  431. #endif
  433. return 0;
  434. }
  436. static void ymf_start_dac(struct ymf_state *state)
  437. {
  438. ymf_playback_trigger(state->unit, &state->wpcm, 1);
  439. }
  441. // static void ymf_start_adc(struct ymf_state *state)
  442. // {
  443. //  ymf_capture_trigger(state->unit, &state->rpcm, 1);
  444. // }
  446. /*
  447.  * Wait until output is drained.
  448.  * This does not kill the hardware for the sake of ioctls.
  449.  */
  450. static void ymf_wait_dac(struct ymf_state *state)
  451. {
  452. struct ymf_unit *unit = state->unit;
  453. struct ymf_pcm *ypcm = &state->wpcm;
  454. DECLARE_WAITQUEUE(waita, current);
  455. unsigned long flags;
  457. add_wait_queue(&ypcm->dmabuf.wait, &waita);
  459. spin_lock_irqsave(&unit->reg_lock, flags);
  460. if (ypcm->dmabuf.count != 0 && !ypcm->running) {
  461. ymf_playback_trigger(unit, ypcm, 1);
  462. }
  464. #if 0
  465. if (file->f_flags & O_NONBLOCK) {
  466. /*
  467.  * XXX Our  mistake is to attach DMA buffer to state
  468.  * rather than to some per-device structure.
  469.  * Cannot skip waiting, can only make it shorter.
  470.  */
  471. }
  472. #endif
  474. set_current_state(TASK_UNINTERRUPTIBLE);
  475. while (ypcm->running) {
  476. spin_unlock_irqrestore(&unit->reg_lock, flags);
  477. schedule();
  478. spin_lock_irqsave(&unit->reg_lock, flags);
  479. set_current_state(TASK_UNINTERRUPTIBLE);
  480. }
  481. spin_unlock_irqrestore(&unit->reg_lock, flags);
  483. set_current_state(TASK_RUNNING);
  484. remove_wait_queue(&ypcm->dmabuf.wait, &waita);
  486. /*
  487.  * This function may take up to 4 seconds to reach this point
  488.  * (32K circular buffer, 8000 Hz). User notices.
  489.  */
  490. }
  492. /* Can just stop, without wait. Or can we? */
  493. static void ymf_stop_adc(struct ymf_state *state)
  494. {
  495. struct ymf_unit *unit = state->unit;
  496. unsigned long flags;
  498. spin_lock_irqsave(&unit->reg_lock, flags);
  499. ymf_capture_trigger(unit, &state->rpcm, 0);
  500. spin_unlock_irqrestore(&unit->reg_lock, flags);
  501. }
  503. /*
  504.  *  Hardware start management
  505.  */
  507. static void ymfpci_hw_start(ymfpci_t *unit)
  508. {
  509. unsigned long flags;
  511. spin_lock_irqsave(&unit->reg_lock, flags);
  512. if (unit->start_count++ == 0) {
  513. ymfpci_writel(unit, YDSXGR_MODE,
  514.     ymfpci_readl(unit, YDSXGR_MODE) | 3);
  515. unit->active_bank = ymfpci_readl(unit, YDSXGR_CTRLSELECT) & 1;
  516. }
  517. spin_unlock_irqrestore(&unit->reg_lock, flags);
  518. }
  520. static void ymfpci_hw_stop(ymfpci_t *unit)
  521. {
  522. unsigned long flags;
  523. long timeout = 1000;
  525. spin_lock_irqsave(&unit->reg_lock, flags);
  526. if (--unit->start_count == 0) {
  527. ymfpci_writel(unit, YDSXGR_MODE,
  528.     ymfpci_readl(unit, YDSXGR_MODE) & ~3);
  529. while (timeout-- > 0) {
  530. if ((ymfpci_readl(unit, YDSXGR_STATUS) & 2) == 0)
  531. break;
  532. }
  533. }
  534. spin_unlock_irqrestore(&unit->reg_lock, flags);
  535. }
  537. /*
  538.  *  Playback voice management
  539.  */
  541. static int voice_alloc(ymfpci_t *codec, ymfpci_voice_type_t type, int pair, ymfpci_voice_t *rvoice[])
  542. {
  543. ymfpci_voice_t *voice, *voice2;
  544. int idx;
  546. for (idx = 0; idx < YDSXG_PLAYBACK_VOICES; idx += pair ? 2 : 1) {
  547. voice = &codec->voices[idx];
  548. voice2 = pair ? &codec->voices[idx+1] : NULL;
  549. if (voice->use || (voice2 && voice2->use))
  550. continue;
  551. voice->use = 1;
  552. if (voice2)
  553. voice2->use = 1;
  554. switch (type) {
  555. case YMFPCI_PCM:
  556. voice->pcm = 1;
  557. if (voice2)
  558. voice2->pcm = 1;
  559. break;
  560. case YMFPCI_SYNTH:
  561. voice->synth = 1;
  562. break;
  563. case YMFPCI_MIDI:
  564. voice->midi = 1;
  565. break;
  566. }
  567. ymfpci_hw_start(codec);
  568. rvoice[0] = voice;
  569. if (voice2) {
  570. ymfpci_hw_start(codec);
  571. rvoice[1] = voice2;
  572. }
  573. return 0;
  574. }
  575. return -EBUSY; /* Your audio channel is open by someone else. */
  576. }
  578. static void ymfpci_voice_free(ymfpci_t *unit, ymfpci_voice_t *pvoice)
  579. {
  580. ymfpci_hw_stop(unit);
  581. pvoice->use = pvoice->pcm = pvoice->synth = pvoice->midi = 0;
  582. pvoice->ypcm = NULL;
  583. }
  585. /*
  586.  */
  588. static void ymf_pcm_interrupt(ymfpci_t *codec, ymfpci_voice_t *voice)
  589. {
  590. struct ymf_pcm *ypcm;
  591. int redzone;
  592. int pos, delta, swptr;
  593. int played, distance;
  594. struct ymf_state *state;
  595. struct ymf_dmabuf *dmabuf;
  596. char silence;
  598. if ((ypcm = voice->ypcm) == NULL) {
  599. return;
  600. }
  601. if ((state = ypcm->state) == NULL) {
  602. ypcm->running = 0; // lock it
  603. return;
  604. }
  605. dmabuf = &ypcm->dmabuf;
  606. spin_lock(&codec->reg_lock);
  607. if (ypcm->running) {
  608. YMFDBGI("ymfpci: %d, intr bank %d count %d start 0x%x:%xn",
  609.    voice->number, codec->active_bank, dmabuf->count,
  610.    le32_to_cpu(voice->bank[0].start),
  611.    le32_to_cpu(voice->bank[1].start));
  612. silence = (ymf_pcm_format_width(state->format.format) == 16) ?
  613.     0 : 0x80;
  614. /* We need actual left-hand-side redzone size here. */
  615. redzone = ymf_calc_lend(state->format.rate);
  616. redzone <<= (state->format.shift + 1);
  617. swptr = dmabuf->swptr;
  619. pos = le32_to_cpu(voice->bank[codec->active_bank].start);
  620. pos <<= state->format.shift;
  621. if (pos < 0 || pos >= dmabuf->dmasize) { /* ucode bug */
  622. printk(KERN_ERR "ymfpci%d: runaway voice %d: hwptr %d=>%d dmasize %dn",
  623.     codec->dev_audio, voice->number,
  624.     dmabuf->hwptr, pos, dmabuf->dmasize);
  625. pos = 0;
  626. }
  627. if (pos < dmabuf->hwptr) {
  628. delta = dmabuf->dmasize - dmabuf->hwptr;
  629. memset(dmabuf->rawbuf + dmabuf->hwptr, silence, delta);
  630. delta += pos;
  631. memset(dmabuf->rawbuf, silence, pos);
  632. } else {
  633. delta = pos - dmabuf->hwptr;
  634. memset(dmabuf->rawbuf + dmabuf->hwptr, silence, delta);
  635. }
  636. dmabuf->hwptr = pos;
  638. if (dmabuf->count == 0) {
  639. printk(KERN_ERR "ymfpci%d: %d: strain: hwptr %dn",
  640.     codec->dev_audio, voice->number, dmabuf->hwptr);
  641. ymf_playback_trigger(codec, ypcm, 0);
  642. }
  644. if (swptr <= pos) {
  645. distance = pos - swptr;
  646. } else {
  647. distance = dmabuf->dmasize - (swptr - pos);
  648. }
  649. if (distance < redzone) {
  650. /*
  651.  * hwptr inside redzone => DMA ran out of samples.
  652.  */
  653. if (delta < dmabuf->count) {
  654. /*
  655.  * Lost interrupt or other screwage.
  656.  */
  657. printk(KERN_ERR "ymfpci%d: %d: lost: delta %d"
  658.     " hwptr %d swptr %d distance %d count %dn",
  659.     codec->dev_audio, voice->number, delta,
  660.     dmabuf->hwptr, swptr, distance, dmabuf->count);
  661. } else {
  662. /*
  663.  * Normal end of DMA.
  664.  */
  665. YMFDBGI("ymfpci%d: %d: done: delta %d"
  666.     " hwptr %d swptr %d distance %d count %dn",
  667.     codec->dev_audio, voice->number, delta,
  668.     dmabuf->hwptr, swptr, distance, dmabuf->count);
  669. }
  670. played = dmabuf->count;
  671. if (ypcm->running) {
  672. ymf_playback_trigger(codec, ypcm, 0);
  673. }
  674. } else {
  675. /*
  676.  * hwptr is chipping away towards a remote swptr.
  677.  * Calculate other distance and apply it to count.
  678.  */
  679. if (swptr >= pos) {
  680. distance = swptr - pos;
  681. } else {
  682. distance = dmabuf->dmasize - (pos - swptr);
  683. }
  684. if (distance < dmabuf->count) {
  685. played = dmabuf->count - distance;
  686. } else {
  687. played = 0;
  688. }
  689. }
  691. dmabuf->total_bytes += played;
  692. dmabuf->count -= played;
  693. if (dmabuf->count < dmabuf->dmasize / 2) {
  694. wake_up(&dmabuf->wait);
  695. }
  696. }
  697. spin_unlock(&codec->reg_lock);
  698. }
  700. static void ymf_cap_interrupt(ymfpci_t *unit, struct ymf_capture *cap)
  701. {
  702. struct ymf_pcm *ypcm;
  703. int redzone;
  704. struct ymf_state *state;
  705. struct ymf_dmabuf *dmabuf;
  706. int pos, delta;
  707. int cnt;
  709. if ((ypcm = cap->ypcm) == NULL) {
  710. return;
  711. }
  712. if ((state = ypcm->state) == NULL) {
  713. ypcm->running = 0; // lock it
  714. return;
  715. }
  716. dmabuf = &ypcm->dmabuf;
  717. spin_lock(&unit->reg_lock);
  718. if (ypcm->running) {
  719. redzone = ymf_calc_lend(state->format.rate);
  720. redzone <<= (state->format.shift + 1);
  722. pos = le32_to_cpu(cap->bank[unit->active_bank].start);
  723. // pos <<= state->format.shift;
  724. if (pos < 0 || pos >= dmabuf->dmasize) { /* ucode bug */
  725. printk(KERN_ERR "ymfpci%d: runaway capture %d: hwptr %d=>%d dmasize %dn",
  726.     unit->dev_audio, ypcm->capture_bank_number,
  727.     dmabuf->hwptr, pos, dmabuf->dmasize);
  728. pos = 0;
  729. }
  730. if (pos < dmabuf->hwptr) {
  731. delta = dmabuf->dmasize - dmabuf->hwptr;
  732. delta += pos;
  733. } else {
  734. delta = pos - dmabuf->hwptr;
  735. }
  736. dmabuf->hwptr = pos;
  738. cnt = dmabuf->count;
  739. cnt += delta;
  740. if (cnt + redzone > dmabuf->dmasize) {
  741. /* Overflow - bump swptr */
  742. dmabuf->count = dmabuf->dmasize - redzone;
  743. dmabuf->swptr = dmabuf->hwptr + redzone;
  744. if (dmabuf->swptr >= dmabuf->dmasize) {
  745. dmabuf->swptr -= dmabuf->dmasize;
  746. }
  747. } else {
  748. dmabuf->count = cnt;
  749. }
  751. dmabuf->total_bytes += delta;
  752. if (dmabuf->count) { /* && is_sleeping  XXX */
  753. wake_up(&dmabuf->wait);
  754. }
  755. }
  756. spin_unlock(&unit->reg_lock);
  757. }
  759. static int ymf_playback_trigger(ymfpci_t *codec, struct ymf_pcm *ypcm, int cmd)
  760. {
  762. if (ypcm->voices[0] == NULL) {
  763. return -EINVAL;
  764. }
  765. if (cmd != 0) {
  766. codec->ctrl_playback[ypcm->voices[0]->number + 1] =
  767.     cpu_to_le32(ypcm->voices[0]->bank_ba);
  768. if (ypcm->voices[1] != NULL)
  769. codec->ctrl_playback[ypcm->voices[1]->number + 1] =
  770.     cpu_to_le32(ypcm->voices[1]->bank_ba);
  771. ypcm->running = 1;
  772. } else {
  773. codec->ctrl_playback[ypcm->voices[0]->number + 1] = 0;
  774. if (ypcm->voices[1] != NULL)
  775. codec->ctrl_playback[ypcm->voices[1]->number + 1] = 0;
  776. ypcm->running = 0;
  777. }
  778. return 0;
  779. }
  781. static void ymf_capture_trigger(ymfpci_t *codec, struct ymf_pcm *ypcm, int cmd)
  782. {
  783. u32 tmp;
  785. if (cmd != 0) {
  786. tmp = ymfpci_readl(codec, YDSXGR_MAPOFREC) | (1 << ypcm->capture_bank_number);
  787. ymfpci_writel(codec, YDSXGR_MAPOFREC, tmp);
  788. ypcm->running = 1;
  789. } else {
  790. tmp = ymfpci_readl(codec, YDSXGR_MAPOFREC) & ~(1 << ypcm->capture_bank_number);
  791. ymfpci_writel(codec, YDSXGR_MAPOFREC, tmp);
  792. ypcm->running = 0;
  793. }
  794. }
  796. static int ymfpci_pcm_voice_alloc(struct ymf_pcm *ypcm, int voices)
  797. {
  798. struct ymf_unit *unit;
  799. int err;
  801. unit = ypcm->state->unit;
  802. if (ypcm->voices[1] != NULL && voices < 2) {
  803. ymfpci_voice_free(unit, ypcm->voices[1]);
  804. ypcm->voices[1] = NULL;
  805. }
  806. if (voices == 1 && ypcm->voices[0] != NULL)
  807. return 0; /* already allocated */
  808. if (voices == 2 && ypcm->voices[0] != NULL && ypcm->voices[1] != NULL)
  809. return 0; /* already allocated */
  810. if (voices > 1) {
  811. if (ypcm->voices[0] != NULL && ypcm->voices[1] == NULL) {
  812. ymfpci_voice_free(unit, ypcm->voices[0]);
  813. ypcm->voices[0] = NULL;
  814. }
  815. if ((err = voice_alloc(unit, YMFPCI_PCM, 1, ypcm->voices)) < 0)
  816. return err;
  817. ypcm->voices[0]->ypcm = ypcm;
  818. ypcm->voices[1]->ypcm = ypcm;
  819. } else {
  820. if ((err = voice_alloc(unit, YMFPCI_PCM, 0, ypcm->voices)) < 0)
  821. return err;
  822. ypcm->voices[0]->ypcm = ypcm;
  823. }
  824. return 0;
  825. }
  827. static void ymf_pcm_init_voice(ymfpci_voice_t *voice, int stereo,
  828.     int rate, int w_16, unsigned long addr, unsigned int end, int spdif)
  829. {
  830. u32 format;
  831. u32 delta = ymfpci_calc_delta(rate);
  832. u32 lpfQ = ymfpci_calc_lpfQ(rate);
  833. u32 lpfK = ymfpci_calc_lpfK(rate);
  834. ymfpci_playback_bank_t *bank;
  835. int nbank;
  837. /*
  838.  * The gain is a floating point number. According to the manual,
  839.  * bit 31 indicates a sign bit, bit 30 indicates an integer part,
  840.  * and bits [29:15] indicate a decimal fraction part. Thus,
  841.  * for a gain of 1.0 the constant of 0x40000000 is loaded.
  842.  */
  843. unsigned default_gain = cpu_to_le32(0x40000000);
  845. format = (stereo ? 0x00010000 : 0) | (w_16 ? 0 : 0x80000000);
  846. if (stereo)
  847. end >>= 1;
  848. if (w_16)
  849. end >>= 1;
  850. for (nbank = 0; nbank < 2; nbank++) {
  851. bank = &voice->bank[nbank];
  852. bank->format = cpu_to_le32(format);
  853. bank->loop_default = 0; /* 0-loops forever, otherwise count */
  854. bank->base = cpu_to_le32(addr);
  855. bank->loop_start = 0;
  856. bank->loop_end = cpu_to_le32(end);
  857. bank->loop_frac = 0;
  858. bank->eg_gain_end = default_gain;
  859. bank->lpfQ = cpu_to_le32(lpfQ);
  860. bank->status = 0;
  861. bank->num_of_frames = 0;
  862. bank->loop_count = 0;
  863. bank->start = 0;
  864. bank->start_frac = 0;
  865. bank->delta =
  866. bank->delta_end = cpu_to_le32(delta);
  867. bank->lpfK =
  868. bank->lpfK_end = cpu_to_le32(lpfK);
  869. bank->eg_gain = default_gain;
  870. bank->lpfD1 =
  871. bank->lpfD2 = 0;
  873. bank->left_gain = 
  874. bank->right_gain =
  875. bank->left_gain_end =
  876. bank->right_gain_end =
  877. bank->eff1_gain =
  878. bank->eff2_gain =
  879. bank->eff3_gain =
  880. bank->eff1_gain_end =
  881. bank->eff2_gain_end =
  882. bank->eff3_gain_end = 0;
  884. if (!stereo) {
  885. if (!spdif) {
  886. bank->left_gain = 
  887. bank->right_gain =
  888. bank->left_gain_end =
  889. bank->right_gain_end = default_gain;
  890. } else {
  891. bank->eff2_gain =
  892. bank->eff2_gain_end =
  893. bank->eff3_gain =
  894. bank->eff3_gain_end = default_gain;
  895. }
  896. } else {
  897. if (!spdif) {
  898. if ((voice->number & 1) == 0) {
  899. bank->left_gain =
  900. bank->left_gain_end = default_gain;
  901. } else {
  902. bank->format |= cpu_to_le32(1);
  903. bank->right_gain =
  904. bank->right_gain_end = default_gain;
  905. }
  906. } else {
  907. if ((voice->number & 1) == 0) {
  908. bank->eff2_gain =
  909. bank->eff2_gain_end = default_gain;
  910. } else {
  911. bank->format |= cpu_to_le32(1);
  912. bank->eff3_gain =
  913. bank->eff3_gain_end = default_gain;
  914. }
  915. }
  916. }
  917. }
  918. }
  920. /*
  921.  * XXX Capture channel allocation is entirely fake at the moment.
  922.  * We use only one channel and mark it busy as required.
  923.  */
  924. static int ymf_capture_alloc(struct ymf_unit *unit, int *pbank)
  925. {
  926. struct ymf_capture *cap;
  927. int cbank;
  929. cbank = 1; /* Only ADC slot is used for now. */
  930. cap = &unit->capture[cbank];
  931. if (cap->use)
  932. return -EBUSY;
  933. cap->use = 1;
  934. *pbank = cbank;
  935. return 0;
  936. }
  938. static int ymf_playback_prepare(struct ymf_state *state)
  939. {
  940. struct ymf_pcm *ypcm = &state->wpcm;
  941. int err, nvoice;
  943. if ((err = ymfpci_pcm_voice_alloc(ypcm, state->format.voices)) < 0) {
  944. /* Somebody started 32 mpg123's in parallel? */
  945. printk(KERN_INFO "ymfpci%d: cannot allocate voicen",
  946.     state->unit->dev_audio);
  947. return err;
  948. }
  950. for (nvoice = 0; nvoice < state->format.voices; nvoice++) {
  951. ymf_pcm_init_voice(ypcm->voices[nvoice],
  952.     state->format.voices == 2, state->format.rate,
  953.     ymf_pcm_format_width(state->format.format) == 16,
  954.     ypcm->dmabuf.dma_addr, ypcm->dmabuf.dmasize,
  955.     ypcm->spdif);
  956. }
  957. return 0;
  958. }
  960. static int ymf_capture_prepare(struct ymf_state *state)
  961. {
  962. ymfpci_t *unit = state->unit;
  963. struct ymf_pcm *ypcm = &state->rpcm;
  964. ymfpci_capture_bank_t * bank;
  965. /* XXX This is confusing, gotta rename one of them banks... */
  966. int nbank; /* flip-flop bank */
  967. int cbank; /* input [super-]bank */
  968. struct ymf_capture *cap;
  969. u32 rate, format;
  971. if (ypcm->capture_bank_number == -1) {
  972. if (ymf_capture_alloc(unit, &cbank) != 0)
  973. return -EBUSY;
  975. ypcm->capture_bank_number = cbank;
  977. cap = &unit->capture[cbank];
  978. cap->bank = unit->bank_capture[cbank][0];
  979. cap->ypcm = ypcm;
  980. ymfpci_hw_start(unit);
  981. }
  983. // ypcm->frag_size = snd_pcm_lib_transfer_fragment(substream);
  984. // frag_size is replaced with nonfragged byte-aligned rolling buffer
  985. rate = ((48000 * 4096) / state->format.rate) - 1;
  986. format = 0;
  987. if (state->format.voices == 2)
  988. format |= 2;
  989. if (ymf_pcm_format_width(state->format.format) == 8)
  990. format |= 1;
  991. switch (ypcm->capture_bank_number) {
  992. case 0:
  993. ymfpci_writel(unit, YDSXGR_RECFORMAT, format);
  994. ymfpci_writel(unit, YDSXGR_RECSLOTSR, rate);
  995. break;
  996. case 1:
  997. ymfpci_writel(unit, YDSXGR_ADCFORMAT, format);
  998. ymfpci_writel(unit, YDSXGR_ADCSLOTSR, rate);
  999. break;
  1000. }
  1001. for (nbank = 0; nbank < 2; nbank++) {
  1002. bank = unit->bank_capture[ypcm->capture_bank_number][nbank];
  1003. bank->base = cpu_to_le32(ypcm->dmabuf.dma_addr);
  1004. // bank->loop_end = ypcm->dmabuf.dmasize >> state->format.shift;
  1005. bank->loop_end = cpu_to_le32(ypcm->dmabuf.dmasize);
  1006. bank->start = 0;
  1007. bank->num_of_loops = 0;
  1008. }
  1009. #if 0 /* s/pdif */
  1010. if (state->digital.dig_valid)
  1011. /*state->digital.type == SND_PCM_DIG_AES_IEC958*/
  1012. ymfpci_writew(codec, YDSXGR_SPDIFOUTSTATUS,
  1013.     state->digital.dig_status[0] | (state->digital.dig_status[1] << 8));
  1014. #endif
  1015. return 0;
  1016. }
  1018. void ymf_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  1019. {
  1020. ymfpci_t *codec = dev_id;
  1021. u32 status, nvoice, mode;
  1022. struct ymf_voice *voice;
  1023. struct ymf_capture *cap;
  1025. status = ymfpci_readl(codec, YDSXGR_STATUS);
  1026. if (status & 0x80000000) {
  1027. codec->active_bank = ymfpci_readl(codec, YDSXGR_CTRLSELECT) & 1;
  1028. spin_lock(&codec->voice_lock);
  1029. for (nvoice = 0; nvoice < YDSXG_PLAYBACK_VOICES; nvoice++) {
  1030. voice = &codec->voices[nvoice];
  1031. if (voice->use)
  1032. ymf_pcm_interrupt(codec, voice);
  1033. }
  1034. for (nvoice = 0; nvoice < YDSXG_CAPTURE_VOICES; nvoice++) {
  1035. cap = &codec->capture[nvoice];
  1036. if (cap->use)
  1037. ymf_cap_interrupt(codec, cap);
  1038. }
  1039. spin_unlock(&codec->voice_lock);
  1040. spin_lock(&codec->reg_lock);
  1041. ymfpci_writel(codec, YDSXGR_STATUS, 0x80000000);
  1042. mode = ymfpci_readl(codec, YDSXGR_MODE) | 2;
  1043. ymfpci_writel(codec, YDSXGR_MODE, mode);
  1044. spin_unlock(&codec->reg_lock);
  1045. }
  1047. status = ymfpci_readl(codec, YDSXGR_INTFLAG);
  1048. if (status & 1) {
  1049. /* timer handler */
  1050. ymfpci_writel(codec, YDSXGR_INTFLAG, ~0);
  1051. }
  1052. }
  1054. static void ymf_pcm_free_substream(struct ymf_pcm *ypcm)
  1055. {
  1056. unsigned long flags;
  1057. struct ymf_unit *unit;
  1059. unit = ypcm->state->unit;
  1061. if (ypcm->type == PLAYBACK_VOICE) {
  1062. spin_lock_irqsave(&unit->voice_lock, flags);
  1063. if (ypcm->voices[1])
  1064. ymfpci_voice_free(unit, ypcm->voices[1]);
  1065. if (ypcm->voices[0])
  1066. ymfpci_voice_free(unit, ypcm->voices[0]);
  1067. spin_unlock_irqrestore(&unit->voice_lock, flags);
  1068. } else {
  1069. if (ypcm->capture_bank_number != -1) {
  1070. unit->capture[ypcm->capture_bank_number].use = 0;
  1071. ypcm->capture_bank_number = -1;
  1072. ymfpci_hw_stop(unit);
  1073. }
  1074. }
  1075. }
  1077. static struct ymf_state *ymf_state_alloc(ymfpci_t *unit)
  1078. {
  1079. struct ymf_pcm *ypcm;
  1080. struct ymf_state *state;
  1082. if ((state = kmalloc(sizeof(struct ymf_state), GFP_KERNEL)) == NULL) {
  1083. goto out0;
  1084. }
  1085. memset(state, 0, sizeof(struct ymf_state));
  1087. ypcm = &state->wpcm;
  1088. ypcm->state = state;
  1089. ypcm->type = PLAYBACK_VOICE;
  1090. ypcm->capture_bank_number = -1;
  1091. init_waitqueue_head(&ypcm->dmabuf.wait);
  1093. ypcm = &state->rpcm;
  1094. ypcm->state = state;
  1095. ypcm->type = CAPTURE_AC97;
  1096. ypcm->capture_bank_number = -1;
  1097. init_waitqueue_head(&ypcm->dmabuf.wait);
  1099. state->unit = unit;
  1101. state->format.format = AFMT_U8;
  1102. state->format.rate = 8000;
  1103. state->format.voices = 1;
  1104. ymf_pcm_update_shift(&state->format);
  1106. return state;
  1108. out0:
  1109. return NULL;
  1110. }
  1112. /* AES/IEC958 channel status bits */
  1113. #define SND_PCM_AES0_PROFESSIONAL (1<<0) /* 0 = consumer, 1 = professional */
  1114. #define SND_PCM_AES0_NONAUDIO (1<<1) /* 0 = audio, 1 = non-audio */
  1115. #define SND_PCM_AES0_PRO_EMPHASIS (7<<2) /* mask - emphasis */
  1116. #define SND_PCM_AES0_PRO_EMPHASIS_NOTID (0<<2) /* emphasis not indicated */
  1117. #define SND_PCM_AES0_PRO_EMPHASIS_NONE (1<<2) /* none emphasis */
  1118. #define SND_PCM_AES0_PRO_EMPHASIS_5015 (3<<2) /* 50/15us emphasis */
  1119. #define SND_PCM_AES0_PRO_EMPHASIS_CCITT (7<<2) /* CCITT J.17 emphasis */
  1120. #define SND_PCM_AES0_PRO_FREQ_UNLOCKED (1<<5) /* source sample frequency: 0 = locked, 1 = unlocked */
  1121. #define SND_PCM_AES0_PRO_FS (3<<6) /* mask - sample frequency */
  1122. #define SND_PCM_AES0_PRO_FS_NOTID (0<<6) /* fs not indicated */
  1123. #define SND_PCM_AES0_PRO_FS_44100 (1<<6) /* 44.1kHz */
  1124. #define SND_PCM_AES0_PRO_FS_48000 (2<<6) /* 48kHz */
  1125. #define SND_PCM_AES0_PRO_FS_32000 (3<<6) /* 32kHz */
  1126. #define SND_PCM_AES0_CON_NOT_COPYRIGHT (1<<2) /* 0 = copyright, 1 = not copyright */
  1127. #define SND_PCM_AES0_CON_EMPHASIS (7<<3) /* mask - emphasis */
  1128. #define SND_PCM_AES0_CON_EMPHASIS_NONE (0<<3) /* none emphasis */
  1129. #define SND_PCM_AES0_CON_EMPHASIS_5015 (1<<3) /* 50/15us emphasis */
  1130. #define SND_PCM_AES0_CON_MODE (3<<6) /* mask - mode */
  1131. #define SND_PCM_AES1_PRO_MODE (15<<0) /* mask - channel mode */
  1132. #define SND_PCM_AES1_PRO_MODE_NOTID (0<<0) /* not indicated */
  1133. #define SND_PCM_AES1_PRO_MODE_STEREOPHONIC (2<<0) /* stereophonic - ch A is left */
  1134. #define SND_PCM_AES1_PRO_MODE_SINGLE (4<<0) /* single channel */
  1135. #define SND_PCM_AES1_PRO_MODE_TWO (8<<0) /* two channels */
  1136. #define SND_PCM_AES1_PRO_MODE_PRIMARY (12<<0) /* primary/secondary */
  1137. #define SND_PCM_AES1_PRO_MODE_BYTE3 (15<<0) /* vector to byte 3 */
  1138. #define SND_PCM_AES1_PRO_USERBITS (15<<4) /* mask - user bits */
  1139. #define SND_PCM_AES1_PRO_USERBITS_NOTID (0<<4) /* not indicated */
  1140. #define SND_PCM_AES1_PRO_USERBITS_192 (8<<4) /* 192-bit structure */
  1141. #define SND_PCM_AES1_PRO_USERBITS_UDEF (12<<4) /* user defined application */
  1142. #define SND_PCM_AES1_CON_CATEGORY 0x7f
  1143. #define SND_PCM_AES1_CON_GENERAL 0x00
  1144. #define SND_PCM_AES1_CON_EXPERIMENTAL 0x40
  1145. #define SND_PCM_AES1_CON_SOLIDMEM_MASK 0x0f
  1146. #define SND_PCM_AES1_CON_SOLIDMEM_ID 0x08
  1147. #define SND_PCM_AES1_CON_BROADCAST1_MASK 0x07
  1148. #define SND_PCM_AES1_CON_BROADCAST1_ID 0x04
  1149. #define SND_PCM_AES1_CON_DIGDIGCONV_MASK 0x07
  1150. #define SND_PCM_AES1_CON_DIGDIGCONV_ID 0x02
  1151. #define SND_PCM_AES1_CON_ADC_COPYRIGHT_MASK 0x1f
  1152. #define SND_PCM_AES1_CON_ADC_COPYRIGHT_ID 0x06
  1153. #define SND_PCM_AES1_CON_ADC_MASK 0x1f
  1154. #define SND_PCM_AES1_CON_ADC_ID 0x16
  1155. #define SND_PCM_AES1_CON_BROADCAST2_MASK 0x0f
  1156. #define SND_PCM_AES1_CON_BROADCAST2_ID 0x0e
  1157. #define SND_PCM_AES1_CON_LASEROPT_MASK 0x07
  1158. #define SND_PCM_AES1_CON_LASEROPT_ID 0x01
  1159. #define SND_PCM_AES1_CON_MUSICAL_MASK 0x07
  1160. #define SND_PCM_AES1_CON_MUSICAL_ID 0x05
  1161. #define SND_PCM_AES1_CON_MAGNETIC_MASK 0x07
  1162. #define SND_PCM_AES1_CON_MAGNETIC_ID 0x03
  1163. #define SND_PCM_AES1_CON_IEC908_CD (SND_PCM_AES1_CON_LASEROPT_ID|0x00)
  1164. #define SND_PCM_AES1_CON_NON_IEC908_CD (SND_PCM_AES1_CON_LASEROPT_ID|0x08)
  1165. #define SND_PCM_AES1_CON_PCM_CODER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x00)
  1166. #define SND_PCM_AES1_CON_SAMPLER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x20)
  1167. #define SND_PCM_AES1_CON_MIXER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x10)
  1168. #define SND_PCM_AES1_CON_RATE_CONVERTER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x18)
  1169. #define SND_PCM_AES1_CON_SYNTHESIZER (SND_PCM_AES1_CON_MUSICAL_ID|0x00)
  1170. #define SND_PCM_AES1_CON_MICROPHONE (SND_PCM_AES1_CON_MUSICAL_ID|0x08)
  1171. #define SND_PCM_AES1_CON_DAT (SND_PCM_AES1_CON_MAGNETIC_ID|0x00)
  1172. #define SND_PCM_AES1_CON_VCR (SND_PCM_AES1_CON_MAGNETIC_ID|0x08)
  1173. #define SND_PCM_AES1_CON_ORIGINAL (1<<7) /* this bits depends on the category code */
  1174. #define SND_PCM_AES2_PRO_SBITS (7<<0) /* mask - sample bits */
  1175. #define SND_PCM_AES2_PRO_SBITS_20 (2<<0) /* 20-bit - coordination */
  1176. #define SND_PCM_AES2_PRO_SBITS_24 (4<<0) /* 24-bit - main audio */
  1177. #define SND_PCM_AES2_PRO_SBITS_UDEF (6<<0) /* user defined application */
  1178. #define SND_PCM_AES2_PRO_WORDLEN (7<<3) /* mask - source word length */
  1179. #define SND_PCM_AES2_PRO_WORDLEN_NOTID (0<<3) /* not indicated */
  1180. #define SND_PCM_AES2_PRO_WORDLEN_22_18 (2<<3) /* 22-bit or 18-bit */
  1181. #define SND_PCM_AES2_PRO_WORDLEN_23_19 (4<<3) /* 23-bit or 19-bit */
  1182. #define SND_PCM_AES2_PRO_WORDLEN_24_20 (5<<3) /* 24-bit or 20-bit */
  1183. #define SND_PCM_AES2_PRO_WORDLEN_20_16 (6<<3) /* 20-bit or 16-bit */
  1184. #define SND_PCM_AES2_CON_SOURCE (15<<0) /* mask - source number */
  1185. #define SND_PCM_AES2_CON_SOURCE_UNSPEC (0<<0) /* unspecified */
  1186. #define SND_PCM_AES2_CON_CHANNEL (15<<4) /* mask - channel number */
  1187. #define SND_PCM_AES2_CON_CHANNEL_UNSPEC (0<<4) /* unspecified */
  1188. #define SND_PCM_AES3_CON_FS (15<<0) /* mask - sample frequency */
  1189. #define SND_PCM_AES3_CON_FS_44100 (0<<0) /* 44.1kHz */
  1190. #define SND_PCM_AES3_CON_FS_48000 (2<<0) /* 48kHz */
  1191. #define SND_PCM_AES3_CON_FS_32000 (3<<0) /* 32kHz */
  1192. #define SND_PCM_AES3_CON_CLOCK (3<<4) /* mask - clock accuracy */
  1193. #define SND_PCM_AES3_CON_CLOCK_1000PPM (0<<4) /* 1000 ppm */
  1194. #define SND_PCM_AES3_CON_CLOCK_50PPM (1<<4) /* 50 ppm */
  1195. #define SND_PCM_AES3_CON_CLOCK_VARIABLE (2<<4) /* variable pitch */
  1197. /*
  1198.  * User interface
  1199.  */
  1201. /*
  1202.  * in this loop, dmabuf.count signifies the amount of data that is
  1203.  * waiting to be copied to the user's buffer.  it is filled by the dma
  1204.  * machine and drained by this loop.
  1205.  */
  1206. static ssize_t
  1207. ymf_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
  1208. {
  1209. struct ymf_state *state = (struct ymf_state *)file->private_data;
  1210. struct ymf_dmabuf *dmabuf = &state->rpcm.dmabuf;
  1211. struct ymf_unit *unit = state->unit;
  1212. DECLARE_WAITQUEUE(waita, current);
  1213. ssize_t ret;
  1214. unsigned long flags;
  1215. unsigned int swptr;
  1216. int cnt; /* This many to go in this revolution */
  1218. if (ppos != &file->f_pos)
  1219. return -ESPIPE;
  1220. if (dmabuf->mapped)
  1221. return -ENXIO;
  1222. if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
  1223. return ret;
  1224. ret = 0;
  1226. add_wait_queue(&dmabuf->wait, &waita);
  1227. set_current_state(TASK_INTERRUPTIBLE);
  1228. while (count > 0) {
  1229. spin_lock_irqsave(&unit->reg_lock, flags);
  1230. if (unit->suspended) {
  1231. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1232. schedule();
  1233. set_current_state(TASK_INTERRUPTIBLE);
  1234. if (signal_pending(current)) {
  1235. if (!ret) ret = -EAGAIN;
  1236. break;
  1237. }
  1238. continue;
  1239. }
  1240. swptr = dmabuf->swptr;
  1241. cnt = dmabuf->dmasize - swptr;
  1242. if (dmabuf->count < cnt)
  1243. cnt = dmabuf->count;
  1244. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1246. if (cnt > count)
  1247. cnt = count;
  1248. if (cnt <= 0) {
  1249. unsigned long tmo;
  1250. /* buffer is empty, start the dma machine and wait for data to be
  1251.    recorded */
  1252. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1253. if (!state->rpcm.running) {
  1254. ymf_capture_trigger(state->unit, &state->rpcm, 1);
  1255. }
  1256. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1257. if (file->f_flags & O_NONBLOCK) {
  1258. if (!ret) ret = -EAGAIN;
  1259. break;
  1260. }
  1261. /* This isnt strictly right for the 810  but it'll do */
  1262. tmo = (dmabuf->dmasize * HZ) / (state->format.rate * 2);
  1263. tmo >>= state->format.shift;
  1264. /* There are two situations when sleep_on_timeout returns, one is when
  1265.    the interrupt is serviced correctly and the process is waked up by
  1266.    ISR ON TIME. Another is when timeout is expired, which means that
  1267.    either interrupt is NOT serviced correctly (pending interrupt) or it
  1268.    is TOO LATE for the process to be scheduled to run (scheduler latency)
  1269.    which results in a (potential) buffer overrun. And worse, there is
  1270.    NOTHING we can do to prevent it. */
  1271. tmo = schedule_timeout(tmo);
  1272. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1273. set_current_state(TASK_INTERRUPTIBLE);
  1274. if (tmo == 0 && dmabuf->count == 0) {
  1275. printk(KERN_ERR "ymfpci%d: recording schedule timeout, "
  1276.     "dmasz %u fragsz %u count %i hwptr %u swptr %un",
  1277.     state->unit->dev_audio,
  1278.     dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
  1279.     dmabuf->hwptr, dmabuf->swptr);
  1280. }
  1281. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1282. if (signal_pending(current)) {
  1283. if (!ret) ret = -ERESTARTSYS;
  1284. break;
  1285. }
  1286. continue;
  1287. }
  1289. if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
  1290. if (!ret) ret = -EFAULT;
  1291. break;
  1292. }
  1294. swptr = (swptr + cnt) % dmabuf->dmasize;
  1296. spin_lock_irqsave(&unit->reg_lock, flags);
  1297. if (unit->suspended) {
  1298. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1299. continue;
  1300. }
  1302. dmabuf->swptr = swptr;
  1303. dmabuf->count -= cnt;
  1304. // spin_unlock_irqrestore(&unit->reg_lock, flags);
  1306. count -= cnt;
  1307. buffer += cnt;
  1308. ret += cnt;
  1309. // spin_lock_irqsave(&unit->reg_lock, flags);
  1310. if (!state->rpcm.running) {
  1311. ymf_capture_trigger(unit, &state->rpcm, 1);
  1312. }
  1313. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1314. }
  1315. set_current_state(TASK_RUNNING);
  1316. remove_wait_queue(&dmabuf->wait, &waita);
  1318. return ret;
  1319. }
  1321. static ssize_t
  1322. ymf_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
  1323. {
  1324. struct ymf_state *state = (struct ymf_state *)file->private_data;
  1325. struct ymf_dmabuf *dmabuf = &state->wpcm.dmabuf;
  1326. struct ymf_unit *unit = state->unit;
  1327. DECLARE_WAITQUEUE(waita, current);
  1328. ssize_t ret;
  1329. unsigned long flags;
  1330. unsigned int swptr;
  1331. int cnt; /* This many to go in this revolution */
  1332. int redzone;
  1333. int delay;
  1335. YMFDBGW("ymf_write: count %dn", count);
  1337. if (ppos != &file->f_pos)
  1338. return -ESPIPE;
  1339. if (dmabuf->mapped)
  1340. return -ENXIO;
  1341. if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
  1342. return ret;
  1343. ret = 0;
  1345. /*
  1346.  * Alan's cs46xx works without a red zone - marvel of ingenuity.
  1347.  * We are not so brilliant... Red zone does two things:
  1348.  *  1. allows for safe start after a pause as we have no way
  1349.  *     to know what the actual, relentlessly advancing, hwptr is.
  1350.  *  2. makes computations in ymf_pcm_interrupt simpler.
  1351.  */
  1352. redzone = ymf_calc_lend(state->format.rate) << state->format.shift;
  1353. redzone *= 3; /* 2 redzone + 1 possible uncertainty reserve. */
  1355. add_wait_queue(&dmabuf->wait, &waita);
  1356. set_current_state(TASK_INTERRUPTIBLE);
  1357. while (count > 0) {
  1358. spin_lock_irqsave(&unit->reg_lock, flags);
  1359. if (unit->suspended) {
  1360. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1361. schedule();
  1362. set_current_state(TASK_INTERRUPTIBLE);
  1363. if (signal_pending(current)) {
  1364. if (!ret) ret = -EAGAIN;
  1365. break;
  1366. }
  1367. continue;
  1368. }
  1369. if (dmabuf->count < 0) {
  1370. printk(KERN_ERR
  1371.    "ymf_write: count %d, was legal in cs46xxn",
  1372.     dmabuf->count);
  1373. dmabuf->count = 0;
  1374. }
  1375. if (dmabuf->count == 0) {
  1376. swptr = dmabuf->hwptr;
  1377. if (state->wpcm.running) {
  1378. /*
  1379.  * Add uncertainty reserve.
  1380.  */
  1381. cnt = ymf_calc_lend(state->format.rate);
  1382. cnt <<= state->format.shift;
  1383. if ((swptr += cnt) >= dmabuf->dmasize) {
  1384. swptr -= dmabuf->dmasize;
  1385. }
  1386. }
  1387. dmabuf->swptr = swptr;
  1388. } else {
  1389. /*
  1390.  * XXX This is not right if dmabuf->count is small -
  1391.  * about 2*x frame size or less. We cannot count on
  1392.  * on appending and not causing an artefact.
  1393.  * Should use a variation of the count==0 case above.
  1394.  */
  1395. swptr = dmabuf->swptr;
  1396. }
  1397. cnt = dmabuf->dmasize - swptr;
  1398. if (dmabuf->count + cnt > dmabuf->dmasize - redzone)
  1399. cnt = (dmabuf->dmasize - redzone) - dmabuf->count;
  1400. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1402. if (cnt > count)
  1403. cnt = count;
  1404. if (cnt <= 0) {
  1405. YMFDBGW("ymf_write: full, count %d swptr %dn",
  1406.    dmabuf->count, dmabuf->swptr);
  1407. /*
  1408.  * buffer is full, start the dma machine and
  1409.  * wait for data to be played
  1410.  */
  1411. spin_lock_irqsave(&unit->reg_lock, flags);
  1412. if (!state->wpcm.running) {
  1413. ymf_playback_trigger(unit, &state->wpcm, 1);
  1414. }
  1415. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1416. if (file->f_flags & O_NONBLOCK) {
  1417. if (!ret) ret = -EAGAIN;
  1418. break;
  1419. }
  1420. schedule();
  1421. set_current_state(TASK_INTERRUPTIBLE);
  1422. if (signal_pending(current)) {
  1423. if (!ret) ret = -ERESTARTSYS;
  1424. break;
  1425. }
  1426. continue;
  1427. }
  1428. if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
  1429. if (!ret) ret = -EFAULT;
  1430. break;
  1431. }
  1433. if ((swptr += cnt) >= dmabuf->dmasize) {
  1434. swptr -= dmabuf->dmasize;
  1435. }
  1437. spin_lock_irqsave(&unit->reg_lock, flags);
  1438. if (unit->suspended) {
  1439. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1440. continue;
  1441. }
  1442. dmabuf->swptr = swptr;
  1443. dmabuf->count += cnt;
  1445. /*
  1446.  * Start here is a bad idea - may cause startup click
  1447.  * in /bin/play when dmabuf is not full yet.
  1448.  * However, some broken applications do not make
  1449.  * any use of SNDCTL_DSP_SYNC (Doom is the worst).
  1450.  * One frame is about 5.3ms, Doom write size is 46ms.
  1451.  */
  1452. delay = state->format.rate / 20; /* 50ms */
  1453. delay <<= state->format.shift;
  1454. if (dmabuf->count >= delay && !state->wpcm.running) {
  1455. ymf_playback_trigger(unit, &state->wpcm, 1);
  1456. }
  1458. spin_unlock_irqrestore(&unit->reg_lock, flags);
  1460. count -= cnt;
  1461. buffer += cnt;
  1462. ret += cnt;
  1463. }
  1465. set_current_state(TASK_RUNNING);
  1466. remove_wait_queue(&dmabuf->wait, &waita);
  1468. YMFDBGW("ymf_write: ret %d dmabuf.count %dn", ret, dmabuf->count);
  1469. return ret;
  1470. }
  1472. static unsigned int ymf_poll(struct file *file, struct poll_table_struct *wait)
  1473. {
  1474. struct ymf_state *state = (struct ymf_state *)file->private_data;
  1475. struct ymf_dmabuf *dmabuf;
  1476. int redzone;
  1477. unsigned long flags;
  1478. unsigned int mask = 0;
  1480. if (file->f_mode & FMODE_WRITE)
  1481. poll_wait(file, &state->wpcm.dmabuf.wait, wait);
  1482. if (file->f_mode & FMODE_READ)
  1483. poll_wait(file, &state->rpcm.dmabuf.wait, wait);
  1485. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1486. if (file->f_mode & FMODE_READ) {
  1487. dmabuf = &state->rpcm.dmabuf;
  1488. if (dmabuf->count >= (signed)dmabuf->fragsize)
  1489. mask |= POLLIN | POLLRDNORM;
  1490. }
  1491. if (file->f_mode & FMODE_WRITE) {
  1492. redzone = ymf_calc_lend(state->format.rate);
  1493. redzone <<= state->format.shift;
  1494. redzone *= 3;
  1496. dmabuf = &state->wpcm.dmabuf;
  1497. if (dmabuf->mapped) {
  1498. if (dmabuf->count >= (signed)dmabuf->fragsize)
  1499. mask |= POLLOUT | POLLWRNORM;
  1500. } else {
  1501. /*
  1502.  * Don't select unless a full fragment is available.
  1503.  * Otherwise artsd does GETOSPACE, sees 0, and loops.
  1504.  */
  1505. if (dmabuf->count + redzone + dmabuf->fragsize
  1506.      <= dmabuf->dmasize)
  1507. mask |= POLLOUT | POLLWRNORM;
  1508. }
  1509. }
  1510. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1512. return mask;
  1513. }
  1515. static int ymf_mmap(struct file *file, struct vm_area_struct *vma)
  1516. {
  1517. struct ymf_state *state = (struct ymf_state *)file->private_data;
  1518. struct ymf_dmabuf *dmabuf = &state->wpcm.dmabuf;
  1519. int ret;
  1520. unsigned long size;
  1522. if (vma->vm_flags & VM_WRITE) {
  1523. if ((ret = prog_dmabuf(state, 0)) != 0)
  1524. return ret;
  1525. } else if (vma->vm_flags & VM_READ) {
  1526. if ((ret = prog_dmabuf(state, 1)) != 0)
  1527. return ret;
  1528. } else 
  1529. return -EINVAL;
  1531. if (vma->vm_pgoff != 0)
  1532. return -EINVAL;
  1533. size = vma->vm_end - vma->vm_start;
  1534. if (size > (PAGE_SIZE << dmabuf->buforder))
  1535. return -EINVAL;
  1536. if (remap_page_range(vma->vm_start, virt_to_phys(dmabuf->rawbuf),
  1537.      size, vma->vm_page_prot))
  1538. return -EAGAIN;
  1539. dmabuf->mapped = 1;
  1541. /* P3 */ printk(KERN_INFO "ymfpci: using memory mapped sound, untested!n");
  1542. return 0;
  1543. }
  1545. static int ymf_ioctl(struct inode *inode, struct file *file,
  1546.     unsigned int cmd, unsigned long arg)
  1547. {
  1548. struct ymf_state *state = (struct ymf_state *)file->private_data;
  1549. struct ymf_dmabuf *dmabuf;
  1550. unsigned long flags;
  1551. audio_buf_info abinfo;
  1552. count_info cinfo;
  1553. int redzone;
  1554. int val;
  1556. switch (cmd) {
  1557. case OSS_GETVERSION:
  1558. YMFDBGX("ymf_ioctl: cmd 0x%x(GETVER) arg 0x%lxn", cmd, arg);
  1559. return put_user(SOUND_VERSION, (int *)arg);
  1561. case SNDCTL_DSP_RESET:
  1562. YMFDBGX("ymf_ioctl: cmd 0x%x(RESET)n", cmd);
  1563. if (file->f_mode & FMODE_WRITE) {
  1564. ymf_wait_dac(state);
  1565. dmabuf = &state->wpcm.dmabuf;
  1566. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1567. dmabuf->ready = 0;
  1568. dmabuf->swptr = dmabuf->hwptr;
  1569. dmabuf->count = dmabuf->total_bytes = 0;
  1570. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1571. }
  1572. if (file->f_mode & FMODE_READ) {
  1573. ymf_stop_adc(state);
  1574. dmabuf = &state->rpcm.dmabuf;
  1575. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1576. dmabuf->ready = 0;
  1577. dmabuf->swptr = dmabuf->hwptr;
  1578. dmabuf->count = dmabuf->total_bytes = 0;
  1579. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1580. }
  1581. return 0;
  1583. case SNDCTL_DSP_SYNC:
  1584. YMFDBGX("ymf_ioctl: cmd 0x%x(SYNC)n", cmd);
  1585. if (file->f_mode & FMODE_WRITE) {
  1586. dmabuf = &state->wpcm.dmabuf;
  1587. if (file->f_flags & O_NONBLOCK) {
  1588. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1589. if (dmabuf->count != 0 && !state->wpcm.running) {
  1590. ymf_start_dac(state);
  1591. }
  1592. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1593. } else {
  1594. ymf_wait_dac(state);
  1595. }
  1596. }
  1597. /* XXX What does this do for reading? dmabuf->count=0; ? */
  1598. return 0;
  1600. case SNDCTL_DSP_SPEED: /* set smaple rate */
  1601. if (get_user(val, (int *)arg))
  1602. return -EFAULT;
  1603. YMFDBGX("ymf_ioctl: cmd 0x%x(SPEED) sp %dn", cmd, val);
  1604. if (val >= 8000 && val <= 48000) {
  1605. if (file->f_mode & FMODE_WRITE) {
  1606. ymf_wait_dac(state);
  1607. dmabuf = &state->wpcm.dmabuf;
  1608. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1609. dmabuf->ready = 0;
  1610. state->format.rate = val;
  1611. ymf_pcm_update_shift(&state->format);
  1612. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1613. }
  1614. if (file->f_mode & FMODE_READ) {
  1615. ymf_stop_adc(state);
  1616. dmabuf = &state->rpcm.dmabuf;
  1617. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1618. dmabuf->ready = 0;
  1619. state->format.rate = val;
  1620. ymf_pcm_update_shift(&state->format);
  1621. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1622. }
  1623. }
  1624. return put_user(state->format.rate, (int *)arg);
  1626. /*
  1627.  * OSS manual does not mention SNDCTL_DSP_STEREO at all.
  1628.  * All channels are mono and if you want stereo, you
  1629.  * play into two channels with SNDCTL_DSP_CHANNELS.
  1630.  * However, mpg123 calls it. I wonder, why Michael Hipp used it.
  1631.  */
  1632. case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
  1633. if (get_user(val, (int *)arg))
  1634. return -EFAULT;
  1635. YMFDBGX("ymf_ioctl: cmd 0x%x(STEREO) st %dn", cmd, val);
  1636. if (file->f_mode & FMODE_WRITE) {
  1637. ymf_wait_dac(state); 
  1638. dmabuf = &state->wpcm.dmabuf;
  1639. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1640. dmabuf->ready = 0;
  1641. state->format.voices = val ? 2 : 1;
  1642. ymf_pcm_update_shift(&state->format);
  1643. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1644. }
  1645. if (file->f_mode & FMODE_READ) {
  1646. ymf_stop_adc(state);
  1647. dmabuf = &state->rpcm.dmabuf;
  1648. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1649. dmabuf->ready = 0;
  1650. state->format.voices = val ? 2 : 1;
  1651. ymf_pcm_update_shift(&state->format);
  1652. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1653. }
  1654. return 0;
  1656. case SNDCTL_DSP_GETBLKSIZE:
  1657. YMFDBGX("ymf_ioctl: cmd 0x%x(GETBLK)n", cmd);
  1658. if (file->f_mode & FMODE_WRITE) {
  1659. if ((val = prog_dmabuf(state, 0)))
  1660. return val;
  1661. val = state->wpcm.dmabuf.fragsize;
  1662. YMFDBGX("ymf_ioctl: GETBLK w %dn", val);
  1663. return put_user(val, (int *)arg);
  1664. }
  1665. if (file->f_mode & FMODE_READ) {
  1666. if ((val = prog_dmabuf(state, 1)))
  1667. return val;
  1668. val = state->rpcm.dmabuf.fragsize;
  1669. YMFDBGX("ymf_ioctl: GETBLK r %dn", val);
  1670. return put_user(val, (int *)arg);
  1671. }
  1672. return -EINVAL;
  1674. case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
  1675. YMFDBGX("ymf_ioctl: cmd 0x%x(GETFMTS)n", cmd);
  1676. return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
  1678. case SNDCTL_DSP_SETFMT: /* Select sample format */
  1679. if (get_user(val, (int *)arg))
  1680. return -EFAULT;
  1681. YMFDBGX("ymf_ioctl: cmd 0x%x(SETFMT) fmt %dn", cmd, val);
  1682. if (val == AFMT_S16_LE || val == AFMT_U8) {
  1683. if (file->f_mode & FMODE_WRITE) {
  1684. ymf_wait_dac(state);
  1685. dmabuf = &state->wpcm.dmabuf;
  1686. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1687. dmabuf->ready = 0;
  1688. state->format.format = val;
  1689. ymf_pcm_update_shift(&state->format);
  1690. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1691. }
  1692. if (file->f_mode & FMODE_READ) {
  1693. ymf_stop_adc(state);
  1694. dmabuf = &state->rpcm.dmabuf;
  1695. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1696. dmabuf->ready = 0;
  1697. state->format.format = val;
  1698. ymf_pcm_update_shift(&state->format);
  1699. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1700. }
  1701. }
  1702. return put_user(state->format.format, (int *)arg);
  1704. case SNDCTL_DSP_CHANNELS:
  1705. if (get_user(val, (int *)arg))
  1706. return -EFAULT;
  1707. YMFDBGX("ymf_ioctl: cmd 0x%x(CHAN) ch %dn", cmd, val);
  1708. if (val != 0) {
  1709. if (file->f_mode & FMODE_WRITE) {
  1710. ymf_wait_dac(state);
  1711. if (val == 1 || val == 2) {
  1712. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1713. dmabuf = &state->wpcm.dmabuf;
  1714. dmabuf->ready = 0;
  1715. state->format.voices = val;
  1716. ymf_pcm_update_shift(&state->format);
  1717. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1718. }
  1719. }
  1720. if (file->f_mode & FMODE_READ) {
  1721. ymf_stop_adc(state);
  1722. if (val == 1 || val == 2) {
  1723. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1724. dmabuf = &state->rpcm.dmabuf;
  1725. dmabuf->ready = 0;
  1726. state->format.voices = val;
  1727. ymf_pcm_update_shift(&state->format);
  1728. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1729. }
  1730. }
  1731. }
  1732. return put_user(state->format.voices, (int *)arg);
  1734. case SNDCTL_DSP_POST:
  1735. YMFDBGX("ymf_ioctl: cmd 0x%x(POST)n", cmd);
  1736. /*
  1737.  * Quoting OSS PG:
  1738.  *    The ioctl SNDCTL_DSP_POST is a lightweight version of
  1739.  *    SNDCTL_DSP_SYNC. It just tells to the driver that there
  1740.  *    is likely to be a pause in the output. This makes it
  1741.  *    possible for the device to handle the pause more
  1742.  *    intelligently. This ioctl doesn't block the application.
  1743.  *
  1744.  * The paragraph above is a clumsy way to say "flush ioctl".
  1745.  * This ioctl is used by mpg123.
  1746.  */
  1747. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1748. if (state->wpcm.dmabuf.count != 0 && !state->wpcm.running) {
  1749. ymf_start_dac(state);
  1750. }
  1751. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1752. return 0;
  1754. case SNDCTL_DSP_SETFRAGMENT:
  1755. if (get_user(val, (int *)arg))
  1756. return -EFAULT;
  1757. YMFDBGX("ymf_ioctl: cmd 0x%x(SETFRAG) fr 0x%04x:%04x(%d:%d)n",
  1758.     cmd,
  1759.     (val >> 16) & 0xFFFF, val & 0xFFFF,
  1760.     (val >> 16) & 0xFFFF, val & 0xFFFF);
  1761. dmabuf = &state->wpcm.dmabuf;
  1762. dmabuf->ossfragshift = val & 0xffff;
  1763. dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
  1764. if (dmabuf->ossfragshift < 4)
  1765. dmabuf->ossfragshift = 4;
  1766. if (dmabuf->ossfragshift > 15)
  1767. dmabuf->ossfragshift = 15;
  1768. return 0;
  1770. case SNDCTL_DSP_GETOSPACE:
  1771. YMFDBGX("ymf_ioctl: cmd 0x%x(GETOSPACE)n", cmd);
  1772. if (!(file->f_mode & FMODE_WRITE))
  1773. return -EINVAL;
  1774. dmabuf = &state->wpcm.dmabuf;
  1775. if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
  1776. return val;
  1777. redzone = ymf_calc_lend(state->format.rate);
  1778. redzone <<= state->format.shift;
  1779. redzone *= 3;
  1780. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1781. abinfo.fragsize = dmabuf->fragsize;
  1782. abinfo.bytes = dmabuf->dmasize - dmabuf->count - redzone;
  1783. abinfo.fragstotal = dmabuf->numfrag;
  1784. abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
  1785. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1786. return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  1788. case SNDCTL_DSP_GETISPACE:
  1789. YMFDBGX("ymf_ioctl: cmd 0x%x(GETISPACE)n", cmd);
  1790. if (!(file->f_mode & FMODE_READ))
  1791. return -EINVAL;
  1792. dmabuf = &state->rpcm.dmabuf;
  1793. if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
  1794. return val;
  1795. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1796. abinfo.fragsize = dmabuf->fragsize;
  1797. abinfo.bytes = dmabuf->count;
  1798. abinfo.fragstotal = dmabuf->numfrag;
  1799. abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
  1800. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1801. return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  1803. case SNDCTL_DSP_NONBLOCK:
  1804. YMFDBGX("ymf_ioctl: cmd 0x%x(NONBLOCK)n", cmd);
  1805. file->f_flags |= O_NONBLOCK;
  1806. return 0;
  1808. case SNDCTL_DSP_GETCAPS:
  1809. YMFDBGX("ymf_ioctl: cmd 0x%x(GETCAPS)n", cmd);
  1810. /* return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
  1811.     (int *)arg); */
  1812. return put_user(0, (int *)arg);
  1814. case SNDCTL_DSP_GETIPTR:
  1815. YMFDBGX("ymf_ioctl: cmd 0x%x(GETIPTR)n", cmd);
  1816. if (!(file->f_mode & FMODE_READ))
  1817. return -EINVAL;
  1818. dmabuf = &state->rpcm.dmabuf;
  1819. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1820. cinfo.bytes = dmabuf->total_bytes;
  1821. cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
  1822. cinfo.ptr = dmabuf->hwptr;
  1823. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1824. YMFDBGX("ymf_ioctl: GETIPTR ptr %d bytes %dn",
  1825.     cinfo.ptr, cinfo.bytes);
  1826. return copy_to_user((void *)arg, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
  1828. case SNDCTL_DSP_GETOPTR:
  1829. YMFDBGX("ymf_ioctl: cmd 0x%x(GETOPTR)n", cmd);
  1830. if (!(file->f_mode & FMODE_WRITE))
  1831. return -EINVAL;
  1832. dmabuf = &state->wpcm.dmabuf;
  1833. spin_lock_irqsave(&state->unit->reg_lock, flags);
  1834. cinfo.bytes = dmabuf->total_bytes;
  1835. cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
  1836. cinfo.ptr = dmabuf->hwptr;
  1837. spin_unlock_irqrestore(&state->unit->reg_lock, flags);
  1838. YMFDBGX("ymf_ioctl: GETOPTR ptr %d bytes %dn",
  1839.     cinfo.ptr, cinfo.bytes);
  1840. return copy_to_user((void *)arg, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
  1842. case SNDCTL_DSP_SETDUPLEX:
  1843. YMFDBGX("ymf_ioctl: cmd 0x%x(SETDUPLEX)n", cmd);
  1844. return 0; /* Always duplex */
  1846. case SOUND_PCM_READ_RATE:
  1847. YMFDBGX("ymf_ioctl: cmd 0x%x(READ_RATE)n", cmd);
  1848. return put_user(state->format.rate, (int *)arg);
  1850. case SOUND_PCM_READ_CHANNELS:
  1851. YMFDBGX("ymf_ioctl: cmd 0x%x(READ_CH)n", cmd);
  1852. return put_user(state->format.voices, (int *)arg);
  1854. case SOUND_PCM_READ_BITS:
  1855. YMFDBGX("ymf_ioctl: cmd 0x%x(READ_BITS)n", cmd);
  1856. return put_user(AFMT_S16_LE, (int *)arg);
  1858. case SNDCTL_DSP_MAPINBUF:
  1859. case SNDCTL_DSP_MAPOUTBUF:
  1860. case SNDCTL_DSP_SETSYNCRO:
  1861. case SOUND_PCM_WRITE_FILTER:
  1862. case SOUND_PCM_READ_FILTER:
  1863. YMFDBGX("ymf_ioctl: cmd 0x%x unsupportedn", cmd);
  1864. return -ENOTTY;
  1866. default:
  1867. /*
  1868.  * Some programs mix up audio devices and ioctls
  1869.  * or perhaps they expect "universal" ioctls,
  1870.  * for instance we get SNDCTL_TMR_CONTINUE here.
  1871.  * (mpg123 -g 100 ends here too - to be fixed.)
  1872.  */
  1873. YMFDBGX("ymf_ioctl: cmd 0x%x unknownn", cmd);
  1874. break;
  1875. }
  1876. return -ENOTTY;
  1877. }
  1879. /*
  1880.  * open(2)
  1881.  * We use upper part of the minor to distinguish between soundcards.
  1882.  * Channels are opened with a clone open.
  1883.  */
  1884. static int ymf_open(struct inode *inode, struct file *file)
  1885. {
  1886. struct list_head *list;
  1887. ymfpci_t *unit = NULL;
  1888. int minor;
  1889. struct ymf_state *state;
  1890. int err;
  1892. minor = MINOR(inode->i_rdev);
  1893. if ((minor & 0x0F) == 3) { /* /dev/dspN */
  1894. ;
  1895. } else {
  1896. return -ENXIO;
  1897. }
  1899. unit = NULL; /* gcc warns */
  1900. list_for_each(list, &ymf_devs) {
  1901. unit = list_entry(list, ymfpci_t, ymf_devs);
  1902. if (((unit->dev_audio ^ minor) & ~0x0F) == 0)
  1903. break;
  1904. }
  1905. if (list == &ymf_devs)
  1906. return -ENODEV;
  1908. down(&unit->open_sem);
  1910. if ((state = ymf_state_alloc(unit)) == NULL) {
  1911. up(&unit->open_sem);
  1912. return -ENOMEM;
  1913. }
  1914. list_add_tail(&state->chain, &unit->states);
  1916. file->private_data = state;
  1918. /*
  1919.  * ymf_read and ymf_write that we borrowed from cs46xx
  1920.  * allocate buffers with prog_dmabuf(). We call prog_dmabuf
  1921.  * here so that in case of DMA memory exhaustion open
  1922.  * fails rather than write.
  1923.  *
  1924.  * XXX prog_dmabuf allocates voice. Should allocate explicitly, above.
  1925.  */
  1926. if (file->f_mode & FMODE_WRITE) {
  1927. if (!state->wpcm.dmabuf.ready) {
  1928. if ((err = prog_dmabuf(state, 0)) != 0) {
  1929. goto out_nodma;
  1930. }
  1931. }
  1932. }
  1933. if (file->f_mode & FMODE_READ) {
  1934. if (!state->rpcm.dmabuf.ready) {
  1935. if ((err = prog_dmabuf(state, 1)) != 0) {
  1936. goto out_nodma;
  1937. }
  1938. }
  1939. }
  1941. #if 0 /* test if interrupts work */
  1942. ymfpci_writew(unit, YDSXGR_TIMERCOUNT, 0xfffe); /* ~ 680ms */
  1943. ymfpci_writeb(unit, YDSXGR_TIMERCTRL,
  1944.     (YDSXGR_TIMERCTRL_TEN|YDSXGR_TIMERCTRL_TIEN));
  1945. #endif
  1946. up(&unit->open_sem);
  1948. return 0;
  1950. out_nodma:
  1951. /*
  1952.  * XXX Broken custom: "goto out_xxx" in other place is
  1953.  * a nestable exception, but here it is not nestable due to semaphore.
  1954.  * XXX Doubtful technique of self-describing objects....
  1955.  */
  1956. dealloc_dmabuf(unit, &state->wpcm.dmabuf);
  1957. dealloc_dmabuf(unit, &state->rpcm.dmabuf);
  1958. ymf_pcm_free_substream(&state->wpcm);
  1959. ymf_pcm_free_substream(&state->rpcm);
  1961. list_del(&state->chain);
  1962. kfree(state);
  1964. up(&unit->open_sem);
  1965. return err;
  1966. }
  1968. static int ymf_release(struct inode *inode, struct file *file)
  1969. {
  1970. struct ymf_state *state = (struct ymf_state *)file->private_data;
  1971. ymfpci_t *unit = state->unit;
  1973. #if 0 /* test if interrupts work */
  1974. ymfpci_writeb(unit, YDSXGR_TIMERCTRL, 0);
  1975. #endif
  1977. down(&unit->open_sem);
  1979. /*
  1980.  * XXX Solve the case of O_NONBLOCK close - don't deallocate here.
  1981.  * Deallocate when unloading the driver and we can wait.
  1982.  */
  1983. ymf_wait_dac(state);
  1984. ymf_stop_adc(state); /* fortunately, it's immediate */
  1985. dealloc_dmabuf(unit, &state->wpcm.dmabuf);
  1986. dealloc_dmabuf(unit, &state->rpcm.dmabuf);
  1987. ymf_pcm_free_substream(&state->wpcm);
  1988. ymf_pcm_free_substream(&state->rpcm);
  1990. list_del(&state->chain);
  1991. file->private_data = NULL; /* Can you tell I programmed Solaris */
  1992. kfree(state);
  1994. up(&unit->open_sem);
  1996. return 0;
  1997. }
  1999. /*
  2000.  * Mixer operations are based on cs46xx.
  2001.  */
  2002. static int ymf_open_mixdev(struct inode *inode, struct file *file)
  2003. {
  2004. int minor = MINOR(inode->i_rdev);
  2005. struct list_head *list;
  2006. ymfpci_t *unit;
  2007. int i;
  2009. list_for_each(list, &ymf_devs) {
  2010. unit = list_entry(list, ymfpci_t, ymf_devs);
  2011. for (i = 0; i < NR_AC97; i++) {
  2012. if (unit->ac97_codec[i] != NULL &&
  2013.     unit->ac97_codec[i]->dev_mixer == minor) {
  2014. goto match;
  2015. }
  2016. }
  2017. }
  2018. return -ENODEV;
  2020.  match:
  2021. file->private_data = unit->ac97_codec[i];
  2023. return 0;
  2024. }
  2026. static int ymf_ioctl_mixdev(struct inode *inode, struct file *file,
  2027.     unsigned int cmd, unsigned long arg)
  2028. {
  2029. struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
  2031. return codec->mixer_ioctl(codec, cmd, arg);
  2032. }
  2034. static int ymf_release_mixdev(struct inode *inode, struct file *file)
  2035. {
  2036. return 0;
  2037. }
  2039. static /*const*/ struct file_operations ymf_fops = {
  2040. owner: THIS_MODULE,
  2041. llseek: no_llseek,
  2042. read: ymf_read,
  2043. write: ymf_write,
  2044. poll: ymf_poll,
  2045. ioctl: ymf_ioctl,
  2046. mmap: ymf_mmap,
  2047. open: ymf_open,
  2048. release: ymf_release,
  2049. };
  2051. static /*const*/ struct file_operations ymf_mixer_fops = {
  2052. owner: THIS_MODULE,
  2053. llseek: no_llseek,
  2054. ioctl: ymf_ioctl_mixdev,
  2055. open: ymf_open_mixdev,
  2056. release: ymf_release_mixdev,
  2057. };
  2059. /*
  2060.  */
  2062. static int ymf_suspend(struct pci_dev *pcidev, u32 unused)
  2063. {
  2064. struct ymf_unit *unit = pci_get_drvdata(pcidev);
  2065. unsigned long flags;
  2066. struct ymf_dmabuf *dmabuf;
  2067. struct list_head *p;
  2068. struct ymf_state *state;
  2069. struct ac97_codec *codec;
  2070. int i;
  2072. spin_lock_irqsave(&unit->reg_lock, flags);
  2074. unit->suspended = 1;
  2076. for (i = 0; i < NR_AC97; i++) {
  2077. if ((codec = unit->ac97_codec[i]) != NULL)
  2078. ac97_save_state(codec);
  2079. }
  2081. list_for_each(p, &unit->states) {
  2082. state = list_entry(p, struct ymf_state, chain);
  2084. dmabuf = &state->wpcm.dmabuf;
  2085. dmabuf->hwptr = dmabuf->swptr = 0;
  2086. dmabuf->total_bytes = 0;
  2087. dmabuf->count = 0;
  2089. dmabuf = &state->rpcm.dmabuf;
  2090. dmabuf->hwptr = dmabuf->swptr = 0;
  2091. dmabuf->total_bytes = 0;
  2092. dmabuf->count = 0;
  2093. }
  2095. ymfpci_writel(unit, YDSXGR_NATIVEDACOUTVOL, 0);
  2096. ymfpci_disable_dsp(unit);
  2098. spin_unlock_irqrestore(&unit->reg_lock, flags);
  2100. return 0;
  2101. }
  2103. static int ymf_resume(struct pci_dev *pcidev)
  2104. {
  2105. struct ymf_unit *unit = pci_get_drvdata(pcidev);
  2106. unsigned long flags;
  2107. struct list_head *p;
  2108. struct ymf_state *state;
  2109. struct ac97_codec *codec;
  2110. int i;
  2112. ymfpci_aclink_reset(unit->pci);
  2113. ymfpci_codec_ready(unit, 0, 1); /* prints diag if not ready. */
  2115. #ifdef CONFIG_SOUND_YMFPCI_LEGACY
  2116. /* XXX At this time the legacy registers are probably deprogrammed. */
  2117. #endif
  2119. ymfpci_download_image(unit);
  2121. ymf_memload(unit);
  2123. spin_lock_irqsave(&unit->reg_lock, flags);
  2125. if (unit->start_count) {
  2126. ymfpci_writel(unit, YDSXGR_MODE, 3);
  2127. unit->active_bank = ymfpci_readl(unit, YDSXGR_CTRLSELECT) & 1;
  2128. }
  2130. for (i = 0; i < NR_AC97; i++) {
  2131. if ((codec = unit->ac97_codec[i]) != NULL)
  2132. ac97_restore_state(codec);
  2133. }
  2135. unit->suspended = 0;
  2136. list_for_each(p, &unit->states) {
  2137. state = list_entry(p, struct ymf_state, chain);
  2138. wake_up(&state->wpcm.dmabuf.wait);
  2139. wake_up(&state->rpcm.dmabuf.wait);
  2140. }
  2142. spin_unlock_irqrestore(&unit->reg_lock, flags);
  2143. return 0;
  2144. }
  2146. /*
  2147.  *  initialization routines
  2148.  */
  2150. #ifdef CONFIG_SOUND_YMFPCI_LEGACY
  2152. static int ymfpci_setup_legacy(ymfpci_t *unit, struct pci_dev *pcidev)
  2153. {
  2154. int v;
  2155. int mpuio = -1, oplio = -1;
  2157. switch (unit->iomidi) {
  2158. case 0x330:
  2159. mpuio = 0;
  2160. break;
  2161. case 0x300:
  2162. mpuio = 1;
  2163. break;
  2164. case 0x332:
  2165. mpuio = 2;
  2166. break;
  2167. case 0x334:
  2168. mpuio = 3;
  2169. break;
  2170. default: ;
  2171. }
  2173. switch (unit->iosynth) {
  2174. case 0x388:
  2175. oplio = 0;
  2176. break;
  2177. case 0x398:
  2178. oplio = 1;
  2179. break;
  2180. case 0x3a0:
  2181. oplio = 2;
  2182. break;
  2183. case 0x3a8:
  2184. oplio = 3;
  2185. break;
  2186. default: ;
  2187. }
  2189. if (mpuio >= 0 || oplio >= 0) {
  2190. /* 0x0020: 1 - 10 bits of I/O address decoded, 0 - 16 bits. */
  2191. v = 0x001e;
  2192. pci_write_config_word(pcidev, PCIR_LEGCTRL, v);
  2194. switch (pcidev->device) {
  2195. case PCI_DEVICE_ID_YAMAHA_724:
  2196. case PCI_DEVICE_ID_YAMAHA_740:
  2197. case PCI_DEVICE_ID_YAMAHA_724F:
  2198. case PCI_DEVICE_ID_YAMAHA_740C:
  2199. v = 0x8800;
  2200. if (mpuio >= 0) { v |= mpuio<<4; }
  2201. if (oplio >= 0) { v |= oplio; }
  2202. pci_write_config_word(pcidev, PCIR_ELEGCTRL, v);
  2203. break;
  2205. case PCI_DEVICE_ID_YAMAHA_744:
  2206. case PCI_DEVICE_ID_YAMAHA_754:
  2207. v = 0x8800;
  2208. pci_write_config_word(pcidev, PCIR_ELEGCTRL, v);
  2209. if (oplio >= 0) {
  2210. pci_write_config_word(pcidev, PCIR_OPLADR, unit->iosynth);
  2211. }
  2212. if (mpuio >= 0) {
  2213. pci_write_config_word(pcidev, PCIR_MPUADR, unit->iomidi);
  2214. }
  2215. break;
  2217. default:
  2218. printk(KERN_ERR "ymfpci: Unknown device ID: 0x%xn",
  2219.     pcidev->device);
  2220. return -EINVAL;
  2221. }
  2222. }
  2224. return 0;
  2225. }
  2226. #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
  2228. static void ymfpci_aclink_reset(struct pci_dev * pci)
  2229. {
  2230. u8 cmd;
  2232. /*
  2233.  * In the 744, 754 only 0x01 exists, 0x02 is undefined.
  2234.  * It does not seem to hurt to trip both regardless of revision.
  2235.  */
  2236. pci_read_config_byte(pci, PCIR_DSXGCTRL, &cmd);
  2237. pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd & 0xfc);
  2238. pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd | 0x03);
  2239. pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd & 0xfc);
  2241. pci_write_config_word(pci, PCIR_DSXPWRCTRL1, 0);
  2242. pci_write_config_word(pci, PCIR_DSXPWRCTRL2, 0);
  2243. }
  2245. static void ymfpci_enable_dsp(ymfpci_t *codec)
  2246. {
  2247. ymfpci_writel(codec, YDSXGR_CONFIG, 0x00000001);
  2248. }
  2250. static void ymfpci_disable_dsp(ymfpci_t *codec)
  2251. {
  2252. u32 val;
  2253. int timeout = 1000;
  2255. val = ymfpci_readl(codec, YDSXGR_CONFIG);
  2256. if (val)
  2257. ymfpci_writel(codec, YDSXGR_CONFIG, 0x00000000);
  2258. while (timeout-- > 0) {
  2259. val = ymfpci_readl(codec, YDSXGR_STATUS);
  2260. if ((val & 0x00000002) == 0)
  2261. break;
  2262. }
  2263. }
  2265. #include "ymfpci_image.h"
  2267. static void ymfpci_download_image(ymfpci_t *codec)
  2268. {
  2269. int i, ver_1e;
  2270. u16 ctrl;
  2272. ymfpci_writel(codec, YDSXGR_NATIVEDACOUTVOL, 0x00000000);
  2273. ymfpci_disable_dsp(codec);
  2274. ymfpci_writel(codec, YDSXGR_MODE, 0x00010000);
  2275. ymfpci_writel(codec, YDSXGR_MODE, 0x00000000);
  2276. ymfpci_writel(codec, YDSXGR_MAPOFREC, 0x00000000);
  2277. ymfpci_writel(codec, YDSXGR_MAPOFEFFECT, 0x00000000);
  2278. ymfpci_writel(codec, YDSXGR_PLAYCTRLBASE, 0x00000000);
  2279. ymfpci_writel(codec, YDSXGR_RECCTRLBASE, 0x00000000);
  2280. ymfpci_writel(codec, YDSXGR_EFFCTRLBASE, 0x00000000);
  2281. ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
  2282. ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
  2284. /* setup DSP instruction code */
  2285. for (i = 0; i < YDSXG_DSPLENGTH / 4; i++)
  2286. ymfpci_writel(codec, YDSXGR_DSPINSTRAM + (i << 2), DspInst[i]);
  2288. switch (codec->pci->device) {
  2289. case PCI_DEVICE_ID_YAMAHA_724F:
  2290. case PCI_DEVICE_ID_YAMAHA_740C:
  2291. case PCI_DEVICE_ID_YAMAHA_744:
  2292. case PCI_DEVICE_ID_YAMAHA_754:
  2293. ver_1e = 1;
  2294. break;
  2295. default:
  2296. ver_1e = 0;
  2297. }
  2299. if (ver_1e) {
  2300. /* setup control instruction code */
  2301. for (i = 0; i < YDSXG_CTRLLENGTH / 4; i++)
  2302. ymfpci_writel(codec, YDSXGR_CTRLINSTRAM + (i << 2), CntrlInst1E[i]);
  2303. } else {
  2304. for (i = 0; i < YDSXG_CTRLLENGTH / 4; i++)
  2305. ymfpci_writel(codec, YDSXGR_CTRLINSTRAM + (i << 2), CntrlInst[i]);
  2306. }
  2308. ymfpci_enable_dsp(codec);
  2310. /* 0.02s sounds not too bad, we may do schedule_timeout() later. */
  2311. mdelay(20); /* seems we need some delay after downloading image.. */
  2312. }
  2314. static int ymfpci_memalloc(ymfpci_t *codec)
  2315. {
  2316. unsigned int playback_ctrl_size;
  2317. unsigned int bank_size_playback;
  2318. unsigned int bank_size_capture;
  2319. unsigned int bank_size_effect;
  2320. unsigned int size;
  2321. unsigned int off;
  2322. char *ptr;
  2323. dma_addr_t pba;
  2324. int voice, bank;
  2326. playback_ctrl_size = 4 + 4 * YDSXG_PLAYBACK_VOICES;
  2327. bank_size_playback = ymfpci_readl(codec, YDSXGR_PLAYCTRLSIZE) << 2;
  2328. bank_size_capture = ymfpci_readl(codec, YDSXGR_RECCTRLSIZE) << 2;
  2329. bank_size_effect = ymfpci_readl(codec, YDSXGR_EFFCTRLSIZE) << 2;
  2330. codec->work_size = YDSXG_DEFAULT_WORK_SIZE;
  2332. size = ((playback_ctrl_size + 0x00ff) & ~0x00ff) +
  2333.     ((bank_size_playback * 2 * YDSXG_PLAYBACK_VOICES + 0xff) & ~0xff) +
  2334.     ((bank_size_capture * 2 * YDSXG_CAPTURE_VOICES + 0xff) & ~0xff) +
  2335.     ((bank_size_effect * 2 * YDSXG_EFFECT_VOICES + 0xff) & ~0xff) +
  2336.     codec->work_size;
  2338. ptr = pci_alloc_consistent(codec->pci, size + 0xff, &pba);
  2339. if (ptr == NULL)
  2340. return -ENOMEM;
  2341. codec->dma_area_va = ptr;
  2342. codec->dma_area_ba = pba;
  2343. codec->dma_area_size = size + 0xff;
  2345. if ((off = ((uint) ptr) & 0xff) != 0) {
  2346. ptr += 0x100 - off;
  2347. pba += 0x100 - off;
  2348. }
  2350. /*
  2351.  * Hardware requires only ptr[playback_ctrl_size] zeroed,
  2352.  * but in our judgement it is a wrong kind of savings, so clear it all.
  2353.  */
  2354. memset(ptr, 0, size);
  2356. codec->ctrl_playback = (u32 *)ptr;
  2357. codec->ctrl_playback_ba = pba;
  2358. codec->ctrl_playback[0] = cpu_to_le32(YDSXG_PLAYBACK_VOICES);
  2359. ptr += (playback_ctrl_size + 0x00ff) & ~0x00ff;
  2360. pba += (playback_ctrl_size + 0x00ff) & ~0x00ff;
  2362. off = 0;
  2363. for (voice = 0; voice < YDSXG_PLAYBACK_VOICES; voice++) {
  2364. codec->voices[voice].number = voice;
  2365. codec->voices[voice].bank =
  2366.     (ymfpci_playback_bank_t *) (ptr + off);
  2367. codec->voices[voice].bank_ba = pba + off;
  2368. off += 2 * bank_size_playback; /* 2 banks */
  2369. }
  2370. off = (off + 0xff) & ~0xff;
  2371. ptr += off;
  2372. pba += off;
  2374. off = 0;
  2375. codec->bank_base_capture = pba;
  2376. for (voice = 0; voice < YDSXG_CAPTURE_VOICES; voice++)
  2377. for (bank = 0; bank < 2; bank++) {
  2378. codec->bank_capture[voice][bank] =
  2379.     (ymfpci_capture_bank_t *) (ptr + off);
  2380. off += bank_size_capture;
  2381. }
  2382. off = (off + 0xff) & ~0xff;
  2383. ptr += off;
  2384. pba += off;
  2386. off = 0;
  2387. codec->bank_base_effect = pba;
  2388. for (voice = 0; voice < YDSXG_EFFECT_VOICES; voice++)
  2389. for (bank = 0; bank < 2; bank++) {
  2390. codec->bank_effect[voice][bank] =
  2391.     (ymfpci_effect_bank_t *) (ptr + off);
  2392. off += bank_size_effect;
  2393. }
  2394. off = (off + 0xff) & ~0xff;
  2395. ptr += off;
  2396. pba += off;
  2398. codec->work_base = pba;
  2400. return 0;
  2401. }
  2403. static void ymfpci_memfree(ymfpci_t *codec)
  2404. {
  2405. ymfpci_writel(codec, YDSXGR_PLAYCTRLBASE, 0);
  2406. ymfpci_writel(codec, YDSXGR_RECCTRLBASE, 0);
  2407. ymfpci_writel(codec, YDSXGR_EFFCTRLBASE, 0);
  2408. ymfpci_writel(codec, YDSXGR_WORKBASE, 0);
  2409. ymfpci_writel(codec, YDSXGR_WORKSIZE, 0);
  2410. pci_free_consistent(codec->pci,
  2411.     codec->dma_area_size, codec->dma_area_va, codec->dma_area_ba);
  2412. }
  2414. static void ymf_memload(ymfpci_t *unit)
  2415. {
  2417. ymfpci_writel(unit, YDSXGR_PLAYCTRLBASE, unit->ctrl_playback_ba);
  2418. ymfpci_writel(unit, YDSXGR_RECCTRLBASE, unit->bank_base_capture);
  2419. ymfpci_writel(unit, YDSXGR_EFFCTRLBASE, unit->bank_base_effect);
  2420. ymfpci_writel(unit, YDSXGR_WORKBASE, unit->work_base);
  2421. ymfpci_writel(unit, YDSXGR_WORKSIZE, unit->work_size >> 2);
  2423. /* S/PDIF output initialization */
  2424. ymfpci_writew(unit, YDSXGR_SPDIFOUTCTRL, 0);
  2425. ymfpci_writew(unit, YDSXGR_SPDIFOUTSTATUS,
  2426. SND_PCM_AES0_CON_EMPHASIS_NONE |
  2427. (SND_PCM_AES1_CON_ORIGINAL << 8) |
  2428. (SND_PCM_AES1_CON_PCM_CODER << 8));
  2430. /* S/PDIF input initialization */
  2431. ymfpci_writew(unit, YDSXGR_SPDIFINCTRL, 0);
  2433. /* move this volume setup to mixer */
  2434. ymfpci_writel(unit, YDSXGR_NATIVEDACOUTVOL, 0x3fff3fff);
  2435. ymfpci_writel(unit, YDSXGR_BUF441OUTVOL, 0);
  2436. ymfpci_writel(unit, YDSXGR_NATIVEADCINVOL, 0x3fff3fff);
  2437. ymfpci_writel(unit, YDSXGR_NATIVEDACINVOL, 0x3fff3fff);
  2438. }
  2440. static int ymf_ac97_init(ymfpci_t *unit, int num_ac97)
  2441. {
  2442. struct ac97_codec *codec;
  2443. u16 eid;
  2445. if ((codec = kmalloc(sizeof(struct ac97_codec), GFP_KERNEL)) == NULL)
  2446. return -ENOMEM;
  2447. memset(codec, 0, sizeof(struct ac97_codec));
  2449. /* initialize some basic codec information, other fields will be filled
  2450.    in ac97_probe_codec */
  2451. codec->private_data = unit;
  2452. codec->id = num_ac97;
  2454. codec->codec_read = ymfpci_codec_read;
  2455. codec->codec_write = ymfpci_codec_write;
  2457. if (ac97_probe_codec(codec) == 0) {
  2458. printk(KERN_ERR "ymfpci: ac97_probe_codec failedn");
  2459. goto out_kfree;
  2460. }
  2462. eid = ymfpci_codec_read(codec, AC97_EXTENDED_ID);
  2463. if (eid==0xFFFFFF) {
  2464. printk(KERN_WARNING "ymfpci: no codec attached ?n");
  2465. goto out_kfree;
  2466. }
  2468. unit->ac97_features = eid;
  2470. if ((codec->dev_mixer = register_sound_mixer(&ymf_mixer_fops, -1)) < 0) {
  2471. printk(KERN_ERR "ymfpci: couldn't register mixer!n");
  2472. goto out_kfree;
  2473. }
  2475. unit->ac97_codec[num_ac97] = codec;
  2477. return 0;
  2478.  out_kfree:
  2479. kfree(codec);
  2480. return -ENODEV;
  2481. }
  2483. #ifdef CONFIG_SOUND_YMFPCI_LEGACY
  2484. # ifdef MODULE
  2485. static int mpu_io     = 0;
  2486. static int synth_io   = 0;
  2487. MODULE_PARM(mpu_io, "i");
  2488. MODULE_PARM(synth_io, "i");
  2489. # else
  2490. static int mpu_io     = 0x330;
  2491. static int synth_io   = 0x388;
  2492. # endif
  2493. static int assigned;
  2494. #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
  2496. static int __devinit ymf_probe_one(struct pci_dev *pcidev, const struct pci_device_id *ent)
  2497. {
  2498. u16 ctrl;
  2499. unsigned long base;
  2500. ymfpci_t *codec;
  2502. int err;
  2504. if ((err = pci_enable_device(pcidev)) != 0) {
  2505. printk(KERN_ERR "ymfpci: pci_enable_device failedn");
  2506. return err;
  2507. }
  2508. base = pci_resource_start(pcidev, 0);
  2510. if ((codec = kmalloc(sizeof(ymfpci_t), GFP_KERNEL)) == NULL) {
  2511. printk(KERN_ERR "ymfpci: no coren");
  2512. return -ENOMEM;
  2513. }
  2514. memset(codec, 0, sizeof(*codec));
  2516. spin_lock_init(&codec->reg_lock);
  2517. spin_lock_init(&codec->voice_lock);
  2518. init_MUTEX(&codec->open_sem);
  2519. INIT_LIST_HEAD(&codec->states);
  2520. codec->pci = pcidev;
  2522. pci_read_config_byte(pcidev, PCI_REVISION_ID, &codec->rev);
  2524. if (request_mem_region(base, 0x8000, "ymfpci") == NULL) {
  2525. printk(KERN_ERR "ymfpci: unable to request mem regionn");
  2526. goto out_free;
  2527. }
  2529. if ((codec->reg_area_virt = ioremap(base, 0x8000)) == NULL) {
  2530. printk(KERN_ERR "ymfpci: unable to map registersn");
  2531. goto out_release_region;
  2532. }
  2534. pci_set_master(pcidev);
  2536. printk(KERN_INFO "ymfpci: %s at 0x%lx IRQ %dn",
  2537.     (char *)ent->driver_data, base, pcidev->irq);
  2539. ymfpci_aclink_reset(pcidev);
  2540. if (ymfpci_codec_ready(codec, 0, 1) < 0)
  2541. goto out_unmap;
  2543. #ifdef CONFIG_SOUND_YMFPCI_LEGACY
  2544. if (assigned == 0) {
  2545. codec->iomidi = mpu_io;
  2546. codec->iosynth = synth_io;
  2547. if (ymfpci_setup_legacy(codec, pcidev) < 0)
  2548. goto out_unmap;
  2549. assigned = 1;
  2550. }
  2551. #endif
  2553. ymfpci_download_image(codec);
  2555. if (ymfpci_memalloc(codec) < 0)
  2556. goto out_disable_dsp;
  2557. ymf_memload(codec);
  2559. if (request_irq(pcidev->irq, ymf_interrupt, SA_SHIRQ, "ymfpci", codec) != 0) {
  2560. printk(KERN_ERR "ymfpci: unable to request IRQ %dn",
  2561.     pcidev->irq);
  2562. goto out_memfree;
  2563. }
  2565. /* register /dev/dsp */
  2566. if ((codec->dev_audio = register_sound_dsp(&ymf_fops, -1)) < 0) {
  2567. printk(KERN_ERR "ymfpci: unable to register dspn");
  2568. goto out_free_irq;
  2569. }
  2571. /*
  2572.  * Poke just the primary for the moment.
  2573.  */
  2574. if ((err = ymf_ac97_init(codec, 0)) != 0)
  2575. goto out_unregister_sound_dsp;
  2577. #ifdef CONFIG_SOUND_YMFPCI_LEGACY
  2578. codec->opl3_data.name = "ymfpci";
  2579. codec->mpu_data.name  = "ymfpci";
  2581. codec->opl3_data.io_base = codec->iosynth;
  2582. codec->opl3_data.irq     = -1;
  2584. codec->mpu_data.io_base  = codec->iomidi;
  2585. codec->mpu_data.irq      = -1; /* May be different from our PCI IRQ. */
  2587. if (codec->iomidi) {
  2588. if (!probe_uart401(&codec->mpu_data, THIS_MODULE)) {
  2589. codec->iomidi = 0; /* XXX kludge */
  2590. }
  2591. }
  2592. #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
  2594. /* put it into driver list */
  2595. list_add_tail(&codec->ymf_devs, &ymf_devs);
  2596. pci_set_drvdata(pcidev, codec);
  2598. return 0;
  2600.  out_unregister_sound_dsp:
  2601. unregister_sound_dsp(codec->dev_audio);
  2602.  out_free_irq:
  2603. free_irq(pcidev->irq, codec);
  2604.  out_memfree:
  2605. ymfpci_memfree(codec);
  2606.  out_disable_dsp:
  2607. ymfpci_disable_dsp(codec);
  2608. ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
  2609. ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
  2610. ymfpci_writel(codec, YDSXGR_STATUS, ~0);
  2611.  out_unmap:
  2612. iounmap(codec->reg_area_virt);
  2613.  out_release_region:
  2614. release_mem_region(pci_resource_start(pcidev, 0), 0x8000);
  2615.  out_free:
  2616. kfree(codec);
  2617. return -ENODEV;
  2618. }
  2620. static void __devexit ymf_remove_one(struct pci_dev *pcidev)
  2621. {
  2622. __u16 ctrl;
  2623. ymfpci_t *codec = pci_get_drvdata(pcidev);
  2625. /* remove from list of devices */
  2626. list_del(&codec->ymf_devs);
  2628. unregister_sound_mixer(codec->ac97_codec[0]->dev_mixer);
  2629. kfree(codec->ac97_codec[0]);
  2630. unregister_sound_dsp(codec->dev_audio);
  2631. free_irq(pcidev->irq, codec);
  2632. ymfpci_memfree(codec);
  2633. ymfpci_writel(codec, YDSXGR_STATUS, ~0);
  2634. ymfpci_disable_dsp(codec);
  2635. ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
  2636. ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
  2637. iounmap(codec->reg_area_virt);
  2638. release_mem_region(pci_resource_start(pcidev, 0), 0x8000);
  2639. #ifdef CONFIG_SOUND_YMFPCI_LEGACY
  2640. if (codec->iomidi) {
  2641. unload_uart401(&codec->mpu_data);
  2642. }
  2643. #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
  2644. kfree(codec);
  2645. }
  2647. MODULE_AUTHOR("Jaroslav Kysela");
  2648. MODULE_DESCRIPTION("Yamaha YMF7xx PCI Audio");
  2649. MODULE_LICENSE("GPL");
  2651. static struct pci_driver ymfpci_driver = {
  2652. name: "ymfpci",
  2653. id_table: ymf_id_tbl,
  2654. probe: ymf_probe_one,
  2655. remove:         __devexit_p(ymf_remove_one),
  2656. suspend: ymf_suspend,
  2657. resume: ymf_resume
  2658. };
  2660. static int __init ymf_init_module(void)
  2661. {
  2662. return pci_module_init(&ymfpci_driver);
  2663. }
  2665. static void __exit ymf_cleanup_module (void)
  2666. {
  2667. pci_unregister_driver(&ymfpci_driver);
  2668. }
  2670. module_init(ymf_init_module);
  2671. module_exit(ymf_cleanup_module);