sb_audio.c
上传用户:jlfgdled
上传日期:2013-04-10
资源大小:33168k
文件大小:26k
源码类别:

Linux/Unix编程

开发平台:

Unix_Linux

  1. /*
  2.  * sound/sb_audio.c
  3.  *
  4.  * Audio routines for Sound Blaster compatible cards.
  5.  *
  6.  *
  7.  * Copyright (C) by Hannu Savolainen 1993-1997
  8.  *
  9.  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10.  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11.  * for more info.
  12.  *
  13.  * Changes
  14.  * Alan Cox : Formatting and clean ups
  15.  *
  16.  * Status
  17.  * Mostly working. Weird uart bug causing irq storms
  18.  *
  19.  * Daniel J. Rodriksson: Changes to make sb16 work full duplex.
  20.  *                       Maybe other 16 bit cards in this code could behave
  21.  *                       the same.
  22.  * Chris Rankin:         Use spinlocks instead of CLI/STI
  23.  */
  24. #include <linux/spinlock.h>
  25. #include "sound_config.h"
  26. #include "sb_mixer.h"
  27. #include "sb.h"
  28. #include "sb_ess.h"
  29. int sb_audio_open(int dev, int mode)
  30. {
  31. sb_devc *devc = audio_devs[dev]->devc;
  32. unsigned long flags;
  33. if (devc == NULL)
  34. {
  35.   printk(KERN_ERR "Sound Blaster: incomplete initialization.n");
  36.   return -ENXIO;
  37. }
  38. if (devc->caps & SB_NO_RECORDING && mode & OPEN_READ)
  39. {
  40. if (mode == OPEN_READ)
  41. return -EPERM;
  42. }
  43. spin_lock_irqsave(&devc->lock, flags);
  44. if (devc->opened)
  45. {
  46.   spin_unlock_irqrestore(&devc->lock, flags);
  47.   return -EBUSY;
  48. }
  49. if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex)
  50. {
  51. if (sound_open_dma(devc->dma16, "Sound Blaster 16 bit"))
  52. {
  53.    spin_unlock_irqrestore(&devc->lock, flags);
  54. return -EBUSY;
  55. }
  56. }
  57. devc->opened = mode;
  58. spin_unlock_irqrestore(&devc->lock, flags);
  59. devc->irq_mode = IMODE_NONE;
  60. devc->irq_mode_16 = IMODE_NONE;
  61. devc->fullduplex = devc->duplex &&
  62. ((mode & OPEN_READ) && (mode & OPEN_WRITE));
  63. sb_dsp_reset(devc);
  64. /* At first glance this check isn't enough, some ESS chips might not 
  65.  * have a RECLEV. However if they don't common_mixer_set will refuse 
  66.  * cause devc->iomap has no register mapping for RECLEV
  67.  */
  68. if (devc->model == MDL_ESS) ess_mixer_reload (devc, SOUND_MIXER_RECLEV);
  69. /* The ALS007 seems to require that the DSP be removed from the output */
  70. /* in order for recording to be activated properly.  This is done by   */
  71. /* setting the appropriate bits of the output control register 4ch to  */
  72. /* zero.  This code assumes that the output control registers are not  */
  73. /* used anywhere else and therefore the DSP bits are *always* ON for   */
  74. /* output and OFF for sampling.                                        */
  75. if (devc->submodel == SUBMDL_ALS007) 
  76. {
  77. if (mode & OPEN_READ) 
  78. sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
  79. sb_getmixer(devc,ALS007_OUTPUT_CTRL2) & 0xf9);
  80. else
  81. sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
  82. sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
  83. }
  84. return 0;
  85. }
  86. void sb_audio_close(int dev)
  87. {
  88. sb_devc *devc = audio_devs[dev]->devc;
  89. /* fix things if mmap turned off fullduplex */
  90. if(devc->duplex
  91.    && !devc->fullduplex
  92.    && (devc->opened & OPEN_READ) && (devc->opened & OPEN_WRITE))
  93. {
  94. struct dma_buffparms *dmap_temp;
  95. dmap_temp = audio_devs[dev]->dmap_out;
  96. audio_devs[dev]->dmap_out = audio_devs[dev]->dmap_in;
  97. audio_devs[dev]->dmap_in = dmap_temp;
  98. }
  99. audio_devs[dev]->dmap_out->dma = devc->dma8;
  100. audio_devs[dev]->dmap_in->dma = ( devc->duplex ) ?
  101. devc->dma16 : devc->dma8;
  102. if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex)
  103. sound_close_dma(devc->dma16);
  104. /* For ALS007, turn DSP output back on if closing the device for read */
  105. if ((devc->submodel == SUBMDL_ALS007) && (devc->opened & OPEN_READ)) 
  106. {
  107. sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
  108. sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
  109. }
  110. devc->opened = 0;
  111. }
  112. static void sb_set_output_parms(int dev, unsigned long buf, int nr_bytes,
  113.     int intrflag)
  114. {
  115. sb_devc *devc = audio_devs[dev]->devc;
  116. if (!devc->fullduplex || devc->bits == AFMT_S16_LE)
  117. {
  118. devc->trg_buf = buf;
  119. devc->trg_bytes = nr_bytes;
  120. devc->trg_intrflag = intrflag;
  121. devc->irq_mode = IMODE_OUTPUT;
  122. }
  123. else
  124. {
  125. devc->trg_buf_16 = buf;
  126. devc->trg_bytes_16 = nr_bytes;
  127. devc->trg_intrflag_16 = intrflag;
  128. devc->irq_mode_16 = IMODE_OUTPUT;
  129. }
  130. }
  131. static void sb_set_input_parms(int dev, unsigned long buf, int count, int intrflag)
  132. {
  133. sb_devc *devc = audio_devs[dev]->devc;
  134. if (!devc->fullduplex || devc->bits != AFMT_S16_LE)
  135. {
  136. devc->trg_buf = buf;
  137. devc->trg_bytes = count;
  138. devc->trg_intrflag = intrflag;
  139. devc->irq_mode = IMODE_INPUT;
  140. }
  141. else
  142. {
  143. devc->trg_buf_16 = buf;
  144. devc->trg_bytes_16 = count;
  145. devc->trg_intrflag_16 = intrflag;
  146. devc->irq_mode_16 = IMODE_INPUT;
  147. }
  148. }
  149. /*
  150.  * SB1.x compatible routines 
  151.  */
  152. static void sb1_audio_output_block(int dev, unsigned long buf, int nr_bytes, int intrflag)
  153. {
  154. unsigned long flags;
  155. int count = nr_bytes;
  156. sb_devc *devc = audio_devs[dev]->devc;
  157. /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
  158. if (audio_devs[dev]->dmap_out->dma > 3)
  159. count >>= 1;
  160. count--;
  161. devc->irq_mode = IMODE_OUTPUT;
  162. spin_lock_irqsave(&devc->lock, flags);
  163. if (sb_dsp_command(devc, 0x14)) /* 8 bit DAC using DMA */
  164. {
  165. sb_dsp_command(devc, (unsigned char) (count & 0xff));
  166. sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
  167. }
  168. else
  169. printk(KERN_WARNING "Sound Blaster:  unable to start DAC.n");
  170. spin_unlock_irqrestore(&devc->lock, flags);
  171. devc->intr_active = 1;
  172. }
  173. static void sb1_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
  174. {
  175. unsigned long flags;
  176. int count = nr_bytes;
  177. sb_devc *devc = audio_devs[dev]->devc;
  178. /*
  179.  * Start a DMA input to the buffer pointed by dmaqtail
  180.  */
  181. /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
  182. if (audio_devs[dev]->dmap_out->dma > 3)
  183. count >>= 1;
  184. count--;
  185. devc->irq_mode = IMODE_INPUT;
  186. spin_lock_irqsave(&devc->lock, flags);
  187. if (sb_dsp_command(devc, 0x24)) /* 8 bit ADC using DMA */
  188. {
  189. sb_dsp_command(devc, (unsigned char) (count & 0xff));
  190. sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
  191. }
  192. else
  193. printk(KERN_ERR "Sound Blaster:  unable to start ADC.n");
  194. spin_unlock_irqrestore(&devc->lock, flags);
  195. devc->intr_active = 1;
  196. }
  197. static void sb1_audio_trigger(int dev, int bits)
  198. {
  199. sb_devc *devc = audio_devs[dev]->devc;
  200. bits &= devc->irq_mode;
  201. if (!bits)
  202. sb_dsp_command(devc, 0xd0); /* Halt DMA */
  203. else
  204. {
  205. switch (devc->irq_mode)
  206. {
  207. case IMODE_INPUT:
  208. sb1_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
  209. devc->trg_intrflag);
  210. break;
  211. case IMODE_OUTPUT:
  212. sb1_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
  213. devc->trg_intrflag);
  214. break;
  215. }
  216. }
  217. devc->trigger_bits = bits;
  218. }
  219. static int sb1_audio_prepare_for_input(int dev, int bsize, int bcount)
  220. {
  221. sb_devc *devc = audio_devs[dev]->devc;
  222. unsigned long flags;
  223. spin_lock_irqsave(&devc->lock, flags);
  224. if (sb_dsp_command(devc, 0x40))
  225. sb_dsp_command(devc, devc->tconst);
  226. sb_dsp_command(devc, DSP_CMD_SPKOFF);
  227. spin_unlock_irqrestore(&devc->lock, flags);
  228. devc->trigger_bits = 0;
  229. return 0;
  230. }
  231. static int sb1_audio_prepare_for_output(int dev, int bsize, int bcount)
  232. {
  233. sb_devc *devc = audio_devs[dev]->devc;
  234. unsigned long flags;
  235. spin_lock_irqsave(&devc->lock, flags);
  236. if (sb_dsp_command(devc, 0x40))
  237. sb_dsp_command(devc, devc->tconst);
  238. sb_dsp_command(devc, DSP_CMD_SPKON);
  239. spin_unlock_irqrestore(&devc->lock, flags);
  240. devc->trigger_bits = 0;
  241. return 0;
  242. }
  243. static int sb1_audio_set_speed(int dev, int speed)
  244. {
  245. int max_speed = 23000;
  246. sb_devc *devc = audio_devs[dev]->devc;
  247. int tmp;
  248. if (devc->opened & OPEN_READ)
  249. max_speed = 13000;
  250. if (speed > 0)
  251. {
  252. if (speed < 4000)
  253. speed = 4000;
  254. if (speed > max_speed)
  255. speed = max_speed;
  256. devc->tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff;
  257. tmp = 256 - devc->tconst;
  258. speed = (1000000 + tmp / 2) / tmp;
  259. devc->speed = speed;
  260. }
  261. return devc->speed;
  262. }
  263. static short sb1_audio_set_channels(int dev, short channels)
  264. {
  265. sb_devc *devc = audio_devs[dev]->devc;
  266. return devc->channels = 1;
  267. }
  268. static unsigned int sb1_audio_set_bits(int dev, unsigned int bits)
  269. {
  270. sb_devc        *devc = audio_devs[dev]->devc;
  271. return devc->bits = 8;
  272. }
  273. static void sb1_audio_halt_xfer(int dev)
  274. {
  275. unsigned long flags;
  276. sb_devc *devc = audio_devs[dev]->devc;
  277. spin_lock_irqsave(&devc->lock, flags);
  278. sb_dsp_reset(devc);
  279. spin_unlock_irqrestore(&devc->lock, flags);
  280. }
  281. /*
  282.  * SB 2.0 and SB 2.01 compatible routines
  283.  */
  284. static void sb20_audio_output_block(int dev, unsigned long buf, int nr_bytes,
  285. int intrflag)
  286. {
  287. unsigned long flags;
  288. int count = nr_bytes;
  289. sb_devc *devc = audio_devs[dev]->devc;
  290. unsigned char cmd;
  291. /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
  292. if (audio_devs[dev]->dmap_out->dma > 3)
  293. count >>= 1;
  294. count--;
  295. devc->irq_mode = IMODE_OUTPUT;
  296. spin_lock_irqsave(&devc->lock, flags);
  297. if (sb_dsp_command(devc, 0x48)) /* DSP Block size */
  298. {
  299. sb_dsp_command(devc, (unsigned char) (count & 0xff));
  300. sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
  301. if (devc->speed * devc->channels <= 23000)
  302. cmd = 0x1c; /* 8 bit PCM output */
  303. else
  304. cmd = 0x90; /* 8 bit high speed PCM output (SB2.01/Pro) */
  305. if (!sb_dsp_command(devc, cmd))
  306. printk(KERN_ERR "Sound Blaster:  unable to start DAC.n");
  307. }
  308. else
  309. printk(KERN_ERR "Sound Blaster: unable to start DAC.n");
  310. spin_unlock_irqrestore(&devc->lock, flags);
  311. devc->intr_active = 1;
  312. }
  313. static void sb20_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
  314. {
  315. unsigned long flags;
  316. int count = nr_bytes;
  317. sb_devc *devc = audio_devs[dev]->devc;
  318. unsigned char cmd;
  319. /*
  320.  * Start a DMA input to the buffer pointed by dmaqtail
  321.  */
  322. /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
  323. if (audio_devs[dev]->dmap_out->dma > 3)
  324. count >>= 1;
  325. count--;
  326. devc->irq_mode = IMODE_INPUT;
  327. spin_lock_irqsave(&devc->lock, flags);
  328. if (sb_dsp_command(devc, 0x48)) /* DSP Block size */
  329. {
  330. sb_dsp_command(devc, (unsigned char) (count & 0xff));
  331. sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
  332. if (devc->speed * devc->channels <= (devc->major == 3 ? 23000 : 13000))
  333. cmd = 0x2c; /* 8 bit PCM input */
  334. else
  335. cmd = 0x98; /* 8 bit high speed PCM input (SB2.01/Pro) */
  336. if (!sb_dsp_command(devc, cmd))
  337. printk(KERN_ERR "Sound Blaster:  unable to start ADC.n");
  338. }
  339. else
  340. printk(KERN_ERR "Sound Blaster:  unable to start ADC.n");
  341. spin_unlock_irqrestore(&devc->lock, flags);
  342. devc->intr_active = 1;
  343. }
  344. static void sb20_audio_trigger(int dev, int bits)
  345. {
  346. sb_devc *devc = audio_devs[dev]->devc;
  347. bits &= devc->irq_mode;
  348. if (!bits)
  349. sb_dsp_command(devc, 0xd0); /* Halt DMA */
  350. else
  351. {
  352. switch (devc->irq_mode)
  353. {
  354. case IMODE_INPUT:
  355. sb20_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
  356. devc->trg_intrflag);
  357. break;
  358. case IMODE_OUTPUT:
  359. sb20_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
  360. devc->trg_intrflag);
  361.     break;
  362. }
  363. }
  364. devc->trigger_bits = bits;
  365. }
  366. /*
  367.  * SB2.01 specific speed setup
  368.  */
  369. static int sb201_audio_set_speed(int dev, int speed)
  370. {
  371. sb_devc *devc = audio_devs[dev]->devc;
  372. int tmp;
  373. int s = speed * devc->channels;
  374. if (speed > 0)
  375. {
  376. if (speed < 4000)
  377. speed = 4000;
  378. if (speed > 44100)
  379. speed = 44100;
  380. if (devc->opened & OPEN_READ && speed > 15000)
  381. speed = 15000;
  382. devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff;
  383. tmp = 256 - devc->tconst;
  384. speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
  385. devc->speed = speed;
  386. }
  387. return devc->speed;
  388. }
  389. /*
  390.  * SB Pro specific routines
  391.  */
  392. static int sbpro_audio_prepare_for_input(int dev, int bsize, int bcount)
  393. { /* For SB Pro and Jazz16 */
  394. sb_devc *devc = audio_devs[dev]->devc;
  395. unsigned long flags;
  396. unsigned char bits = 0;
  397. if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
  398. audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma =
  399. devc->bits == 16 ? devc->dma16 : devc->dma8;
  400. if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
  401. if (devc->bits == AFMT_S16_LE)
  402. bits = 0x04; /* 16 bit mode */
  403. spin_lock_irqsave(&devc->lock, flags);
  404. if (sb_dsp_command(devc, 0x40))
  405. sb_dsp_command(devc, devc->tconst);
  406. sb_dsp_command(devc, DSP_CMD_SPKOFF);
  407. if (devc->channels == 1)
  408. sb_dsp_command(devc, 0xa0 | bits); /* Mono input */
  409. else
  410. sb_dsp_command(devc, 0xa8 | bits); /* Stereo input */
  411. spin_unlock_irqrestore(&devc->lock, flags);
  412. devc->trigger_bits = 0;
  413. return 0;
  414. }
  415. static int sbpro_audio_prepare_for_output(int dev, int bsize, int bcount)
  416. { /* For SB Pro and Jazz16 */
  417. sb_devc *devc = audio_devs[dev]->devc;
  418. unsigned long flags;
  419. unsigned char tmp;
  420. unsigned char bits = 0;
  421. if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
  422. audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = devc->bits == 16 ? devc->dma16 : devc->dma8;
  423. if (devc->model == MDL_SBPRO)
  424. sb_mixer_set_stereo(devc, devc->channels == 2);
  425. spin_lock_irqsave(&devc->lock, flags);
  426. if (sb_dsp_command(devc, 0x40))
  427. sb_dsp_command(devc, devc->tconst);
  428. sb_dsp_command(devc, DSP_CMD_SPKON);
  429. if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
  430. {
  431. if (devc->bits == AFMT_S16_LE)
  432. bits = 0x04; /* 16 bit mode */
  433. if (devc->channels == 1)
  434. sb_dsp_command(devc, 0xa0 | bits); /* Mono output */
  435. else
  436. sb_dsp_command(devc, 0xa8 | bits); /* Stereo output */
  437. }
  438. else
  439. {
  440. tmp = sb_getmixer(devc, 0x0e);
  441. if (devc->channels == 1)
  442. tmp &= ~0x02;
  443. else
  444. tmp |= 0x02;
  445. sb_setmixer(devc, 0x0e, tmp);
  446. }
  447. spin_unlock_irqrestore(&devc->lock, flags);
  448. devc->trigger_bits = 0;
  449. return 0;
  450. }
  451. static int sbpro_audio_set_speed(int dev, int speed)
  452. {
  453. sb_devc *devc = audio_devs[dev]->devc;
  454. if (speed > 0)
  455. {
  456. if (speed < 4000)
  457. speed = 4000;
  458. if (speed > 44100)
  459. speed = 44100;
  460. if (devc->channels > 1 && speed > 22050)
  461. speed = 22050;
  462. sb201_audio_set_speed(dev, speed);
  463. }
  464. return devc->speed;
  465. }
  466. static short sbpro_audio_set_channels(int dev, short channels)
  467. {
  468. sb_devc *devc = audio_devs[dev]->devc;
  469. if (channels == 1 || channels == 2)
  470. {
  471. if (channels != devc->channels)
  472. {
  473. devc->channels = channels;
  474. if (devc->model == MDL_SBPRO && devc->channels == 2)
  475. sbpro_audio_set_speed(dev, devc->speed);
  476. }
  477. }
  478. return devc->channels;
  479. }
  480. static int jazz16_audio_set_speed(int dev, int speed)
  481. {
  482. sb_devc *devc = audio_devs[dev]->devc;
  483. if (speed > 0)
  484. {
  485. int tmp;
  486. int s = speed * devc->channels;
  487. if (speed < 5000)
  488. speed = 5000;
  489. if (speed > 44100)
  490. speed = 44100;
  491. devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff;
  492. tmp = 256 - devc->tconst;
  493. speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
  494. devc->speed = speed;
  495. }
  496. return devc->speed;
  497. }
  498. /*
  499.  * SB16 specific routines
  500.  */
  501. static int sb16_audio_set_speed(int dev, int speed)
  502. {
  503. sb_devc *devc = audio_devs[dev]->devc;
  504. int max_speed = devc->submodel == SUBMDL_ALS100 ? 48000 : 44100;
  505. if (speed > 0)
  506. {
  507. if (speed < 5000)
  508. speed = 5000;
  509. if (speed > max_speed)
  510. speed = max_speed;
  511. devc->speed = speed;
  512. }
  513. return devc->speed;
  514. }
  515. static unsigned int sb16_audio_set_bits(int dev, unsigned int bits)
  516. {
  517. sb_devc *devc = audio_devs[dev]->devc;
  518. if (bits != 0)
  519. {
  520. if (bits == AFMT_U8 || bits == AFMT_S16_LE)
  521. devc->bits = bits;
  522. else
  523. devc->bits = AFMT_U8;
  524. }
  525. return devc->bits;
  526. }
  527. static int sb16_audio_prepare_for_input(int dev, int bsize, int bcount)
  528. {
  529. sb_devc *devc = audio_devs[dev]->devc;
  530. if (!devc->fullduplex)
  531. {
  532. audio_devs[dev]->dmap_out->dma =
  533. audio_devs[dev]->dmap_in->dma =
  534. devc->bits == AFMT_S16_LE ?
  535. devc->dma16 : devc->dma8;
  536. }
  537. else if (devc->bits == AFMT_S16_LE)
  538. {
  539. audio_devs[dev]->dmap_out->dma = devc->dma8;
  540. audio_devs[dev]->dmap_in->dma = devc->dma16;
  541. }
  542. else
  543. {
  544. audio_devs[dev]->dmap_out->dma = devc->dma16;
  545. audio_devs[dev]->dmap_in->dma = devc->dma8;
  546. }
  547. devc->trigger_bits = 0;
  548. return 0;
  549. }
  550. static int sb16_audio_prepare_for_output(int dev, int bsize, int bcount)
  551. {
  552. sb_devc *devc = audio_devs[dev]->devc;
  553. if (!devc->fullduplex)
  554. {
  555. audio_devs[dev]->dmap_out->dma =
  556. audio_devs[dev]->dmap_in->dma =
  557. devc->bits == AFMT_S16_LE ?
  558. devc->dma16 : devc->dma8;
  559. }
  560. else if (devc->bits == AFMT_S16_LE)
  561. {
  562. audio_devs[dev]->dmap_out->dma = devc->dma8;
  563. audio_devs[dev]->dmap_in->dma = devc->dma16;
  564. }
  565. else
  566. {
  567. audio_devs[dev]->dmap_out->dma = devc->dma16;
  568. audio_devs[dev]->dmap_in->dma = devc->dma8;
  569. }
  570. devc->trigger_bits = 0;
  571. return 0;
  572. }
  573. static void sb16_audio_output_block(int dev, unsigned long buf, int count,
  574. int intrflag)
  575. {
  576. unsigned long   flags, cnt;
  577. sb_devc        *devc = audio_devs[dev]->devc;
  578. unsigned long   bits;
  579. if (!devc->fullduplex || devc->bits == AFMT_S16_LE)
  580. {
  581. devc->irq_mode = IMODE_OUTPUT;
  582. devc->intr_active = 1;
  583. }
  584. else
  585. {
  586. devc->irq_mode_16 = IMODE_OUTPUT;
  587. devc->intr_active_16 = 1;
  588. }
  589. /* save value */
  590. spin_lock_irqsave(&devc->lock, flags);
  591. bits = devc->bits;
  592. if (devc->fullduplex)
  593. devc->bits = (devc->bits == AFMT_S16_LE) ?
  594. AFMT_U8 : AFMT_S16_LE;
  595. spin_unlock_irqrestore(&devc->lock, flags);
  596. cnt = count;
  597. if (devc->bits == AFMT_S16_LE)
  598. cnt >>= 1;
  599. cnt--;
  600. spin_lock_irqsave(&devc->lock, flags);
  601. /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
  602. sb_dsp_command(devc, 0x41);
  603. sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff));
  604. sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff));
  605. sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xb6 : 0xc6));
  606. sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) +
  607.       (devc->bits == AFMT_S16_LE ? 0x10 : 0)));
  608. sb_dsp_command(devc, (unsigned char) (cnt & 0xff));
  609. sb_dsp_command(devc, (unsigned char) (cnt >> 8));
  610. /* restore real value after all programming */
  611. devc->bits = bits;
  612. spin_unlock_irqrestore(&devc->lock, flags);
  613. }
  614. /*
  615.  * This fails on the Cyrix MediaGX. If you don't have the DMA enabled
  616.  * before the first sample arrives it locks up. However even if you
  617.  * do enable the DMA in time you just get DMA timeouts and missing
  618.  * interrupts and stuff, so for now I've not bothered fixing this either.
  619.  */
  620.  
  621. static void sb16_audio_start_input(int dev, unsigned long buf, int count, int intrflag)
  622. {
  623. unsigned long   flags, cnt;
  624. sb_devc        *devc = audio_devs[dev]->devc;
  625. if (!devc->fullduplex || devc->bits != AFMT_S16_LE)
  626. {
  627. devc->irq_mode = IMODE_INPUT;
  628. devc->intr_active = 1;
  629. }
  630. else
  631. {
  632. devc->irq_mode_16 = IMODE_INPUT;
  633. devc->intr_active_16 = 1;
  634. }
  635. cnt = count;
  636. if (devc->bits == AFMT_S16_LE)
  637. cnt >>= 1;
  638. cnt--;
  639. spin_lock_irqsave(&devc->lock, flags);
  640. /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
  641. sb_dsp_command(devc, 0x42);
  642. sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff));
  643. sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff));
  644. sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xbe : 0xce));
  645. sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) +
  646.       (devc->bits == AFMT_S16_LE ? 0x10 : 0)));
  647. sb_dsp_command(devc, (unsigned char) (cnt & 0xff));
  648. sb_dsp_command(devc, (unsigned char) (cnt >> 8));
  649. spin_unlock_irqrestore(&devc->lock, flags);
  650. }
  651. static void sb16_audio_trigger(int dev, int bits)
  652. {
  653. sb_devc *devc = audio_devs[dev]->devc;
  654. int bits_16 = bits & devc->irq_mode_16;
  655. bits &= devc->irq_mode;
  656. if (!bits && !bits_16)
  657. sb_dsp_command(devc, 0xd0); /* Halt DMA */
  658. else
  659. {
  660. if (bits)
  661. {
  662. switch (devc->irq_mode)
  663. {
  664. case IMODE_INPUT:
  665. sb16_audio_start_input(dev,
  666. devc->trg_buf,
  667. devc->trg_bytes,
  668. devc->trg_intrflag);
  669. break;
  670. case IMODE_OUTPUT:
  671. sb16_audio_output_block(dev,
  672. devc->trg_buf,
  673. devc->trg_bytes,
  674. devc->trg_intrflag);
  675. break;
  676. }
  677. }
  678. if (bits_16)
  679. {
  680. switch (devc->irq_mode_16)
  681. {
  682. case IMODE_INPUT:
  683. sb16_audio_start_input(dev,
  684. devc->trg_buf_16,
  685. devc->trg_bytes_16,
  686. devc->trg_intrflag_16);
  687. break;
  688. case IMODE_OUTPUT:
  689. sb16_audio_output_block(dev,
  690. devc->trg_buf_16,
  691. devc->trg_bytes_16,
  692. devc->trg_intrflag_16);
  693. break;
  694. }
  695. }
  696. }
  697. devc->trigger_bits = bits | bits_16;
  698. }
  699. static unsigned char lbuf8[2048];
  700. static signed short *lbuf16 = (signed short *)lbuf8;
  701. #define LBUFCOPYSIZE 1024
  702. static void
  703. sb16_copy_from_user(int dev,
  704. char *localbuf, int localoffs,
  705. const char *userbuf, int useroffs,
  706. int max_in, int max_out,
  707. int *used, int *returned,
  708. int len)
  709. {
  710. sb_devc       *devc = audio_devs[dev]->devc;
  711. int           i, c, p, locallen;
  712. unsigned char *buf8;
  713. signed short  *buf16;
  714. /* if not duplex no conversion */
  715. if (!devc->fullduplex)
  716. {
  717. copy_from_user (localbuf + localoffs, userbuf + useroffs, len);
  718. *used = len;
  719. *returned = len;
  720. }
  721. else if (devc->bits == AFMT_S16_LE)
  722. {
  723. /* 16 -> 8 */
  724. /* max_in >> 1, max number of samples in ( 16 bits ) */
  725. /* max_out, max number of samples out ( 8 bits ) */
  726. /* len, number of samples that will be taken ( 16 bits )*/
  727. /* c, count of samples remaining in buffer ( 16 bits )*/
  728. /* p, count of samples already processed ( 16 bits )*/
  729. len = ( (max_in >> 1) > max_out) ? max_out : (max_in >> 1);
  730. c = len;
  731. p = 0;
  732. buf8 = (unsigned char *)(localbuf + localoffs);
  733. while (c)
  734. {
  735. locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c);
  736. /* << 1 in order to get 16 bit samples */
  737. copy_from_user (lbuf16,
  738. userbuf+useroffs + (p << 1),
  739. locallen << 1);
  740. for (i = 0; i < locallen; i++)
  741. {
  742. buf8[p+i] = ~((lbuf16[i] >> 8) & 0xff) ^ 0x80;
  743. }
  744. c -= locallen; p += locallen;
  745. }
  746. /* used = ( samples * 16 bits size ) */
  747. *used = len << 1;
  748. /* returned = ( samples * 8 bits size ) */
  749. *returned = len;
  750. }
  751. else
  752. {
  753. /* 8 -> 16 */
  754. /* max_in, max number of samples in ( 8 bits ) */
  755. /* max_out >> 1, max number of samples out ( 16 bits ) */
  756. /* len, number of samples that will be taken ( 8 bits )*/
  757. /* c, count of samples remaining in buffer ( 8 bits )*/
  758. /* p, count of samples already processed ( 8 bits )*/
  759. len = max_in > (max_out >> 1) ? (max_out >> 1) : max_in;
  760. c = len;
  761. p = 0;
  762. buf16 = (signed short *)(localbuf + localoffs);
  763. while (c)
  764. {
  765. locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c);
  766. copy_from_user (lbuf8,
  767. userbuf+useroffs + p,
  768. locallen);
  769. for (i = 0; i < locallen; i++)
  770. {
  771. buf16[p+i] = (~lbuf8[i] ^ 0x80) << 8;
  772. }
  773.        c -= locallen; p += locallen;
  774. }
  775. /* used = ( samples * 8 bits size ) */
  776. *used = len;
  777. /* returned = ( samples * 16 bits size ) */
  778. *returned = len << 1;
  779. }
  780. }
  781. static void
  782. sb16_audio_mmap(int dev)
  783. {
  784. sb_devc       *devc = audio_devs[dev]->devc;
  785. devc->fullduplex = 0;
  786. }
  787. static struct audio_driver sb1_audio_driver = /* SB1.x */
  788. {
  789. owner: THIS_MODULE,
  790. open: sb_audio_open,
  791. close: sb_audio_close,
  792. output_block: sb_set_output_parms,
  793. start_input: sb_set_input_parms,
  794. prepare_for_input: sb1_audio_prepare_for_input,
  795. prepare_for_output: sb1_audio_prepare_for_output,
  796. halt_io: sb1_audio_halt_xfer,
  797. trigger: sb1_audio_trigger,
  798. set_speed: sb1_audio_set_speed,
  799. set_bits: sb1_audio_set_bits,
  800. set_channels: sb1_audio_set_channels
  801. };
  802. static struct audio_driver sb20_audio_driver = /* SB2.0 */
  803. {
  804. owner: THIS_MODULE,
  805. open: sb_audio_open,
  806. close: sb_audio_close,
  807. output_block: sb_set_output_parms,
  808. start_input: sb_set_input_parms,
  809. prepare_for_input: sb1_audio_prepare_for_input,
  810. prepare_for_output: sb1_audio_prepare_for_output,
  811. halt_io: sb1_audio_halt_xfer,
  812. trigger: sb20_audio_trigger,
  813. set_speed: sb1_audio_set_speed,
  814. set_bits: sb1_audio_set_bits,
  815. set_channels: sb1_audio_set_channels
  816. };
  817. static struct audio_driver sb201_audio_driver = /* SB2.01 */
  818. {
  819. owner: THIS_MODULE,
  820. open: sb_audio_open,
  821. close: sb_audio_close,
  822. output_block: sb_set_output_parms,
  823. start_input: sb_set_input_parms,
  824. prepare_for_input: sb1_audio_prepare_for_input,
  825. prepare_for_output: sb1_audio_prepare_for_output,
  826. halt_io: sb1_audio_halt_xfer,
  827. trigger: sb20_audio_trigger,
  828. set_speed: sb201_audio_set_speed,
  829. set_bits: sb1_audio_set_bits,
  830. set_channels: sb1_audio_set_channels
  831. };
  832. static struct audio_driver sbpro_audio_driver = /* SB Pro */
  833. {
  834. owner: THIS_MODULE,
  835. open: sb_audio_open,
  836. close: sb_audio_close,
  837. output_block: sb_set_output_parms,
  838. start_input: sb_set_input_parms,
  839. prepare_for_input: sbpro_audio_prepare_for_input,
  840. prepare_for_output: sbpro_audio_prepare_for_output,
  841. halt_io: sb1_audio_halt_xfer,
  842. trigger: sb20_audio_trigger,
  843. set_speed: sbpro_audio_set_speed,
  844. set_bits: sb1_audio_set_bits,
  845. set_channels: sbpro_audio_set_channels
  846. };
  847. static struct audio_driver jazz16_audio_driver = /* Jazz16 and SM Wave */
  848. {
  849. owner: THIS_MODULE,
  850. open: sb_audio_open,
  851. close: sb_audio_close,
  852. output_block: sb_set_output_parms,
  853. start_input: sb_set_input_parms,
  854. prepare_for_input: sbpro_audio_prepare_for_input,
  855. prepare_for_output: sbpro_audio_prepare_for_output,
  856. halt_io: sb1_audio_halt_xfer,
  857. trigger: sb20_audio_trigger,
  858. set_speed: jazz16_audio_set_speed,
  859. set_bits: sb16_audio_set_bits,
  860. set_channels: sbpro_audio_set_channels
  861. };
  862. static struct audio_driver sb16_audio_driver = /* SB16 */
  863. {
  864. owner: THIS_MODULE,
  865. open: sb_audio_open,
  866. close: sb_audio_close,
  867. output_block: sb_set_output_parms,
  868. start_input: sb_set_input_parms,
  869. prepare_for_input: sb16_audio_prepare_for_input,
  870. prepare_for_output: sb16_audio_prepare_for_output,
  871. halt_io: sb1_audio_halt_xfer,
  872. copy_user: sb16_copy_from_user,
  873. trigger: sb16_audio_trigger,
  874. set_speed: sb16_audio_set_speed,
  875. set_bits: sb16_audio_set_bits,
  876. set_channels: sbpro_audio_set_channels,
  877. mmap: sb16_audio_mmap
  878. };
  879. void sb_audio_init(sb_devc * devc, char *name, struct module *owner)
  880. {
  881. int audio_flags = 0;
  882. int format_mask = AFMT_U8;
  883. struct audio_driver *driver = &sb1_audio_driver;
  884. switch (devc->model)
  885. {
  886. case MDL_SB1: /* SB1.0 or SB 1.5 */
  887. DDB(printk("Will use standard SB1.x drivern"));
  888. audio_flags = DMA_HARDSTOP;
  889. break;
  890. case MDL_SB2:
  891. DDB(printk("Will use SB2.0 drivern"));
  892. audio_flags = DMA_AUTOMODE;
  893. driver = &sb20_audio_driver;
  894. break;
  895. case MDL_SB201:
  896. DDB(printk("Will use SB2.01 (high speed) drivern"));
  897. audio_flags = DMA_AUTOMODE;
  898. driver = &sb201_audio_driver;
  899. break;
  900. case MDL_JAZZ:
  901. case MDL_SMW:
  902. DDB(printk("Will use Jazz16 drivern"));
  903. audio_flags = DMA_AUTOMODE;
  904. format_mask |= AFMT_S16_LE;
  905. driver = &jazz16_audio_driver;
  906. break;
  907. case MDL_ESS:
  908. DDB(printk("Will use ESS ES688/1688 drivern"));
  909. driver = ess_audio_init (devc, &audio_flags, &format_mask);
  910. break;
  911. case MDL_SB16:
  912. DDB(printk("Will use SB16 drivern"));
  913. audio_flags = DMA_AUTOMODE;
  914. format_mask |= AFMT_S16_LE;
  915. if (devc->dma8 != devc->dma16 && devc->dma16 != -1)
  916. {
  917. audio_flags |= DMA_DUPLEX;
  918. devc->duplex = 1;
  919. }
  920. driver = &sb16_audio_driver;
  921. break;
  922. default:
  923. DDB(printk("Will use SB Pro drivern"));
  924. audio_flags = DMA_AUTOMODE;
  925. driver = &sbpro_audio_driver;
  926. }
  927. if (owner)
  928. driver->owner = owner;
  929. if ((devc->dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION,
  930. name,driver, sizeof(struct audio_driver),
  931. audio_flags, format_mask, devc,
  932. devc->dma8,
  933. devc->duplex ? devc->dma16 : devc->dma8)) < 0)
  934. {
  935.   printk(KERN_ERR "Sound Blaster:  unable to install audio.n");
  936.   return;
  937. }
  938. audio_devs[devc->dev]->mixer_dev = devc->my_mixerdev;
  939. audio_devs[devc->dev]->min_fragment = 5;
  940. }