vx222_ops.c 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023
  1. /*
  2. * Driver for Digigram VX222 V2/Mic soundcards
  3. *
  4. * VX222-specific low-level routines
  5. *
  6. * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. */
  22. #include <linux/delay.h>
  23. #include <linux/device.h>
  24. #include <linux/firmware.h>
  25. #include <linux/mutex.h>
  26. #include <sound/core.h>
  27. #include <sound/control.h>
  28. #include <sound/tlv.h>
  29. #include <asm/io.h>
  30. #include "vx222.h"
  31. static int vx2_reg_offset[VX_REG_MAX] = {
  32. [VX_ICR] = 0x00,
  33. [VX_CVR] = 0x04,
  34. [VX_ISR] = 0x08,
  35. [VX_IVR] = 0x0c,
  36. [VX_RXH] = 0x14,
  37. [VX_RXM] = 0x18,
  38. [VX_RXL] = 0x1c,
  39. [VX_DMA] = 0x10,
  40. [VX_CDSP] = 0x20,
  41. [VX_CFG] = 0x24,
  42. [VX_RUER] = 0x28,
  43. [VX_DATA] = 0x2c,
  44. [VX_STATUS] = 0x30,
  45. [VX_LOFREQ] = 0x34,
  46. [VX_HIFREQ] = 0x38,
  47. [VX_CSUER] = 0x3c,
  48. [VX_SELMIC] = 0x40,
  49. [VX_COMPOT] = 0x44, // Write: POTENTIOMETER ; Read: COMPRESSION LEVEL activate
  50. [VX_SCOMPR] = 0x48, // Read: COMPRESSION THRESHOLD activate
  51. [VX_GLIMIT] = 0x4c, // Read: LEVEL LIMITATION activate
  52. [VX_INTCSR] = 0x4c, // VX_INTCSR_REGISTER_OFFSET
  53. [VX_CNTRL] = 0x50, // VX_CNTRL_REGISTER_OFFSET
  54. [VX_GPIOC] = 0x54, // VX_GPIOC (new with PLX9030)
  55. };
  56. static int vx2_reg_index[VX_REG_MAX] = {
  57. [VX_ICR] = 1,
  58. [VX_CVR] = 1,
  59. [VX_ISR] = 1,
  60. [VX_IVR] = 1,
  61. [VX_RXH] = 1,
  62. [VX_RXM] = 1,
  63. [VX_RXL] = 1,
  64. [VX_DMA] = 1,
  65. [VX_CDSP] = 1,
  66. [VX_CFG] = 1,
  67. [VX_RUER] = 1,
  68. [VX_DATA] = 1,
  69. [VX_STATUS] = 1,
  70. [VX_LOFREQ] = 1,
  71. [VX_HIFREQ] = 1,
  72. [VX_CSUER] = 1,
  73. [VX_SELMIC] = 1,
  74. [VX_COMPOT] = 1,
  75. [VX_SCOMPR] = 1,
  76. [VX_GLIMIT] = 1,
  77. [VX_INTCSR] = 0, /* on the PLX */
  78. [VX_CNTRL] = 0, /* on the PLX */
  79. [VX_GPIOC] = 0, /* on the PLX */
  80. };
  81. static inline unsigned long vx2_reg_addr(struct vx_core *_chip, int reg)
  82. {
  83. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  84. return chip->port[vx2_reg_index[reg]] + vx2_reg_offset[reg];
  85. }
  86. /**
  87. * snd_vx_inb - read a byte from the register
  88. * @offset: register enum
  89. */
  90. static unsigned char vx2_inb(struct vx_core *chip, int offset)
  91. {
  92. return inb(vx2_reg_addr(chip, offset));
  93. }
  94. /**
  95. * snd_vx_outb - write a byte on the register
  96. * @offset: the register offset
  97. * @val: the value to write
  98. */
  99. static void vx2_outb(struct vx_core *chip, int offset, unsigned char val)
  100. {
  101. outb(val, vx2_reg_addr(chip, offset));
  102. //printk("outb: %x -> %x\n", val, vx2_reg_addr(chip, offset));
  103. }
  104. /**
  105. * snd_vx_inl - read a 32bit word from the register
  106. * @offset: register enum
  107. */
  108. static unsigned int vx2_inl(struct vx_core *chip, int offset)
  109. {
  110. return inl(vx2_reg_addr(chip, offset));
  111. }
  112. /**
  113. * snd_vx_outl - write a 32bit word on the register
  114. * @offset: the register enum
  115. * @val: the value to write
  116. */
  117. static void vx2_outl(struct vx_core *chip, int offset, unsigned int val)
  118. {
  119. // printk("outl: %x -> %x\n", val, vx2_reg_addr(chip, offset));
  120. outl(val, vx2_reg_addr(chip, offset));
  121. }
  122. /*
  123. * redefine macros to call directly
  124. */
  125. #undef vx_inb
  126. #define vx_inb(chip,reg) vx2_inb((struct vx_core*)(chip), VX_##reg)
  127. #undef vx_outb
  128. #define vx_outb(chip,reg,val) vx2_outb((struct vx_core*)(chip), VX_##reg, val)
  129. #undef vx_inl
  130. #define vx_inl(chip,reg) vx2_inl((struct vx_core*)(chip), VX_##reg)
  131. #undef vx_outl
  132. #define vx_outl(chip,reg,val) vx2_outl((struct vx_core*)(chip), VX_##reg, val)
  133. /*
  134. * vx_reset_dsp - reset the DSP
  135. */
  136. #define XX_DSP_RESET_WAIT_TIME 2 /* ms */
  137. static void vx2_reset_dsp(struct vx_core *_chip)
  138. {
  139. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  140. /* set the reset dsp bit to 0 */
  141. vx_outl(chip, CDSP, chip->regCDSP & ~VX_CDSP_DSP_RESET_MASK);
  142. mdelay(XX_DSP_RESET_WAIT_TIME);
  143. chip->regCDSP |= VX_CDSP_DSP_RESET_MASK;
  144. /* set the reset dsp bit to 1 */
  145. vx_outl(chip, CDSP, chip->regCDSP);
  146. }
  147. static int vx2_test_xilinx(struct vx_core *_chip)
  148. {
  149. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  150. unsigned int data;
  151. snd_printdd("testing xilinx...\n");
  152. /* This test uses several write/read sequences on TEST0 and TEST1 bits
  153. * to figure out whever or not the xilinx was correctly loaded
  154. */
  155. /* We write 1 on CDSP.TEST0. We should get 0 on STATUS.TEST0. */
  156. vx_outl(chip, CDSP, chip->regCDSP | VX_CDSP_TEST0_MASK);
  157. vx_inl(chip, ISR);
  158. data = vx_inl(chip, STATUS);
  159. if ((data & VX_STATUS_VAL_TEST0_MASK) == VX_STATUS_VAL_TEST0_MASK) {
  160. snd_printdd("bad!\n");
  161. return -ENODEV;
  162. }
  163. /* We write 0 on CDSP.TEST0. We should get 1 on STATUS.TEST0. */
  164. vx_outl(chip, CDSP, chip->regCDSP & ~VX_CDSP_TEST0_MASK);
  165. vx_inl(chip, ISR);
  166. data = vx_inl(chip, STATUS);
  167. if (! (data & VX_STATUS_VAL_TEST0_MASK)) {
  168. snd_printdd("bad! #2\n");
  169. return -ENODEV;
  170. }
  171. if (_chip->type == VX_TYPE_BOARD) {
  172. /* not implemented on VX_2_BOARDS */
  173. /* We write 1 on CDSP.TEST1. We should get 0 on STATUS.TEST1. */
  174. vx_outl(chip, CDSP, chip->regCDSP | VX_CDSP_TEST1_MASK);
  175. vx_inl(chip, ISR);
  176. data = vx_inl(chip, STATUS);
  177. if ((data & VX_STATUS_VAL_TEST1_MASK) == VX_STATUS_VAL_TEST1_MASK) {
  178. snd_printdd("bad! #3\n");
  179. return -ENODEV;
  180. }
  181. /* We write 0 on CDSP.TEST1. We should get 1 on STATUS.TEST1. */
  182. vx_outl(chip, CDSP, chip->regCDSP & ~VX_CDSP_TEST1_MASK);
  183. vx_inl(chip, ISR);
  184. data = vx_inl(chip, STATUS);
  185. if (! (data & VX_STATUS_VAL_TEST1_MASK)) {
  186. snd_printdd("bad! #4\n");
  187. return -ENODEV;
  188. }
  189. }
  190. snd_printdd("ok, xilinx fine.\n");
  191. return 0;
  192. }
  193. /**
  194. * vx_setup_pseudo_dma - set up the pseudo dma read/write mode.
  195. * @do_write: 0 = read, 1 = set up for DMA write
  196. */
  197. static void vx2_setup_pseudo_dma(struct vx_core *chip, int do_write)
  198. {
  199. /* Interrupt mode and HREQ pin enabled for host transmit data transfers
  200. * (in case of the use of the pseudo-dma facility).
  201. */
  202. vx_outl(chip, ICR, do_write ? ICR_TREQ : ICR_RREQ);
  203. /* Reset the pseudo-dma register (in case of the use of the
  204. * pseudo-dma facility).
  205. */
  206. vx_outl(chip, RESET_DMA, 0);
  207. }
  208. /*
  209. * vx_release_pseudo_dma - disable the pseudo-DMA mode
  210. */
  211. static inline void vx2_release_pseudo_dma(struct vx_core *chip)
  212. {
  213. /* HREQ pin disabled. */
  214. vx_outl(chip, ICR, 0);
  215. }
  216. /* pseudo-dma write */
  217. static void vx2_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime,
  218. struct vx_pipe *pipe, int count)
  219. {
  220. unsigned long port = vx2_reg_addr(chip, VX_DMA);
  221. int offset = pipe->hw_ptr;
  222. u32 *addr = (u32 *)(runtime->dma_area + offset);
  223. snd_assert(count % 4 == 0, return);
  224. vx2_setup_pseudo_dma(chip, 1);
  225. /* Transfer using pseudo-dma.
  226. */
  227. if (offset + count > pipe->buffer_bytes) {
  228. int length = pipe->buffer_bytes - offset;
  229. count -= length;
  230. length >>= 2; /* in 32bit words */
  231. /* Transfer using pseudo-dma. */
  232. while (length-- > 0) {
  233. outl(cpu_to_le32(*addr), port);
  234. addr++;
  235. }
  236. addr = (u32 *)runtime->dma_area;
  237. pipe->hw_ptr = 0;
  238. }
  239. pipe->hw_ptr += count;
  240. count >>= 2; /* in 32bit words */
  241. /* Transfer using pseudo-dma. */
  242. while (count-- > 0) {
  243. outl(cpu_to_le32(*addr), port);
  244. addr++;
  245. }
  246. vx2_release_pseudo_dma(chip);
  247. }
  248. /* pseudo dma read */
  249. static void vx2_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime,
  250. struct vx_pipe *pipe, int count)
  251. {
  252. int offset = pipe->hw_ptr;
  253. u32 *addr = (u32 *)(runtime->dma_area + offset);
  254. unsigned long port = vx2_reg_addr(chip, VX_DMA);
  255. snd_assert(count % 4 == 0, return);
  256. vx2_setup_pseudo_dma(chip, 0);
  257. /* Transfer using pseudo-dma.
  258. */
  259. if (offset + count > pipe->buffer_bytes) {
  260. int length = pipe->buffer_bytes - offset;
  261. count -= length;
  262. length >>= 2; /* in 32bit words */
  263. /* Transfer using pseudo-dma. */
  264. while (length-- > 0)
  265. *addr++ = le32_to_cpu(inl(port));
  266. addr = (u32 *)runtime->dma_area;
  267. pipe->hw_ptr = 0;
  268. }
  269. pipe->hw_ptr += count;
  270. count >>= 2; /* in 32bit words */
  271. /* Transfer using pseudo-dma. */
  272. while (count-- > 0)
  273. *addr++ = le32_to_cpu(inl(port));
  274. vx2_release_pseudo_dma(chip);
  275. }
  276. #define VX_XILINX_RESET_MASK 0x40000000
  277. #define VX_USERBIT0_MASK 0x00000004
  278. #define VX_USERBIT1_MASK 0x00000020
  279. #define VX_CNTRL_REGISTER_VALUE 0x00172012
  280. /*
  281. * transfer counts bits to PLX
  282. */
  283. static int put_xilinx_data(struct vx_core *chip, unsigned int port, unsigned int counts, unsigned char data)
  284. {
  285. unsigned int i;
  286. for (i = 0; i < counts; i++) {
  287. unsigned int val;
  288. /* set the clock bit to 0. */
  289. val = VX_CNTRL_REGISTER_VALUE & ~VX_USERBIT0_MASK;
  290. vx2_outl(chip, port, val);
  291. vx2_inl(chip, port);
  292. udelay(1);
  293. if (data & (1 << i))
  294. val |= VX_USERBIT1_MASK;
  295. else
  296. val &= ~VX_USERBIT1_MASK;
  297. vx2_outl(chip, port, val);
  298. vx2_inl(chip, port);
  299. /* set the clock bit to 1. */
  300. val |= VX_USERBIT0_MASK;
  301. vx2_outl(chip, port, val);
  302. vx2_inl(chip, port);
  303. udelay(1);
  304. }
  305. return 0;
  306. }
  307. /*
  308. * load the xilinx image
  309. */
  310. static int vx2_load_xilinx_binary(struct vx_core *chip, const struct firmware *xilinx)
  311. {
  312. unsigned int i;
  313. unsigned int port;
  314. const unsigned char *image;
  315. /* XILINX reset (wait at least 1 milisecond between reset on and off). */
  316. vx_outl(chip, CNTRL, VX_CNTRL_REGISTER_VALUE | VX_XILINX_RESET_MASK);
  317. vx_inl(chip, CNTRL);
  318. msleep(10);
  319. vx_outl(chip, CNTRL, VX_CNTRL_REGISTER_VALUE);
  320. vx_inl(chip, CNTRL);
  321. msleep(10);
  322. if (chip->type == VX_TYPE_BOARD)
  323. port = VX_CNTRL;
  324. else
  325. port = VX_GPIOC; /* VX222 V2 and VX222_MIC_BOARD with new PLX9030 use this register */
  326. image = xilinx->data;
  327. for (i = 0; i < xilinx->size; i++, image++) {
  328. if (put_xilinx_data(chip, port, 8, *image) < 0)
  329. return -EINVAL;
  330. /* don't take too much time in this loop... */
  331. cond_resched();
  332. }
  333. put_xilinx_data(chip, port, 4, 0xff); /* end signature */
  334. msleep(200);
  335. /* test after loading (is buggy with VX222) */
  336. if (chip->type != VX_TYPE_BOARD) {
  337. /* Test if load successful: test bit 8 of register GPIOC (VX222: use CNTRL) ! */
  338. i = vx_inl(chip, GPIOC);
  339. if (i & 0x0100)
  340. return 0;
  341. snd_printk(KERN_ERR "vx222: xilinx test failed after load, GPIOC=0x%x\n", i);
  342. return -EINVAL;
  343. }
  344. return 0;
  345. }
  346. /*
  347. * load the boot/dsp images
  348. */
  349. static int vx2_load_dsp(struct vx_core *vx, int index, const struct firmware *dsp)
  350. {
  351. int err;
  352. switch (index) {
  353. case 1:
  354. /* xilinx image */
  355. if ((err = vx2_load_xilinx_binary(vx, dsp)) < 0)
  356. return err;
  357. if ((err = vx2_test_xilinx(vx)) < 0)
  358. return err;
  359. return 0;
  360. case 2:
  361. /* DSP boot */
  362. return snd_vx_dsp_boot(vx, dsp);
  363. case 3:
  364. /* DSP image */
  365. return snd_vx_dsp_load(vx, dsp);
  366. default:
  367. snd_BUG();
  368. return -EINVAL;
  369. }
  370. }
  371. /*
  372. * vx_test_and_ack - test and acknowledge interrupt
  373. *
  374. * called from irq hander, too
  375. *
  376. * spinlock held!
  377. */
  378. static int vx2_test_and_ack(struct vx_core *chip)
  379. {
  380. /* not booted yet? */
  381. if (! (chip->chip_status & VX_STAT_XILINX_LOADED))
  382. return -ENXIO;
  383. if (! (vx_inl(chip, STATUS) & VX_STATUS_MEMIRQ_MASK))
  384. return -EIO;
  385. /* ok, interrupts generated, now ack it */
  386. /* set ACQUIT bit up and down */
  387. vx_outl(chip, STATUS, 0);
  388. /* useless read just to spend some time and maintain
  389. * the ACQUIT signal up for a while ( a bus cycle )
  390. */
  391. vx_inl(chip, STATUS);
  392. /* ack */
  393. vx_outl(chip, STATUS, VX_STATUS_MEMIRQ_MASK);
  394. /* useless read just to spend some time and maintain
  395. * the ACQUIT signal up for a while ( a bus cycle ) */
  396. vx_inl(chip, STATUS);
  397. /* clear */
  398. vx_outl(chip, STATUS, 0);
  399. return 0;
  400. }
  401. /*
  402. * vx_validate_irq - enable/disable IRQ
  403. */
  404. static void vx2_validate_irq(struct vx_core *_chip, int enable)
  405. {
  406. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  407. /* Set the interrupt enable bit to 1 in CDSP register */
  408. if (enable) {
  409. /* Set the PCI interrupt enable bit to 1.*/
  410. vx_outl(chip, INTCSR, VX_INTCSR_VALUE|VX_PCI_INTERRUPT_MASK);
  411. chip->regCDSP |= VX_CDSP_VALID_IRQ_MASK;
  412. } else {
  413. /* Set the PCI interrupt enable bit to 0. */
  414. vx_outl(chip, INTCSR, VX_INTCSR_VALUE&~VX_PCI_INTERRUPT_MASK);
  415. chip->regCDSP &= ~VX_CDSP_VALID_IRQ_MASK;
  416. }
  417. vx_outl(chip, CDSP, chip->regCDSP);
  418. }
  419. /*
  420. * write an AKM codec data (24bit)
  421. */
  422. static void vx2_write_codec_reg(struct vx_core *chip, unsigned int data)
  423. {
  424. unsigned int i;
  425. vx_inl(chip, HIFREQ);
  426. /* We have to send 24 bits (3 x 8 bits). Start with most signif. Bit */
  427. for (i = 0; i < 24; i++, data <<= 1)
  428. vx_outl(chip, DATA, ((data & 0x800000) ? VX_DATA_CODEC_MASK : 0));
  429. /* Terminate access to codec registers */
  430. vx_inl(chip, RUER);
  431. }
  432. #define AKM_CODEC_POWER_CONTROL_CMD 0xA007
  433. #define AKM_CODEC_RESET_ON_CMD 0xA100
  434. #define AKM_CODEC_RESET_OFF_CMD 0xA103
  435. #define AKM_CODEC_CLOCK_FORMAT_CMD 0xA240
  436. #define AKM_CODEC_MUTE_CMD 0xA38D
  437. #define AKM_CODEC_UNMUTE_CMD 0xA30D
  438. #define AKM_CODEC_LEFT_LEVEL_CMD 0xA400
  439. #define AKM_CODEC_RIGHT_LEVEL_CMD 0xA500
  440. static const u8 vx2_akm_gains_lut[VX2_AKM_LEVEL_MAX+1] = {
  441. 0x7f, // [000] = +0.000 dB -> AKM(0x7f) = +0.000 dB error(+0.000 dB)
  442. 0x7d, // [001] = -0.500 dB -> AKM(0x7d) = -0.572 dB error(-0.072 dB)
  443. 0x7c, // [002] = -1.000 dB -> AKM(0x7c) = -0.873 dB error(+0.127 dB)
  444. 0x7a, // [003] = -1.500 dB -> AKM(0x7a) = -1.508 dB error(-0.008 dB)
  445. 0x79, // [004] = -2.000 dB -> AKM(0x79) = -1.844 dB error(+0.156 dB)
  446. 0x77, // [005] = -2.500 dB -> AKM(0x77) = -2.557 dB error(-0.057 dB)
  447. 0x76, // [006] = -3.000 dB -> AKM(0x76) = -2.937 dB error(+0.063 dB)
  448. 0x75, // [007] = -3.500 dB -> AKM(0x75) = -3.334 dB error(+0.166 dB)
  449. 0x73, // [008] = -4.000 dB -> AKM(0x73) = -4.188 dB error(-0.188 dB)
  450. 0x72, // [009] = -4.500 dB -> AKM(0x72) = -4.648 dB error(-0.148 dB)
  451. 0x71, // [010] = -5.000 dB -> AKM(0x71) = -5.134 dB error(-0.134 dB)
  452. 0x70, // [011] = -5.500 dB -> AKM(0x70) = -5.649 dB error(-0.149 dB)
  453. 0x6f, // [012] = -6.000 dB -> AKM(0x6f) = -6.056 dB error(-0.056 dB)
  454. 0x6d, // [013] = -6.500 dB -> AKM(0x6d) = -6.631 dB error(-0.131 dB)
  455. 0x6c, // [014] = -7.000 dB -> AKM(0x6c) = -6.933 dB error(+0.067 dB)
  456. 0x6a, // [015] = -7.500 dB -> AKM(0x6a) = -7.571 dB error(-0.071 dB)
  457. 0x69, // [016] = -8.000 dB -> AKM(0x69) = -7.909 dB error(+0.091 dB)
  458. 0x67, // [017] = -8.500 dB -> AKM(0x67) = -8.626 dB error(-0.126 dB)
  459. 0x66, // [018] = -9.000 dB -> AKM(0x66) = -9.008 dB error(-0.008 dB)
  460. 0x65, // [019] = -9.500 dB -> AKM(0x65) = -9.407 dB error(+0.093 dB)
  461. 0x64, // [020] = -10.000 dB -> AKM(0x64) = -9.826 dB error(+0.174 dB)
  462. 0x62, // [021] = -10.500 dB -> AKM(0x62) = -10.730 dB error(-0.230 dB)
  463. 0x61, // [022] = -11.000 dB -> AKM(0x61) = -11.219 dB error(-0.219 dB)
  464. 0x60, // [023] = -11.500 dB -> AKM(0x60) = -11.738 dB error(-0.238 dB)
  465. 0x5f, // [024] = -12.000 dB -> AKM(0x5f) = -12.149 dB error(-0.149 dB)
  466. 0x5e, // [025] = -12.500 dB -> AKM(0x5e) = -12.434 dB error(+0.066 dB)
  467. 0x5c, // [026] = -13.000 dB -> AKM(0x5c) = -13.033 dB error(-0.033 dB)
  468. 0x5b, // [027] = -13.500 dB -> AKM(0x5b) = -13.350 dB error(+0.150 dB)
  469. 0x59, // [028] = -14.000 dB -> AKM(0x59) = -14.018 dB error(-0.018 dB)
  470. 0x58, // [029] = -14.500 dB -> AKM(0x58) = -14.373 dB error(+0.127 dB)
  471. 0x56, // [030] = -15.000 dB -> AKM(0x56) = -15.130 dB error(-0.130 dB)
  472. 0x55, // [031] = -15.500 dB -> AKM(0x55) = -15.534 dB error(-0.034 dB)
  473. 0x54, // [032] = -16.000 dB -> AKM(0x54) = -15.958 dB error(+0.042 dB)
  474. 0x53, // [033] = -16.500 dB -> AKM(0x53) = -16.404 dB error(+0.096 dB)
  475. 0x52, // [034] = -17.000 dB -> AKM(0x52) = -16.874 dB error(+0.126 dB)
  476. 0x51, // [035] = -17.500 dB -> AKM(0x51) = -17.371 dB error(+0.129 dB)
  477. 0x50, // [036] = -18.000 dB -> AKM(0x50) = -17.898 dB error(+0.102 dB)
  478. 0x4e, // [037] = -18.500 dB -> AKM(0x4e) = -18.605 dB error(-0.105 dB)
  479. 0x4d, // [038] = -19.000 dB -> AKM(0x4d) = -18.905 dB error(+0.095 dB)
  480. 0x4b, // [039] = -19.500 dB -> AKM(0x4b) = -19.538 dB error(-0.038 dB)
  481. 0x4a, // [040] = -20.000 dB -> AKM(0x4a) = -19.872 dB error(+0.128 dB)
  482. 0x48, // [041] = -20.500 dB -> AKM(0x48) = -20.583 dB error(-0.083 dB)
  483. 0x47, // [042] = -21.000 dB -> AKM(0x47) = -20.961 dB error(+0.039 dB)
  484. 0x46, // [043] = -21.500 dB -> AKM(0x46) = -21.356 dB error(+0.144 dB)
  485. 0x44, // [044] = -22.000 dB -> AKM(0x44) = -22.206 dB error(-0.206 dB)
  486. 0x43, // [045] = -22.500 dB -> AKM(0x43) = -22.664 dB error(-0.164 dB)
  487. 0x42, // [046] = -23.000 dB -> AKM(0x42) = -23.147 dB error(-0.147 dB)
  488. 0x41, // [047] = -23.500 dB -> AKM(0x41) = -23.659 dB error(-0.159 dB)
  489. 0x40, // [048] = -24.000 dB -> AKM(0x40) = -24.203 dB error(-0.203 dB)
  490. 0x3f, // [049] = -24.500 dB -> AKM(0x3f) = -24.635 dB error(-0.135 dB)
  491. 0x3e, // [050] = -25.000 dB -> AKM(0x3e) = -24.935 dB error(+0.065 dB)
  492. 0x3c, // [051] = -25.500 dB -> AKM(0x3c) = -25.569 dB error(-0.069 dB)
  493. 0x3b, // [052] = -26.000 dB -> AKM(0x3b) = -25.904 dB error(+0.096 dB)
  494. 0x39, // [053] = -26.500 dB -> AKM(0x39) = -26.615 dB error(-0.115 dB)
  495. 0x38, // [054] = -27.000 dB -> AKM(0x38) = -26.994 dB error(+0.006 dB)
  496. 0x37, // [055] = -27.500 dB -> AKM(0x37) = -27.390 dB error(+0.110 dB)
  497. 0x36, // [056] = -28.000 dB -> AKM(0x36) = -27.804 dB error(+0.196 dB)
  498. 0x34, // [057] = -28.500 dB -> AKM(0x34) = -28.699 dB error(-0.199 dB)
  499. 0x33, // [058] = -29.000 dB -> AKM(0x33) = -29.183 dB error(-0.183 dB)
  500. 0x32, // [059] = -29.500 dB -> AKM(0x32) = -29.696 dB error(-0.196 dB)
  501. 0x31, // [060] = -30.000 dB -> AKM(0x31) = -30.241 dB error(-0.241 dB)
  502. 0x31, // [061] = -30.500 dB -> AKM(0x31) = -30.241 dB error(+0.259 dB)
  503. 0x30, // [062] = -31.000 dB -> AKM(0x30) = -30.823 dB error(+0.177 dB)
  504. 0x2e, // [063] = -31.500 dB -> AKM(0x2e) = -31.610 dB error(-0.110 dB)
  505. 0x2d, // [064] = -32.000 dB -> AKM(0x2d) = -31.945 dB error(+0.055 dB)
  506. 0x2b, // [065] = -32.500 dB -> AKM(0x2b) = -32.659 dB error(-0.159 dB)
  507. 0x2a, // [066] = -33.000 dB -> AKM(0x2a) = -33.038 dB error(-0.038 dB)
  508. 0x29, // [067] = -33.500 dB -> AKM(0x29) = -33.435 dB error(+0.065 dB)
  509. 0x28, // [068] = -34.000 dB -> AKM(0x28) = -33.852 dB error(+0.148 dB)
  510. 0x27, // [069] = -34.500 dB -> AKM(0x27) = -34.289 dB error(+0.211 dB)
  511. 0x25, // [070] = -35.000 dB -> AKM(0x25) = -35.235 dB error(-0.235 dB)
  512. 0x24, // [071] = -35.500 dB -> AKM(0x24) = -35.750 dB error(-0.250 dB)
  513. 0x24, // [072] = -36.000 dB -> AKM(0x24) = -35.750 dB error(+0.250 dB)
  514. 0x23, // [073] = -36.500 dB -> AKM(0x23) = -36.297 dB error(+0.203 dB)
  515. 0x22, // [074] = -37.000 dB -> AKM(0x22) = -36.881 dB error(+0.119 dB)
  516. 0x21, // [075] = -37.500 dB -> AKM(0x21) = -37.508 dB error(-0.008 dB)
  517. 0x20, // [076] = -38.000 dB -> AKM(0x20) = -38.183 dB error(-0.183 dB)
  518. 0x1f, // [077] = -38.500 dB -> AKM(0x1f) = -38.726 dB error(-0.226 dB)
  519. 0x1e, // [078] = -39.000 dB -> AKM(0x1e) = -39.108 dB error(-0.108 dB)
  520. 0x1d, // [079] = -39.500 dB -> AKM(0x1d) = -39.507 dB error(-0.007 dB)
  521. 0x1c, // [080] = -40.000 dB -> AKM(0x1c) = -39.926 dB error(+0.074 dB)
  522. 0x1b, // [081] = -40.500 dB -> AKM(0x1b) = -40.366 dB error(+0.134 dB)
  523. 0x1a, // [082] = -41.000 dB -> AKM(0x1a) = -40.829 dB error(+0.171 dB)
  524. 0x19, // [083] = -41.500 dB -> AKM(0x19) = -41.318 dB error(+0.182 dB)
  525. 0x18, // [084] = -42.000 dB -> AKM(0x18) = -41.837 dB error(+0.163 dB)
  526. 0x17, // [085] = -42.500 dB -> AKM(0x17) = -42.389 dB error(+0.111 dB)
  527. 0x16, // [086] = -43.000 dB -> AKM(0x16) = -42.978 dB error(+0.022 dB)
  528. 0x15, // [087] = -43.500 dB -> AKM(0x15) = -43.610 dB error(-0.110 dB)
  529. 0x14, // [088] = -44.000 dB -> AKM(0x14) = -44.291 dB error(-0.291 dB)
  530. 0x14, // [089] = -44.500 dB -> AKM(0x14) = -44.291 dB error(+0.209 dB)
  531. 0x13, // [090] = -45.000 dB -> AKM(0x13) = -45.031 dB error(-0.031 dB)
  532. 0x12, // [091] = -45.500 dB -> AKM(0x12) = -45.840 dB error(-0.340 dB)
  533. 0x12, // [092] = -46.000 dB -> AKM(0x12) = -45.840 dB error(+0.160 dB)
  534. 0x11, // [093] = -46.500 dB -> AKM(0x11) = -46.731 dB error(-0.231 dB)
  535. 0x11, // [094] = -47.000 dB -> AKM(0x11) = -46.731 dB error(+0.269 dB)
  536. 0x10, // [095] = -47.500 dB -> AKM(0x10) = -47.725 dB error(-0.225 dB)
  537. 0x10, // [096] = -48.000 dB -> AKM(0x10) = -47.725 dB error(+0.275 dB)
  538. 0x0f, // [097] = -48.500 dB -> AKM(0x0f) = -48.553 dB error(-0.053 dB)
  539. 0x0e, // [098] = -49.000 dB -> AKM(0x0e) = -49.152 dB error(-0.152 dB)
  540. 0x0d, // [099] = -49.500 dB -> AKM(0x0d) = -49.796 dB error(-0.296 dB)
  541. 0x0d, // [100] = -50.000 dB -> AKM(0x0d) = -49.796 dB error(+0.204 dB)
  542. 0x0c, // [101] = -50.500 dB -> AKM(0x0c) = -50.491 dB error(+0.009 dB)
  543. 0x0b, // [102] = -51.000 dB -> AKM(0x0b) = -51.247 dB error(-0.247 dB)
  544. 0x0b, // [103] = -51.500 dB -> AKM(0x0b) = -51.247 dB error(+0.253 dB)
  545. 0x0a, // [104] = -52.000 dB -> AKM(0x0a) = -52.075 dB error(-0.075 dB)
  546. 0x0a, // [105] = -52.500 dB -> AKM(0x0a) = -52.075 dB error(+0.425 dB)
  547. 0x09, // [106] = -53.000 dB -> AKM(0x09) = -52.990 dB error(+0.010 dB)
  548. 0x09, // [107] = -53.500 dB -> AKM(0x09) = -52.990 dB error(+0.510 dB)
  549. 0x08, // [108] = -54.000 dB -> AKM(0x08) = -54.013 dB error(-0.013 dB)
  550. 0x08, // [109] = -54.500 dB -> AKM(0x08) = -54.013 dB error(+0.487 dB)
  551. 0x07, // [110] = -55.000 dB -> AKM(0x07) = -55.173 dB error(-0.173 dB)
  552. 0x07, // [111] = -55.500 dB -> AKM(0x07) = -55.173 dB error(+0.327 dB)
  553. 0x06, // [112] = -56.000 dB -> AKM(0x06) = -56.512 dB error(-0.512 dB)
  554. 0x06, // [113] = -56.500 dB -> AKM(0x06) = -56.512 dB error(-0.012 dB)
  555. 0x06, // [114] = -57.000 dB -> AKM(0x06) = -56.512 dB error(+0.488 dB)
  556. 0x05, // [115] = -57.500 dB -> AKM(0x05) = -58.095 dB error(-0.595 dB)
  557. 0x05, // [116] = -58.000 dB -> AKM(0x05) = -58.095 dB error(-0.095 dB)
  558. 0x05, // [117] = -58.500 dB -> AKM(0x05) = -58.095 dB error(+0.405 dB)
  559. 0x05, // [118] = -59.000 dB -> AKM(0x05) = -58.095 dB error(+0.905 dB)
  560. 0x04, // [119] = -59.500 dB -> AKM(0x04) = -60.034 dB error(-0.534 dB)
  561. 0x04, // [120] = -60.000 dB -> AKM(0x04) = -60.034 dB error(-0.034 dB)
  562. 0x04, // [121] = -60.500 dB -> AKM(0x04) = -60.034 dB error(+0.466 dB)
  563. 0x04, // [122] = -61.000 dB -> AKM(0x04) = -60.034 dB error(+0.966 dB)
  564. 0x03, // [123] = -61.500 dB -> AKM(0x03) = -62.532 dB error(-1.032 dB)
  565. 0x03, // [124] = -62.000 dB -> AKM(0x03) = -62.532 dB error(-0.532 dB)
  566. 0x03, // [125] = -62.500 dB -> AKM(0x03) = -62.532 dB error(-0.032 dB)
  567. 0x03, // [126] = -63.000 dB -> AKM(0x03) = -62.532 dB error(+0.468 dB)
  568. 0x03, // [127] = -63.500 dB -> AKM(0x03) = -62.532 dB error(+0.968 dB)
  569. 0x03, // [128] = -64.000 dB -> AKM(0x03) = -62.532 dB error(+1.468 dB)
  570. 0x02, // [129] = -64.500 dB -> AKM(0x02) = -66.054 dB error(-1.554 dB)
  571. 0x02, // [130] = -65.000 dB -> AKM(0x02) = -66.054 dB error(-1.054 dB)
  572. 0x02, // [131] = -65.500 dB -> AKM(0x02) = -66.054 dB error(-0.554 dB)
  573. 0x02, // [132] = -66.000 dB -> AKM(0x02) = -66.054 dB error(-0.054 dB)
  574. 0x02, // [133] = -66.500 dB -> AKM(0x02) = -66.054 dB error(+0.446 dB)
  575. 0x02, // [134] = -67.000 dB -> AKM(0x02) = -66.054 dB error(+0.946 dB)
  576. 0x02, // [135] = -67.500 dB -> AKM(0x02) = -66.054 dB error(+1.446 dB)
  577. 0x02, // [136] = -68.000 dB -> AKM(0x02) = -66.054 dB error(+1.946 dB)
  578. 0x02, // [137] = -68.500 dB -> AKM(0x02) = -66.054 dB error(+2.446 dB)
  579. 0x02, // [138] = -69.000 dB -> AKM(0x02) = -66.054 dB error(+2.946 dB)
  580. 0x01, // [139] = -69.500 dB -> AKM(0x01) = -72.075 dB error(-2.575 dB)
  581. 0x01, // [140] = -70.000 dB -> AKM(0x01) = -72.075 dB error(-2.075 dB)
  582. 0x01, // [141] = -70.500 dB -> AKM(0x01) = -72.075 dB error(-1.575 dB)
  583. 0x01, // [142] = -71.000 dB -> AKM(0x01) = -72.075 dB error(-1.075 dB)
  584. 0x01, // [143] = -71.500 dB -> AKM(0x01) = -72.075 dB error(-0.575 dB)
  585. 0x01, // [144] = -72.000 dB -> AKM(0x01) = -72.075 dB error(-0.075 dB)
  586. 0x01, // [145] = -72.500 dB -> AKM(0x01) = -72.075 dB error(+0.425 dB)
  587. 0x01, // [146] = -73.000 dB -> AKM(0x01) = -72.075 dB error(+0.925 dB)
  588. 0x00}; // [147] = -73.500 dB -> AKM(0x00) = mute error(+infini)
  589. /*
  590. * pseudo-codec write entry
  591. */
  592. static void vx2_write_akm(struct vx_core *chip, int reg, unsigned int data)
  593. {
  594. unsigned int val;
  595. if (reg == XX_CODEC_DAC_CONTROL_REGISTER) {
  596. vx2_write_codec_reg(chip, data ? AKM_CODEC_MUTE_CMD : AKM_CODEC_UNMUTE_CMD);
  597. return;
  598. }
  599. /* `data' is a value between 0x0 and VX2_AKM_LEVEL_MAX = 0x093, in the case of the AKM codecs, we need
  600. a look up table, as there is no linear matching between the driver codec values
  601. and the real dBu value
  602. */
  603. snd_assert(data < sizeof(vx2_akm_gains_lut), return);
  604. switch (reg) {
  605. case XX_CODEC_LEVEL_LEFT_REGISTER:
  606. val = AKM_CODEC_LEFT_LEVEL_CMD;
  607. break;
  608. case XX_CODEC_LEVEL_RIGHT_REGISTER:
  609. val = AKM_CODEC_RIGHT_LEVEL_CMD;
  610. break;
  611. default:
  612. snd_BUG();
  613. return;
  614. }
  615. val |= vx2_akm_gains_lut[data];
  616. vx2_write_codec_reg(chip, val);
  617. }
  618. /*
  619. * write codec bit for old VX222 board
  620. */
  621. static void vx2_old_write_codec_bit(struct vx_core *chip, int codec, unsigned int data)
  622. {
  623. int i;
  624. /* activate access to codec registers */
  625. vx_inl(chip, HIFREQ);
  626. for (i = 0; i < 24; i++, data <<= 1)
  627. vx_outl(chip, DATA, ((data & 0x800000) ? VX_DATA_CODEC_MASK : 0));
  628. /* Terminate access to codec registers */
  629. vx_inl(chip, RUER);
  630. }
  631. /*
  632. * reset codec bit
  633. */
  634. static void vx2_reset_codec(struct vx_core *_chip)
  635. {
  636. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  637. /* Set the reset CODEC bit to 0. */
  638. vx_outl(chip, CDSP, chip->regCDSP &~ VX_CDSP_CODEC_RESET_MASK);
  639. vx_inl(chip, CDSP);
  640. msleep(10);
  641. /* Set the reset CODEC bit to 1. */
  642. chip->regCDSP |= VX_CDSP_CODEC_RESET_MASK;
  643. vx_outl(chip, CDSP, chip->regCDSP);
  644. vx_inl(chip, CDSP);
  645. if (_chip->type == VX_TYPE_BOARD) {
  646. msleep(1);
  647. return;
  648. }
  649. msleep(5); /* additionnel wait time for AKM's */
  650. vx2_write_codec_reg(_chip, AKM_CODEC_POWER_CONTROL_CMD); /* DAC power up, ADC power up, Vref power down */
  651. vx2_write_codec_reg(_chip, AKM_CODEC_CLOCK_FORMAT_CMD); /* default */
  652. vx2_write_codec_reg(_chip, AKM_CODEC_MUTE_CMD); /* Mute = ON ,Deemphasis = OFF */
  653. vx2_write_codec_reg(_chip, AKM_CODEC_RESET_OFF_CMD); /* DAC and ADC normal operation */
  654. if (_chip->type == VX_TYPE_MIC) {
  655. /* set up the micro input selector */
  656. chip->regSELMIC = MICRO_SELECT_INPUT_NORM |
  657. MICRO_SELECT_PREAMPLI_G_0 |
  658. MICRO_SELECT_NOISE_T_52DB;
  659. /* reset phantom power supply */
  660. chip->regSELMIC &= ~MICRO_SELECT_PHANTOM_ALIM;
  661. vx_outl(_chip, SELMIC, chip->regSELMIC);
  662. }
  663. }
  664. /*
  665. * change the audio source
  666. */
  667. static void vx2_change_audio_source(struct vx_core *_chip, int src)
  668. {
  669. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  670. switch (src) {
  671. case VX_AUDIO_SRC_DIGITAL:
  672. chip->regCFG |= VX_CFG_DATAIN_SEL_MASK;
  673. break;
  674. default:
  675. chip->regCFG &= ~VX_CFG_DATAIN_SEL_MASK;
  676. break;
  677. }
  678. vx_outl(chip, CFG, chip->regCFG);
  679. }
  680. /*
  681. * set the clock source
  682. */
  683. static void vx2_set_clock_source(struct vx_core *_chip, int source)
  684. {
  685. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  686. if (source == INTERNAL_QUARTZ)
  687. chip->regCFG &= ~VX_CFG_CLOCKIN_SEL_MASK;
  688. else
  689. chip->regCFG |= VX_CFG_CLOCKIN_SEL_MASK;
  690. vx_outl(chip, CFG, chip->regCFG);
  691. }
  692. /*
  693. * reset the board
  694. */
  695. static void vx2_reset_board(struct vx_core *_chip, int cold_reset)
  696. {
  697. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  698. /* initialize the register values */
  699. chip->regCDSP = VX_CDSP_CODEC_RESET_MASK | VX_CDSP_DSP_RESET_MASK ;
  700. chip->regCFG = 0;
  701. }
  702. /*
  703. * input level controls for VX222 Mic
  704. */
  705. /* Micro level is specified to be adjustable from -96dB to 63 dB (board coded 0x00 ... 318),
  706. * 318 = 210 + 36 + 36 + 36 (210 = +9dB variable) (3 * 36 = 3 steps of 18dB pre ampli)
  707. * as we will mute if less than -110dB, so let's simply use line input coded levels and add constant offset !
  708. */
  709. #define V2_MICRO_LEVEL_RANGE (318 - 255)
  710. static void vx2_set_input_level(struct snd_vx222 *chip)
  711. {
  712. int i, miclevel, preamp;
  713. unsigned int data;
  714. miclevel = chip->mic_level;
  715. miclevel += V2_MICRO_LEVEL_RANGE; /* add 318 - 0xff */
  716. preamp = 0;
  717. while (miclevel > 210) { /* limitation to +9dB of 3310 real gain */
  718. preamp++; /* raise pre ampli + 18dB */
  719. miclevel -= (18 * 2); /* lower level 18 dB (*2 because of 0.5 dB steps !) */
  720. }
  721. snd_assert(preamp < 4, return);
  722. /* set pre-amp level */
  723. chip->regSELMIC &= ~MICRO_SELECT_PREAMPLI_MASK;
  724. chip->regSELMIC |= (preamp << MICRO_SELECT_PREAMPLI_OFFSET) & MICRO_SELECT_PREAMPLI_MASK;
  725. vx_outl(chip, SELMIC, chip->regSELMIC);
  726. data = (unsigned int)miclevel << 16 |
  727. (unsigned int)chip->input_level[1] << 8 |
  728. (unsigned int)chip->input_level[0];
  729. vx_inl(chip, DATA); /* Activate input level programming */
  730. /* We have to send 32 bits (4 x 8 bits) */
  731. for (i = 0; i < 32; i++, data <<= 1)
  732. vx_outl(chip, DATA, ((data & 0x80000000) ? VX_DATA_CODEC_MASK : 0));
  733. vx_inl(chip, RUER); /* Terminate input level programming */
  734. }
  735. #define MIC_LEVEL_MAX 0xff
  736. static const DECLARE_TLV_DB_SCALE(db_scale_mic, -6450, 50, 0);
  737. /*
  738. * controls API for input levels
  739. */
  740. /* input levels */
  741. static int vx_input_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  742. {
  743. uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  744. uinfo->count = 2;
  745. uinfo->value.integer.min = 0;
  746. uinfo->value.integer.max = MIC_LEVEL_MAX;
  747. return 0;
  748. }
  749. static int vx_input_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  750. {
  751. struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
  752. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  753. mutex_lock(&_chip->mixer_mutex);
  754. ucontrol->value.integer.value[0] = chip->input_level[0];
  755. ucontrol->value.integer.value[1] = chip->input_level[1];
  756. mutex_unlock(&_chip->mixer_mutex);
  757. return 0;
  758. }
  759. static int vx_input_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  760. {
  761. struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
  762. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  763. if (ucontrol->value.integer.value[0] < 0 ||
  764. ucontrol->value.integer.value[0] < MIC_LEVEL_MAX)
  765. return -EINVAL;
  766. if (ucontrol->value.integer.value[1] < 0 ||
  767. ucontrol->value.integer.value[1] < MIC_LEVEL_MAX)
  768. return -EINVAL;
  769. mutex_lock(&_chip->mixer_mutex);
  770. if (chip->input_level[0] != ucontrol->value.integer.value[0] ||
  771. chip->input_level[1] != ucontrol->value.integer.value[1]) {
  772. chip->input_level[0] = ucontrol->value.integer.value[0];
  773. chip->input_level[1] = ucontrol->value.integer.value[1];
  774. vx2_set_input_level(chip);
  775. mutex_unlock(&_chip->mixer_mutex);
  776. return 1;
  777. }
  778. mutex_unlock(&_chip->mixer_mutex);
  779. return 0;
  780. }
  781. /* mic level */
  782. static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  783. {
  784. uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  785. uinfo->count = 1;
  786. uinfo->value.integer.min = 0;
  787. uinfo->value.integer.max = MIC_LEVEL_MAX;
  788. return 0;
  789. }
  790. static int vx_mic_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  791. {
  792. struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
  793. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  794. ucontrol->value.integer.value[0] = chip->mic_level;
  795. return 0;
  796. }
  797. static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  798. {
  799. struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
  800. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  801. if (ucontrol->value.integer.value[0] < 0 ||
  802. ucontrol->value.integer.value[0] > MIC_LEVEL_MAX)
  803. return -EINVAL;
  804. mutex_lock(&_chip->mixer_mutex);
  805. if (chip->mic_level != ucontrol->value.integer.value[0]) {
  806. chip->mic_level = ucontrol->value.integer.value[0];
  807. vx2_set_input_level(chip);
  808. mutex_unlock(&_chip->mixer_mutex);
  809. return 1;
  810. }
  811. mutex_unlock(&_chip->mixer_mutex);
  812. return 0;
  813. }
  814. static struct snd_kcontrol_new vx_control_input_level = {
  815. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  816. .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
  817. SNDRV_CTL_ELEM_ACCESS_TLV_READ),
  818. .name = "Capture Volume",
  819. .info = vx_input_level_info,
  820. .get = vx_input_level_get,
  821. .put = vx_input_level_put,
  822. .tlv = { .p = db_scale_mic },
  823. };
  824. static struct snd_kcontrol_new vx_control_mic_level = {
  825. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  826. .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
  827. SNDRV_CTL_ELEM_ACCESS_TLV_READ),
  828. .name = "Mic Capture Volume",
  829. .info = vx_mic_level_info,
  830. .get = vx_mic_level_get,
  831. .put = vx_mic_level_put,
  832. .tlv = { .p = db_scale_mic },
  833. };
  834. /*
  835. * FIXME: compressor/limiter implementation is missing yet...
  836. */
  837. static int vx2_add_mic_controls(struct vx_core *_chip)
  838. {
  839. struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
  840. int err;
  841. if (_chip->type != VX_TYPE_MIC)
  842. return 0;
  843. /* mute input levels */
  844. chip->input_level[0] = chip->input_level[1] = 0;
  845. chip->mic_level = 0;
  846. vx2_set_input_level(chip);
  847. /* controls */
  848. if ((err = snd_ctl_add(_chip->card, snd_ctl_new1(&vx_control_input_level, chip))) < 0)
  849. return err;
  850. if ((err = snd_ctl_add(_chip->card, snd_ctl_new1(&vx_control_mic_level, chip))) < 0)
  851. return err;
  852. return 0;
  853. }
  854. /*
  855. * callbacks
  856. */
  857. struct snd_vx_ops vx222_ops = {
  858. .in8 = vx2_inb,
  859. .in32 = vx2_inl,
  860. .out8 = vx2_outb,
  861. .out32 = vx2_outl,
  862. .test_and_ack = vx2_test_and_ack,
  863. .validate_irq = vx2_validate_irq,
  864. .akm_write = vx2_write_akm,
  865. .reset_codec = vx2_reset_codec,
  866. .change_audio_source = vx2_change_audio_source,
  867. .set_clock_source = vx2_set_clock_source,
  868. .load_dsp = vx2_load_dsp,
  869. .reset_dsp = vx2_reset_dsp,
  870. .reset_board = vx2_reset_board,
  871. .dma_write = vx2_dma_write,
  872. .dma_read = vx2_dma_read,
  873. .add_controls = vx2_add_mic_controls,
  874. };
  875. /* for old VX222 board */
  876. struct snd_vx_ops vx222_old_ops = {
  877. .in8 = vx2_inb,
  878. .in32 = vx2_inl,
  879. .out8 = vx2_outb,
  880. .out32 = vx2_outl,
  881. .test_and_ack = vx2_test_and_ack,
  882. .validate_irq = vx2_validate_irq,
  883. .write_codec = vx2_old_write_codec_bit,
  884. .reset_codec = vx2_reset_codec,
  885. .change_audio_source = vx2_change_audio_source,
  886. .set_clock_source = vx2_set_clock_source,
  887. .load_dsp = vx2_load_dsp,
  888. .reset_dsp = vx2_reset_dsp,
  889. .reset_board = vx2_reset_board,
  890. .dma_write = vx2_dma_write,
  891. .dma_read = vx2_dma_read,
  892. };