emu8000_pcm.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701
  1. /*
  2. * pcm emulation on emu8000 wavetable
  3. *
  4. * Copyright (C) 2002 Takashi Iwai <tiwai@suse.de>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19. */
  20. #include "emu8000_local.h"
  21. #include <linux/init.h>
  22. #include <sound/initval.h>
  23. #include <sound/pcm.h>
  24. /*
  25. * define the following if you want to use this pcm with non-interleaved mode
  26. */
  27. /* #define USE_NONINTERLEAVE */
  28. /* NOTE: for using the non-interleaved mode with alsa-lib, you have to set
  29. * mmap_emulation flag to 1 in your .asoundrc, such like
  30. *
  31. * pcm.emu8k {
  32. * type plug
  33. * slave.pcm {
  34. * type hw
  35. * card 0
  36. * device 1
  37. * mmap_emulation 1
  38. * }
  39. * }
  40. *
  41. * besides, for the time being, the non-interleaved mode doesn't work well on
  42. * alsa-lib...
  43. */
  44. struct snd_emu8k_pcm {
  45. struct snd_emu8000 *emu;
  46. struct snd_pcm_substream *substream;
  47. unsigned int allocated_bytes;
  48. struct snd_util_memblk *block;
  49. unsigned int offset;
  50. unsigned int buf_size;
  51. unsigned int period_size;
  52. unsigned int loop_start[2];
  53. unsigned int pitch;
  54. int panning[2];
  55. int last_ptr;
  56. int period_pos;
  57. int voices;
  58. unsigned int dram_opened: 1;
  59. unsigned int running: 1;
  60. unsigned int timer_running: 1;
  61. struct timer_list timer;
  62. spinlock_t timer_lock;
  63. };
  64. #define LOOP_BLANK_SIZE 8
  65. /*
  66. * open up channels for the simultaneous data transfer and playback
  67. */
  68. static int
  69. emu8k_open_dram_for_pcm(struct snd_emu8000 *emu, int channels)
  70. {
  71. int i;
  72. /* reserve up to 2 voices for playback */
  73. snd_emux_lock_voice(emu->emu, 0);
  74. if (channels > 1)
  75. snd_emux_lock_voice(emu->emu, 1);
  76. /* reserve 28 voices for loading */
  77. for (i = channels + 1; i < EMU8000_DRAM_VOICES; i++) {
  78. unsigned int mode = EMU8000_RAM_WRITE;
  79. snd_emux_lock_voice(emu->emu, i);
  80. #ifndef USE_NONINTERLEAVE
  81. if (channels > 1 && (i & 1) != 0)
  82. mode |= EMU8000_RAM_RIGHT;
  83. #endif
  84. snd_emu8000_dma_chan(emu, i, mode);
  85. }
  86. /* assign voice 31 and 32 to ROM */
  87. EMU8000_VTFT_WRITE(emu, 30, 0);
  88. EMU8000_PSST_WRITE(emu, 30, 0x1d8);
  89. EMU8000_CSL_WRITE(emu, 30, 0x1e0);
  90. EMU8000_CCCA_WRITE(emu, 30, 0x1d8);
  91. EMU8000_VTFT_WRITE(emu, 31, 0);
  92. EMU8000_PSST_WRITE(emu, 31, 0x1d8);
  93. EMU8000_CSL_WRITE(emu, 31, 0x1e0);
  94. EMU8000_CCCA_WRITE(emu, 31, 0x1d8);
  95. return 0;
  96. }
  97. /*
  98. */
  99. static void
  100. snd_emu8000_write_wait(struct snd_emu8000 *emu, int can_schedule)
  101. {
  102. while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) {
  103. if (can_schedule) {
  104. schedule_timeout_interruptible(1);
  105. if (signal_pending(current))
  106. break;
  107. }
  108. }
  109. }
  110. /*
  111. * close all channels
  112. */
  113. static void
  114. emu8k_close_dram(struct snd_emu8000 *emu)
  115. {
  116. int i;
  117. for (i = 0; i < 2; i++)
  118. snd_emux_unlock_voice(emu->emu, i);
  119. for (; i < EMU8000_DRAM_VOICES; i++) {
  120. snd_emu8000_dma_chan(emu, i, EMU8000_RAM_CLOSE);
  121. snd_emux_unlock_voice(emu->emu, i);
  122. }
  123. }
  124. /*
  125. * convert Hz to AWE32 rate offset (see emux/soundfont.c)
  126. */
  127. #define OFFSET_SAMPLERATE 1011119 /* base = 44100 */
  128. #define SAMPLERATE_RATIO 4096
  129. static int calc_rate_offset(int hz)
  130. {
  131. return snd_sf_linear_to_log(hz, OFFSET_SAMPLERATE, SAMPLERATE_RATIO);
  132. }
  133. /*
  134. */
  135. static struct snd_pcm_hardware emu8k_pcm_hw = {
  136. #ifdef USE_NONINTERLEAVE
  137. .info = SNDRV_PCM_INFO_NONINTERLEAVED,
  138. #else
  139. .info = SNDRV_PCM_INFO_INTERLEAVED,
  140. #endif
  141. .formats = SNDRV_PCM_FMTBIT_S16_LE,
  142. .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
  143. .rate_min = 4000,
  144. .rate_max = 48000,
  145. .channels_min = 1,
  146. .channels_max = 2,
  147. .buffer_bytes_max = (128*1024),
  148. .period_bytes_min = 1024,
  149. .period_bytes_max = (128*1024),
  150. .periods_min = 2,
  151. .periods_max = 1024,
  152. .fifo_size = 0,
  153. };
  154. /*
  155. * get the current position at the given channel from CCCA register
  156. */
  157. static inline int emu8k_get_curpos(struct snd_emu8k_pcm *rec, int ch)
  158. {
  159. int val = EMU8000_CCCA_READ(rec->emu, ch) & 0xfffffff;
  160. val -= rec->loop_start[ch] - 1;
  161. return val;
  162. }
  163. /*
  164. * timer interrupt handler
  165. * check the current position and update the period if necessary.
  166. */
  167. static void emu8k_pcm_timer_func(unsigned long data)
  168. {
  169. struct snd_emu8k_pcm *rec = (struct snd_emu8k_pcm *)data;
  170. int ptr, delta;
  171. spin_lock(&rec->timer_lock);
  172. /* update the current pointer */
  173. ptr = emu8k_get_curpos(rec, 0);
  174. if (ptr < rec->last_ptr)
  175. delta = ptr + rec->buf_size - rec->last_ptr;
  176. else
  177. delta = ptr - rec->last_ptr;
  178. rec->period_pos += delta;
  179. rec->last_ptr = ptr;
  180. /* reprogram timer */
  181. rec->timer.expires = jiffies + 1;
  182. add_timer(&rec->timer);
  183. /* update period */
  184. if (rec->period_pos >= (int)rec->period_size) {
  185. rec->period_pos %= rec->period_size;
  186. spin_unlock(&rec->timer_lock);
  187. snd_pcm_period_elapsed(rec->substream);
  188. return;
  189. }
  190. spin_unlock(&rec->timer_lock);
  191. }
  192. /*
  193. * open pcm
  194. * creating an instance here
  195. */
  196. static int emu8k_pcm_open(struct snd_pcm_substream *subs)
  197. {
  198. struct snd_emu8000 *emu = snd_pcm_substream_chip(subs);
  199. struct snd_emu8k_pcm *rec;
  200. struct snd_pcm_runtime *runtime = subs->runtime;
  201. rec = kzalloc(sizeof(*rec), GFP_KERNEL);
  202. if (! rec)
  203. return -ENOMEM;
  204. rec->emu = emu;
  205. rec->substream = subs;
  206. runtime->private_data = rec;
  207. spin_lock_init(&rec->timer_lock);
  208. init_timer(&rec->timer);
  209. rec->timer.function = emu8k_pcm_timer_func;
  210. rec->timer.data = (unsigned long)rec;
  211. runtime->hw = emu8k_pcm_hw;
  212. runtime->hw.buffer_bytes_max = emu->mem_size - LOOP_BLANK_SIZE * 3;
  213. runtime->hw.period_bytes_max = runtime->hw.buffer_bytes_max / 2;
  214. /* use timer to update periods.. (specified in msec) */
  215. snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
  216. (1000000 + HZ - 1) / HZ, UINT_MAX);
  217. return 0;
  218. }
  219. static int emu8k_pcm_close(struct snd_pcm_substream *subs)
  220. {
  221. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  222. kfree(rec);
  223. subs->runtime->private_data = NULL;
  224. return 0;
  225. }
  226. /*
  227. * calculate pitch target
  228. */
  229. static int calc_pitch_target(int pitch)
  230. {
  231. int ptarget = 1 << (pitch >> 12);
  232. if (pitch & 0x800) ptarget += (ptarget * 0x102e) / 0x2710;
  233. if (pitch & 0x400) ptarget += (ptarget * 0x764) / 0x2710;
  234. if (pitch & 0x200) ptarget += (ptarget * 0x389) / 0x2710;
  235. ptarget += (ptarget >> 1);
  236. if (ptarget > 0xffff) ptarget = 0xffff;
  237. return ptarget;
  238. }
  239. /*
  240. * set up the voice
  241. */
  242. static void setup_voice(struct snd_emu8k_pcm *rec, int ch)
  243. {
  244. struct snd_emu8000 *hw = rec->emu;
  245. unsigned int temp;
  246. /* channel to be silent and idle */
  247. EMU8000_DCYSUSV_WRITE(hw, ch, 0x0080);
  248. EMU8000_VTFT_WRITE(hw, ch, 0x0000FFFF);
  249. EMU8000_CVCF_WRITE(hw, ch, 0x0000FFFF);
  250. EMU8000_PTRX_WRITE(hw, ch, 0);
  251. EMU8000_CPF_WRITE(hw, ch, 0);
  252. /* pitch offset */
  253. EMU8000_IP_WRITE(hw, ch, rec->pitch);
  254. /* set envelope parameters */
  255. EMU8000_ENVVAL_WRITE(hw, ch, 0x8000);
  256. EMU8000_ATKHLD_WRITE(hw, ch, 0x7f7f);
  257. EMU8000_DCYSUS_WRITE(hw, ch, 0x7f7f);
  258. EMU8000_ENVVOL_WRITE(hw, ch, 0x8000);
  259. EMU8000_ATKHLDV_WRITE(hw, ch, 0x7f7f);
  260. /* decay/sustain parameter for volume envelope is used
  261. for triggerg the voice */
  262. /* modulation envelope heights */
  263. EMU8000_PEFE_WRITE(hw, ch, 0x0);
  264. /* lfo1/2 delay */
  265. EMU8000_LFO1VAL_WRITE(hw, ch, 0x8000);
  266. EMU8000_LFO2VAL_WRITE(hw, ch, 0x8000);
  267. /* lfo1 pitch & cutoff shift */
  268. EMU8000_FMMOD_WRITE(hw, ch, 0);
  269. /* lfo1 volume & freq */
  270. EMU8000_TREMFRQ_WRITE(hw, ch, 0);
  271. /* lfo2 pitch & freq */
  272. EMU8000_FM2FRQ2_WRITE(hw, ch, 0);
  273. /* pan & loop start */
  274. temp = rec->panning[ch];
  275. temp = (temp <<24) | ((unsigned int)rec->loop_start[ch] - 1);
  276. EMU8000_PSST_WRITE(hw, ch, temp);
  277. /* chorus & loop end (chorus 8bit, MSB) */
  278. temp = 0; // chorus
  279. temp = (temp << 24) | ((unsigned int)rec->loop_start[ch] + rec->buf_size - 1);
  280. EMU8000_CSL_WRITE(hw, ch, temp);
  281. /* Q & current address (Q 4bit value, MSB) */
  282. temp = 0; // filterQ
  283. temp = (temp << 28) | ((unsigned int)rec->loop_start[ch] - 1);
  284. EMU8000_CCCA_WRITE(hw, ch, temp);
  285. /* clear unknown registers */
  286. EMU8000_00A0_WRITE(hw, ch, 0);
  287. EMU8000_0080_WRITE(hw, ch, 0);
  288. }
  289. /*
  290. * trigger the voice
  291. */
  292. static void start_voice(struct snd_emu8k_pcm *rec, int ch)
  293. {
  294. unsigned long flags;
  295. struct snd_emu8000 *hw = rec->emu;
  296. unsigned int temp, aux;
  297. int pt = calc_pitch_target(rec->pitch);
  298. /* cutoff and volume */
  299. EMU8000_IFATN_WRITE(hw, ch, 0xff00);
  300. EMU8000_VTFT_WRITE(hw, ch, 0xffff);
  301. EMU8000_CVCF_WRITE(hw, ch, 0xffff);
  302. /* trigger envelope */
  303. EMU8000_DCYSUSV_WRITE(hw, ch, 0x7f7f);
  304. /* set reverb and pitch target */
  305. temp = 0; // reverb
  306. if (rec->panning[ch] == 0)
  307. aux = 0xff;
  308. else
  309. aux = (-rec->panning[ch]) & 0xff;
  310. temp = (temp << 8) | (pt << 16) | aux;
  311. EMU8000_PTRX_WRITE(hw, ch, temp);
  312. EMU8000_CPF_WRITE(hw, ch, pt << 16);
  313. /* start timer */
  314. spin_lock_irqsave(&rec->timer_lock, flags);
  315. if (! rec->timer_running) {
  316. rec->timer.expires = jiffies + 1;
  317. add_timer(&rec->timer);
  318. rec->timer_running = 1;
  319. }
  320. spin_unlock_irqrestore(&rec->timer_lock, flags);
  321. }
  322. /*
  323. * stop the voice immediately
  324. */
  325. static void stop_voice(struct snd_emu8k_pcm *rec, int ch)
  326. {
  327. unsigned long flags;
  328. struct snd_emu8000 *hw = rec->emu;
  329. EMU8000_DCYSUSV_WRITE(hw, ch, 0x807F);
  330. /* stop timer */
  331. spin_lock_irqsave(&rec->timer_lock, flags);
  332. if (rec->timer_running) {
  333. del_timer(&rec->timer);
  334. rec->timer_running = 0;
  335. }
  336. spin_unlock_irqrestore(&rec->timer_lock, flags);
  337. }
  338. static int emu8k_pcm_trigger(struct snd_pcm_substream *subs, int cmd)
  339. {
  340. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  341. int ch;
  342. switch (cmd) {
  343. case SNDRV_PCM_TRIGGER_START:
  344. for (ch = 0; ch < rec->voices; ch++)
  345. start_voice(rec, ch);
  346. rec->running = 1;
  347. break;
  348. case SNDRV_PCM_TRIGGER_STOP:
  349. rec->running = 0;
  350. for (ch = 0; ch < rec->voices; ch++)
  351. stop_voice(rec, ch);
  352. break;
  353. default:
  354. return -EINVAL;
  355. }
  356. return 0;
  357. }
  358. /*
  359. * copy / silence ops
  360. */
  361. /*
  362. * this macro should be inserted in the copy/silence loops
  363. * to reduce the latency. without this, the system will hang up
  364. * during the whole loop.
  365. */
  366. #define CHECK_SCHEDULER() \
  367. do { \
  368. cond_resched();\
  369. if (signal_pending(current))\
  370. return -EAGAIN;\
  371. } while (0)
  372. #ifdef USE_NONINTERLEAVE
  373. /* copy one channel block */
  374. static int emu8k_transfer_block(struct snd_emu8000 *emu, int offset, unsigned short *buf, int count)
  375. {
  376. EMU8000_SMALW_WRITE(emu, offset);
  377. while (count > 0) {
  378. unsigned short sval;
  379. CHECK_SCHEDULER();
  380. get_user(sval, buf);
  381. EMU8000_SMLD_WRITE(emu, sval);
  382. buf++;
  383. count--;
  384. }
  385. return 0;
  386. }
  387. static int emu8k_pcm_copy(struct snd_pcm_substream *subs,
  388. int voice,
  389. snd_pcm_uframes_t pos,
  390. void *src,
  391. snd_pcm_uframes_t count)
  392. {
  393. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  394. struct snd_emu8000 *emu = rec->emu;
  395. snd_emu8000_write_wait(emu, 1);
  396. if (voice == -1) {
  397. unsigned short *buf = src;
  398. int i, err;
  399. count /= rec->voices;
  400. for (i = 0; i < rec->voices; i++) {
  401. err = emu8k_transfer_block(emu, pos + rec->loop_start[i], buf, count);
  402. if (err < 0)
  403. return err;
  404. buf += count;
  405. }
  406. return 0;
  407. } else {
  408. return emu8k_transfer_block(emu, pos + rec->loop_start[voice], src, count);
  409. }
  410. }
  411. /* make a channel block silence */
  412. static int emu8k_silence_block(struct snd_emu8000 *emu, int offset, int count)
  413. {
  414. EMU8000_SMALW_WRITE(emu, offset);
  415. while (count > 0) {
  416. CHECK_SCHEDULER();
  417. EMU8000_SMLD_WRITE(emu, 0);
  418. count--;
  419. }
  420. return 0;
  421. }
  422. static int emu8k_pcm_silence(struct snd_pcm_substream *subs,
  423. int voice,
  424. snd_pcm_uframes_t pos,
  425. snd_pcm_uframes_t count)
  426. {
  427. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  428. struct snd_emu8000 *emu = rec->emu;
  429. snd_emu8000_write_wait(emu, 1);
  430. if (voice == -1 && rec->voices == 1)
  431. voice = 0;
  432. if (voice == -1) {
  433. int err;
  434. err = emu8k_silence_block(emu, pos + rec->loop_start[0], count / 2);
  435. if (err < 0)
  436. return err;
  437. return emu8k_silence_block(emu, pos + rec->loop_start[1], count / 2);
  438. } else {
  439. return emu8k_silence_block(emu, pos + rec->loop_start[voice], count);
  440. }
  441. }
  442. #else /* interleave */
  443. /*
  444. * copy the interleaved data can be done easily by using
  445. * DMA "left" and "right" channels on emu8k engine.
  446. */
  447. static int emu8k_pcm_copy(struct snd_pcm_substream *subs,
  448. int voice,
  449. snd_pcm_uframes_t pos,
  450. void __user *src,
  451. snd_pcm_uframes_t count)
  452. {
  453. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  454. struct snd_emu8000 *emu = rec->emu;
  455. unsigned short __user *buf = src;
  456. snd_emu8000_write_wait(emu, 1);
  457. EMU8000_SMALW_WRITE(emu, pos + rec->loop_start[0]);
  458. if (rec->voices > 1)
  459. EMU8000_SMARW_WRITE(emu, pos + rec->loop_start[1]);
  460. while (count-- > 0) {
  461. unsigned short sval;
  462. CHECK_SCHEDULER();
  463. get_user(sval, buf);
  464. EMU8000_SMLD_WRITE(emu, sval);
  465. buf++;
  466. if (rec->voices > 1) {
  467. CHECK_SCHEDULER();
  468. get_user(sval, buf);
  469. EMU8000_SMRD_WRITE(emu, sval);
  470. buf++;
  471. }
  472. }
  473. return 0;
  474. }
  475. static int emu8k_pcm_silence(struct snd_pcm_substream *subs,
  476. int voice,
  477. snd_pcm_uframes_t pos,
  478. snd_pcm_uframes_t count)
  479. {
  480. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  481. struct snd_emu8000 *emu = rec->emu;
  482. snd_emu8000_write_wait(emu, 1);
  483. EMU8000_SMALW_WRITE(emu, rec->loop_start[0] + pos);
  484. if (rec->voices > 1)
  485. EMU8000_SMARW_WRITE(emu, rec->loop_start[1] + pos);
  486. while (count-- > 0) {
  487. CHECK_SCHEDULER();
  488. EMU8000_SMLD_WRITE(emu, 0);
  489. if (rec->voices > 1) {
  490. CHECK_SCHEDULER();
  491. EMU8000_SMRD_WRITE(emu, 0);
  492. }
  493. }
  494. return 0;
  495. }
  496. #endif
  497. /*
  498. * allocate a memory block
  499. */
  500. static int emu8k_pcm_hw_params(struct snd_pcm_substream *subs,
  501. struct snd_pcm_hw_params *hw_params)
  502. {
  503. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  504. if (rec->block) {
  505. /* reallocation - release the old block */
  506. snd_util_mem_free(rec->emu->memhdr, rec->block);
  507. rec->block = NULL;
  508. }
  509. rec->allocated_bytes = params_buffer_bytes(hw_params) + LOOP_BLANK_SIZE * 4;
  510. rec->block = snd_util_mem_alloc(rec->emu->memhdr, rec->allocated_bytes);
  511. if (! rec->block)
  512. return -ENOMEM;
  513. rec->offset = EMU8000_DRAM_OFFSET + (rec->block->offset >> 1); /* in word */
  514. /* at least dma_bytes must be set for non-interleaved mode */
  515. subs->dma_buffer.bytes = params_buffer_bytes(hw_params);
  516. return 0;
  517. }
  518. /*
  519. * free the memory block
  520. */
  521. static int emu8k_pcm_hw_free(struct snd_pcm_substream *subs)
  522. {
  523. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  524. if (rec->block) {
  525. int ch;
  526. for (ch = 0; ch < rec->voices; ch++)
  527. stop_voice(rec, ch); // to be sure
  528. if (rec->dram_opened)
  529. emu8k_close_dram(rec->emu);
  530. snd_util_mem_free(rec->emu->memhdr, rec->block);
  531. rec->block = NULL;
  532. }
  533. return 0;
  534. }
  535. /*
  536. */
  537. static int emu8k_pcm_prepare(struct snd_pcm_substream *subs)
  538. {
  539. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  540. rec->pitch = 0xe000 + calc_rate_offset(subs->runtime->rate);
  541. rec->last_ptr = 0;
  542. rec->period_pos = 0;
  543. rec->buf_size = subs->runtime->buffer_size;
  544. rec->period_size = subs->runtime->period_size;
  545. rec->voices = subs->runtime->channels;
  546. rec->loop_start[0] = rec->offset + LOOP_BLANK_SIZE;
  547. if (rec->voices > 1)
  548. rec->loop_start[1] = rec->loop_start[0] + rec->buf_size + LOOP_BLANK_SIZE;
  549. if (rec->voices > 1) {
  550. rec->panning[0] = 0xff;
  551. rec->panning[1] = 0x00;
  552. } else
  553. rec->panning[0] = 0x80;
  554. if (! rec->dram_opened) {
  555. int err, i, ch;
  556. snd_emux_terminate_all(rec->emu->emu);
  557. if ((err = emu8k_open_dram_for_pcm(rec->emu, rec->voices)) != 0)
  558. return err;
  559. rec->dram_opened = 1;
  560. /* clear loop blanks */
  561. snd_emu8000_write_wait(rec->emu, 0);
  562. EMU8000_SMALW_WRITE(rec->emu, rec->offset);
  563. for (i = 0; i < LOOP_BLANK_SIZE; i++)
  564. EMU8000_SMLD_WRITE(rec->emu, 0);
  565. for (ch = 0; ch < rec->voices; ch++) {
  566. EMU8000_SMALW_WRITE(rec->emu, rec->loop_start[ch] + rec->buf_size);
  567. for (i = 0; i < LOOP_BLANK_SIZE; i++)
  568. EMU8000_SMLD_WRITE(rec->emu, 0);
  569. }
  570. }
  571. setup_voice(rec, 0);
  572. if (rec->voices > 1)
  573. setup_voice(rec, 1);
  574. return 0;
  575. }
  576. static snd_pcm_uframes_t emu8k_pcm_pointer(struct snd_pcm_substream *subs)
  577. {
  578. struct snd_emu8k_pcm *rec = subs->runtime->private_data;
  579. if (rec->running)
  580. return emu8k_get_curpos(rec, 0);
  581. return 0;
  582. }
  583. static struct snd_pcm_ops emu8k_pcm_ops = {
  584. .open = emu8k_pcm_open,
  585. .close = emu8k_pcm_close,
  586. .ioctl = snd_pcm_lib_ioctl,
  587. .hw_params = emu8k_pcm_hw_params,
  588. .hw_free = emu8k_pcm_hw_free,
  589. .prepare = emu8k_pcm_prepare,
  590. .trigger = emu8k_pcm_trigger,
  591. .pointer = emu8k_pcm_pointer,
  592. .copy = emu8k_pcm_copy,
  593. .silence = emu8k_pcm_silence,
  594. };
  595. static void snd_emu8000_pcm_free(struct snd_pcm *pcm)
  596. {
  597. struct snd_emu8000 *emu = pcm->private_data;
  598. emu->pcm = NULL;
  599. }
  600. int snd_emu8000_pcm_new(struct snd_card *card, struct snd_emu8000 *emu, int index)
  601. {
  602. struct snd_pcm *pcm;
  603. int err;
  604. if ((err = snd_pcm_new(card, "Emu8000 PCM", index, 1, 0, &pcm)) < 0)
  605. return err;
  606. pcm->private_data = emu;
  607. pcm->private_free = snd_emu8000_pcm_free;
  608. snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &emu8k_pcm_ops);
  609. emu->pcm = pcm;
  610. snd_device_register(card, pcm);
  611. return 0;
  612. }