PageRenderTime 62ms CodeModel.GetById 27ms RepoModel.GetById 1ms app.codeStats 0ms

/sound/pci/ca0106/ca0106_main.c

https://bitbucket.org/abioy/linux
C | 1909 lines | 1337 code | 207 blank | 365 comment | 134 complexity | b4c0926c966e9af12b2af019a1705f56 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0 
    

  1. /*
    2. 

  2.  *  Copyright (c) 2004 James Courtier-Dutton <James@superbug.demon.co.uk>
    3. 

  3.  *  Driver CA0106 chips. e.g. Sound Blaster Audigy LS and Live 24bit
    4. 

  4.  *  Version: 0.0.25
    5. 

  5.  *
    6. 

  6.  *  FEATURES currently supported:
    7. 

  7.  *    Front, Rear and Center/LFE.
    8. 

  8.  *    Surround40 and Surround51.
    9. 

  9.  *    Capture from MIC an LINE IN input.
    10. 

  10.  *    SPDIF digital playback of PCM stereo and AC3/DTS works.
    11. 

  11.  *    (One can use a standard mono mini-jack to one RCA plugs cable.
    12. 

  12.  *     or one can use a standard stereo mini-jack to two RCA plugs cable.
    13. 

  13.  *     Plug one of the RCA plugs into the Coax input of the external decoder/receiver.)
    14. 

  14.  *    ( In theory one could output 3 different AC3 streams at once, to 3 different SPDIF outputs. )
    15. 

  15.  *    Notes on how to capture sound:
    16. 

  16.  *      The AC97 is used in the PLAYBACK direction.
    17. 

  17.  *      The output from the AC97 chip, instead of reaching the speakers, is fed into the Philips 1361T ADC.
    18. 

  18.  *      So, to record from the MIC, set the MIC Playback volume to max,
    19. 

  19.  *      unmute the MIC and turn up the MASTER Playback volume.
    20. 

  20.  *      So, to prevent feedback when capturing, minimise the "Capture feedback into Playback" volume.
    21. 

  21.  *   
    22. 

  22.  *    The only playback controls that currently do anything are: -
    23. 

  23.  *    Analog Front
    24. 

  24.  *    Analog Rear
    25. 

  25.  *    Analog Center/LFE
    26. 

  26.  *    SPDIF Front
    27. 

  27.  *    SPDIF Rear
    28. 

  28.  *    SPDIF Center/LFE
    29. 

  29.  *   
    30. 

  30.  *    For capture from Mic in or Line in.
    31. 

  31.  *    Digital/Analog ( switch must be in Analog mode for CAPTURE. )
    32. 

  32.  * 
    33. 

  33.  *    CAPTURE feedback into PLAYBACK
    34. 

  34.  * 
    35. 

  35.  *  Changelog:
    36. 

  36.  *    Support interrupts per period.
    37. 

  37.  *    Removed noise from Center/LFE channel when in Analog mode.
    38. 

  38.  *    Rename and remove mixer controls.
    39. 

  39.  *  0.0.6
    40. 

  40.  *    Use separate card based DMA buffer for periods table list.
    41. 

  41.  *  0.0.7
    42. 

  42.  *    Change remove and rename ctrls into lists.
    43. 

  43.  *  0.0.8
    44. 

  44.  *    Try to fix capture sources.
    45. 

  45.  *  0.0.9
    46. 

  46.  *    Fix AC3 output.
    47. 

  47.  *    Enable S32_LE format support.
    48. 

  48.  *  0.0.10
    49. 

  49.  *    Enable playback 48000 and 96000 rates. (Rates other that these do not work, even with "plug:front".)
    50. 

  50.  *  0.0.11
    51. 

  51.  *    Add Model name recognition.
    52. 

  52.  *  0.0.12
    53. 

  53.  *    Correct interrupt timing. interrupt at end of period, instead of in the middle of a playback period.
    54. 

  54.  *    Remove redundent "voice" handling.
    55. 

  55.  *  0.0.13
    56. 

  56.  *    Single trigger call for multi channels.
    57. 

  57.  *  0.0.14
    58. 

  58.  *    Set limits based on what the sound card hardware can do.
    59. 

  59.  *    playback periods_min=2, periods_max=8
    60. 

  60.  *    capture hw constraints require period_size = n * 64 bytes.
    61. 

  61.  *    playback hw constraints require period_size = n * 64 bytes.
    62. 

  62.  *  0.0.15
    63. 

  63.  *    Minor updates.
    64. 

  64.  *  0.0.16
    65. 

  65.  *    Implement 192000 sample rate.
    66. 

  66.  *  0.0.17
    67. 

  67.  *    Add support for SB0410 and SB0413.
    68. 

  68.  *  0.0.18
    69. 

  69.  *    Modified Copyright message.
    70. 

  70.  *  0.0.19
    71. 

  71.  *    Finally fix support for SB Live 24 bit. SB0410 and SB0413.
    72. 

  72.  *    The output codec needs resetting, otherwise all output is muted.
    73. 

  73.  *  0.0.20
    74. 

  74.  *    Merge "pci_disable_device(pci);" fixes.
    75. 

  75.  *  0.0.21
    76. 

  76.  *    Add 4 capture channels. (SPDIF only comes in on channel 0. )
    77. 

  77.  *    Add SPDIF capture using optional digital I/O module for SB Live 24bit. (Analog capture does not yet work.)
    78. 

  78.  *  0.0.22
    79. 

  79.  *    Add support for MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97. From kiksen, bug #901
    80. 

  80.  *  0.0.23
    81. 

  81.  *    Implement support for Line-in capture on SB Live 24bit.
    82. 

  82.  *  0.0.24
    83. 

  83.  *    Add support for mute control on SB Live 24bit (cards w/ SPI DAC)
    84. 

  84.  *  0.0.25
    85. 

  85.  *    Powerdown SPI DAC channels when not in use
    86. 

  86.  *
    87. 

  87.  *  BUGS:
    88. 

  88.  *    Some stability problems when unloading the snd-ca0106 kernel module.
    89. 

  89.  *    --
    90. 

  90.  *
    91. 

  91.  *  TODO:
    92. 

  92.  *    4 Capture channels, only one implemented so far.
    93. 

  93.  *    Other capture rates apart from 48khz not implemented.
    94. 

  94.  *    MIDI
    95. 

  95.  *    --
    96. 

  96.  *  GENERAL INFO:
    97. 

  97.  *    Model: SB0310
    98. 

  98.  *    P17 Chip: CA0106-DAT
    99. 

  99.  *    AC97 Codec: STAC 9721
    100. 

  100.  *    ADC: Philips 1361T (Stereo 24bit)
    101. 

  101.  *    DAC: WM8746EDS (6-channel, 24bit, 192Khz)
    102. 

  102.  *
    103. 

  103.  *  GENERAL INFO:
    104. 

  104.  *    Model: SB0410
    105. 

  105.  *    P17 Chip: CA0106-DAT
    106. 

  106.  *    AC97 Codec: None
    107. 

  107.  *    ADC: WM8775EDS (4 Channel)
    108. 

  108.  *    DAC: CS4382 (114 dB, 24-Bit, 192 kHz, 8-Channel D/A Converter with DSD Support)
    109. 

  109.  *    SPDIF Out control switches between Mic in and SPDIF out.
    110. 

  110.  *    No sound out or mic input working yet.
    111. 

  111.  * 
    112. 

  112.  *  GENERAL INFO:
    113. 

  113.  *    Model: SB0413
    114. 

  114.  *    P17 Chip: CA0106-DAT
    115. 

  115.  *    AC97 Codec: None.
    116. 

  116.  *    ADC: Unknown
    117. 

  117.  *    DAC: Unknown
    118. 

  118.  *    Trying to handle it like the SB0410.
    119. 

  119.  *
    120. 

  120.  *  This code was initally based on code from ALSA's emu10k1x.c which is:
    121. 

  121.  *  Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
    122. 

  122.  *
    123. 

  123.  *   This program is free software; you can redistribute it and/or modify
    124. 

  124.  *   it under the terms of the GNU General Public License as published by
    125. 

  125.  *   the Free Software Foundation; either version 2 of the License, or
    126. 

  126.  *   (at your option) any later version.
    127. 

  127.  *
    128. 

  128.  *   This program is distributed in the hope that it will be useful,
    129. 

  129.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
    130. 

  130.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    131. 

  131.  *   GNU General Public License for more details.
    132. 

  132.  *
    133. 

  133.  *   You should have received a copy of the GNU General Public License
    134. 

  134.  *   along with this program; if not, write to the Free Software
    135. 

  135.  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    136. 

  136.  *
    137. 

  137.  */
    138. 

  138. #include <linux/delay.h>
    139. 

  139. #include <linux/init.h>
    140. 

  140. #include <linux/interrupt.h>
    141. 

  141. #include <linux/pci.h>
    142. 

  142. #include <linux/slab.h>
    143. 

  143. #include <linux/moduleparam.h>
    144. 

  144. #include <linux/dma-mapping.h>
    145. 

  145. #include <sound/core.h>
    146. 

  146. #include <sound/initval.h>
    147. 

  147. #include <sound/pcm.h>
    148. 

  148. #include <sound/ac97_codec.h>
    149. 

  149. #include <sound/info.h>
    150. 

  150. 

  151. MODULE_AUTHOR("James Courtier-Dutton <James@superbug.demon.co.uk>");
    152. 

  152. MODULE_DESCRIPTION("CA0106");
    153. 

  153. MODULE_LICENSE("GPL");
    154. 

  154. MODULE_SUPPORTED_DEVICE("{{Creative,SB CA0106 chip}}");
    155. 

  155. 

  156. // module parameters (see "Module Parameters")
    157. 

  157. static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
    158. 

  158. static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
    159. 

  159. static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
    160. 

  160. static uint subsystem[SNDRV_CARDS]; /* Force card subsystem model */
    161. 

  161. 

  162. module_param_array(index, int, NULL, 0444);
    163. 

  163. MODULE_PARM_DESC(index, "Index value for the CA0106 soundcard.");
    164. 

  164. module_param_array(id, charp, NULL, 0444);
    165. 

  165. MODULE_PARM_DESC(id, "ID string for the CA0106 soundcard.");
    166. 

  166. module_param_array(enable, bool, NULL, 0444);
    167. 

  167. MODULE_PARM_DESC(enable, "Enable the CA0106 soundcard.");
    168. 

  168. module_param_array(subsystem, uint, NULL, 0444);
    169. 

  169. MODULE_PARM_DESC(subsystem, "Force card subsystem model.");
    170. 

  170. 

  171. #include "ca0106.h"
    172. 

  172. 

  173. static struct snd_ca0106_details ca0106_chip_details[] = {
    174. 

  174. 	 /* Sound Blaster X-Fi Extreme Audio. This does not have an AC97. 53SB079000000 */
    175. 

  175. 	 /* It is really just a normal SB Live 24bit. */
    176. 

  176. 	 /* Tested:
    177. 

  177. 	  * See ALSA bug#3251
    178. 

  178. 	  */
    179. 

  179. 	 { .serial = 0x10131102,
    180. 

  180. 	   .name   = "X-Fi Extreme Audio [SBxxxx]",
    181. 

  181. 	   .gpio_type = 1,
    182. 

  182. 	   .i2c_adc = 1 } ,
    183. 

  183. 	 /* Sound Blaster X-Fi Extreme Audio. This does not have an AC97. 53SB079000000 */
    184. 

  184. 	 /* It is really just a normal SB Live 24bit. */
    185. 

  185. 	 /*
    186. 

  186.  	  * CTRL:CA0111-WTLF
    187. 

  187. 	  * ADC: WM8775SEDS
    188. 

  188. 	  * DAC: CS4382-KQZ
    189. 

  189. 	  */
    190. 

  190. 	 /* Tested:
    191. 

  191. 	  * Playback on front, rear, center/lfe speakers
    192. 

  192. 	  * Capture from Mic in.
    193. 

  193. 	  * Not-Tested:
    194. 

  194. 	  * Capture from Line in.
    195. 

  195. 	  * Playback to digital out.
    196. 

  196. 	  */
    197. 

  197. 	 { .serial = 0x10121102,
    198. 

  198. 	   .name   = "X-Fi Extreme Audio [SB0790]",
    199. 

  199. 	   .gpio_type = 1,
    200. 

  200. 	   .i2c_adc = 1 } ,
    201. 

  201. 	 /* New Dell Sound Blaster Live! 7.1 24bit. This does not have an AC97.  */
    202. 

  202. 	 /* AudigyLS[SB0310] */
    203. 

  203. 	 { .serial = 0x10021102,
    204. 

  204. 	   .name   = "AudigyLS [SB0310]",
    205. 

  205. 	   .ac97   = 1 } , 
    206. 

  206. 	 /* Unknown AudigyLS that also says SB0310 on it */
    207. 

  207. 	 { .serial = 0x10051102,
    208. 

  208. 	   .name   = "AudigyLS [SB0310b]",
    209. 

  209. 	   .ac97   = 1 } ,
    210. 

  210. 	 /* New Sound Blaster Live! 7.1 24bit. This does not have an AC97. 53SB041000001 */
    211. 

  211. 	 { .serial = 0x10061102,
    212. 

  212. 	   .name   = "Live! 7.1 24bit [SB0410]",
    213. 

  213. 	   .gpio_type = 1,
    214. 

  214. 	   .i2c_adc = 1 } ,
    215. 

  215. 	 /* New Dell Sound Blaster Live! 7.1 24bit. This does not have an AC97.  */
    216. 

  216. 	 { .serial = 0x10071102,
    217. 

  217. 	   .name   = "Live! 7.1 24bit [SB0413]",
    218. 

  218. 	   .gpio_type = 1,
    219. 

  219. 	   .i2c_adc = 1 } ,
    220. 

  220. 	 /* New Audigy SE. Has a different DAC. */
    221. 

  221. 	 /* SB0570:
    222. 

  222. 	  * CTRL:CA0106-DAT
    223. 

  223. 	  * ADC: WM8775EDS
    224. 

  224. 	  * DAC: WM8768GEDS
    225. 

  225. 	  */
    226. 

  226. 	 { .serial = 0x100a1102,
    227. 

  227. 	   .name   = "Audigy SE [SB0570]",
    228. 

  228. 	   .gpio_type = 1,
    229. 

  229. 	   .i2c_adc = 1,
    230. 

  230. 	   .spi_dac = 1 } ,
    231. 

  231. 	 /* New Audigy LS. Has a different DAC. */
    232. 

  232. 	 /* SB0570:
    233. 

  233. 	  * CTRL:CA0106-DAT
    234. 

  234. 	  * ADC: WM8775EDS
    235. 

  235. 	  * DAC: WM8768GEDS
    236. 

  236. 	  */
    237. 

  237. 	 { .serial = 0x10111102,
    238. 

  238. 	   .name   = "Audigy SE OEM [SB0570a]",
    239. 

  239. 	   .gpio_type = 1,
    240. 

  240. 	   .i2c_adc = 1,
    241. 

  241. 	   .spi_dac = 1 } ,
    242. 

  242. 	 /* MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97 */
    243. 

  243. 	 /* SB0438
    244. 

  244. 	  * CTRL:CA0106-DAT
    245. 

  245. 	  * ADC: WM8775SEDS
    246. 

  246. 	  * DAC: CS4382-KQZ
    247. 

  247. 	  */
    248. 

  248. 	 { .serial = 0x10091462,
    249. 

  249. 	   .name   = "MSI K8N Diamond MB [SB0438]",
    250. 

  250. 	   .gpio_type = 2,
    251. 

  251. 	   .i2c_adc = 1 } ,
    252. 

  252. 	 /* MSI K8N Diamond PLUS MB */
    253. 

  253. 	 { .serial = 0x10091102,
    254. 

  254. 	   .name   = "MSI K8N Diamond MB",
    255. 

  255. 	   .gpio_type = 2,
    256. 

  256. 	   .i2c_adc = 1,
    257. 

  257. 	   .spi_dac = 1 } ,
    258. 

  258. 	/* Giga-byte GA-G1975X mobo
    259. 

  259. 	 * Novell bnc#395807
    260. 

  260. 	 */
    261. 

  261. 	/* FIXME: the GPIO and I2C setting aren't tested well */
    262. 

  262. 	{ .serial = 0x1458a006,
    263. 

  263. 	  .name = "Giga-byte GA-G1975X",
    264. 

  264. 	  .gpio_type = 1,
    265. 

  265. 	  .i2c_adc = 1 },
    266. 

  266. 	 /* Shuttle XPC SD31P which has an onboard Creative Labs
    267. 

  267. 	  * Sound Blaster Live! 24-bit EAX
    268. 

  268. 	  * high-definition 7.1 audio processor".
    269. 

  269. 	  * Added using info from andrewvegan in alsa bug #1298
    270. 

  270. 	  */
    271. 

  271. 	 { .serial = 0x30381297,
    272. 

  272. 	   .name   = "Shuttle XPC SD31P [SD31P]",
    273. 

  273. 	   .gpio_type = 1,
    274. 

  274. 	   .i2c_adc = 1 } ,
    275. 

  275. 	/* Shuttle XPC SD11G5 which has an onboard Creative Labs
    276. 

  276. 	 * Sound Blaster Live! 24-bit EAX
    277. 

  277. 	 * high-definition 7.1 audio processor".
    278. 

  278. 	 * Fixes ALSA bug#1600
    279. 

  279.          */
    280. 

  280. 	{ .serial = 0x30411297,
    281. 

  281. 	  .name = "Shuttle XPC SD11G5 [SD11G5]",
    282. 

  282. 	  .gpio_type = 1,
    283. 

  283. 	  .i2c_adc = 1 } ,
    284. 

  284. 	 { .serial = 0,
    285. 

  285. 	   .name   = "AudigyLS [Unknown]" }
    286. 

  286. };
    287. 

  287. 

  288. /* hardware definition */
    289. 

  289. static struct snd_pcm_hardware snd_ca0106_playback_hw = {
    290. 

  290. 	.info =			SNDRV_PCM_INFO_MMAP | 
    291. 

  291. 				SNDRV_PCM_INFO_INTERLEAVED |
    292. 

  292. 				SNDRV_PCM_INFO_BLOCK_TRANSFER |
    293. 

  293. 				SNDRV_PCM_INFO_MMAP_VALID |
    294. 

  294. 				SNDRV_PCM_INFO_SYNC_START,
    295. 

  295. 	.formats =		SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
    296. 

  296. 	.rates =		(SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 |
    297. 

  297. 				 SNDRV_PCM_RATE_192000),
    298. 

  298. 	.rate_min =		48000,
    299. 

  299. 	.rate_max =		192000,
    300. 

  300. 	.channels_min =		2,  //1,
    301. 

  301. 	.channels_max =		2,  //6,
    302. 

  302. 	.buffer_bytes_max =	((65536 - 64) * 8),
    303. 

  303. 	.period_bytes_min =	64,
    304. 

  304. 	.period_bytes_max =	(65536 - 64),
    305. 

  305. 	.periods_min =		2,
    306. 

  306. 	.periods_max =		8,
    307. 

  307. 	.fifo_size =		0,
    308. 

  308. };
    309. 

  309. 

  310. static struct snd_pcm_hardware snd_ca0106_capture_hw = {
    311. 

  311. 	.info =			(SNDRV_PCM_INFO_MMAP | 
    312. 

  312. 				 SNDRV_PCM_INFO_INTERLEAVED |
    313. 

  313. 				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
    314. 

  314. 				 SNDRV_PCM_INFO_MMAP_VALID),
    315. 

  315. 	.formats =		SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
    316. 

  316. #if 0 /* FIXME: looks like 44.1kHz capture causes noisy output on 48kHz */
    317. 

  317. 	.rates =		(SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
    318. 

  318. 				 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000),
    319. 

  319. 	.rate_min =		44100,
    320. 

  320. #else
    321. 

  321. 	.rates =		(SNDRV_PCM_RATE_48000 |
    322. 

  322. 				 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000),
    323. 

  323. 	.rate_min =		48000,
    324. 

  324. #endif /* FIXME */
    325. 

  325. 	.rate_max =		192000,
    326. 

  326. 	.channels_min =		2,
    327. 

  327. 	.channels_max =		2,
    328. 

  328. 	.buffer_bytes_max =	65536 - 128,
    329. 

  329. 	.period_bytes_min =	64,
    330. 

  330. 	.period_bytes_max =	32768 - 64,
    331. 

  331. 	.periods_min =		2,
    332. 

  332. 	.periods_max =		2,
    333. 

  333. 	.fifo_size =		0,
    334. 

  334. };
    335. 

  335. 

  336. unsigned int snd_ca0106_ptr_read(struct snd_ca0106 * emu, 
    337. 

  337. 					  unsigned int reg, 
    338. 

  338. 					  unsigned int chn)
    339. 

  339. {
    340. 

  340. 	unsigned long flags;
    341. 

  341. 	unsigned int regptr, val;
    342. 

  342.   
    343. 

  343. 	regptr = (reg << 16) | chn;
    344. 

  344. 

  345. 	spin_lock_irqsave(&emu->emu_lock, flags);
    346. 

  346. 	outl(regptr, emu->port + PTR);
    347. 

  347. 	val = inl(emu->port + DATA);
    348. 

  348. 	spin_unlock_irqrestore(&emu->emu_lock, flags);
    349. 

  349. 	return val;
    350. 

  350. }
    351. 

  351. 

  352. void snd_ca0106_ptr_write(struct snd_ca0106 *emu, 
    353. 

  353. 				   unsigned int reg, 
    354. 

  354. 				   unsigned int chn, 
    355. 

  355. 				   unsigned int data)
    356. 

  356. {
    357. 

  357. 	unsigned int regptr;
    358. 

  358. 	unsigned long flags;
    359. 

  359. 

  360. 	regptr = (reg << 16) | chn;
    361. 

  361. 

  362. 	spin_lock_irqsave(&emu->emu_lock, flags);
    363. 

  363. 	outl(regptr, emu->port + PTR);
    364. 

  364. 	outl(data, emu->port + DATA);
    365. 

  365. 	spin_unlock_irqrestore(&emu->emu_lock, flags);
    366. 

  366. }
    367. 

  367. 

  368. int snd_ca0106_spi_write(struct snd_ca0106 * emu,
    369. 

  369. 				   unsigned int data)
    370. 

  370. {
    371. 

  371. 	unsigned int reset, set;
    372. 

  372. 	unsigned int reg, tmp;
    373. 

  373. 	int n, result;
    374. 

  374. 	reg = SPI;
    375. 

  375. 	if (data > 0xffff) /* Only 16bit values allowed */
    376. 

  376. 		return 1;
    377. 

  377. 	tmp = snd_ca0106_ptr_read(emu, reg, 0);
    378. 

  378. 	reset = (tmp & ~0x3ffff) | 0x20000; /* Set xxx20000 */
    379. 

  379. 	set = reset | 0x10000; /* Set xxx1xxxx */
    380. 

  380. 	snd_ca0106_ptr_write(emu, reg, 0, reset | data);
    381. 

  381. 	tmp = snd_ca0106_ptr_read(emu, reg, 0); /* write post */
    382. 

  382. 	snd_ca0106_ptr_write(emu, reg, 0, set | data);
    383. 

  383. 	result = 1;
    384. 

  384. 	/* Wait for status bit to return to 0 */
    385. 

  385. 	for (n = 0; n < 100; n++) {
    386. 

  386. 		udelay(10);
    387. 

  387. 		tmp = snd_ca0106_ptr_read(emu, reg, 0);
    388. 

  388. 		if (!(tmp & 0x10000)) {
    389. 

  389. 			result = 0;
    390. 

  390. 			break;
    391. 

  391. 		}
    392. 

  392. 	}
    393. 

  393. 	if (result) /* Timed out */
    394. 

  394. 		return 1;
    395. 

  395. 	snd_ca0106_ptr_write(emu, reg, 0, reset | data);
    396. 

  396. 	tmp = snd_ca0106_ptr_read(emu, reg, 0); /* Write post */
    397. 

  397. 	return 0;
    398. 

  398. }
    399. 

  399. 

  400. /* The ADC does not support i2c read, so only write is implemented */
    401. 

  401. int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
    402. 

  402. 				u32 reg,
    403. 

  403. 				u32 value)
    404. 

  404. {
    405. 

  405. 	u32 tmp;
    406. 

  406. 	int timeout = 0;
    407. 

  407. 	int status;
    408. 

  408. 	int retry;
    409. 

  409. 	if ((reg > 0x7f) || (value > 0x1ff)) {
    410. 

  410. 		snd_printk(KERN_ERR "i2c_write: invalid values.\n");
    411. 

  411. 		return -EINVAL;
    412. 

  412. 	}
    413. 

  413. 

  414. 	tmp = reg << 25 | value << 16;
    415. 

  415. 	/*
    416. 

  416. 	snd_printk(KERN_DEBUG "I2C-write:reg=0x%x, value=0x%x\n", reg, value);
    417. 

  417. 	*/
    418. 

  418. 	/* Not sure what this I2C channel controls. */
    419. 

  419. 	/* snd_ca0106_ptr_write(emu, I2C_D0, 0, tmp); */
    420. 

  420. 

  421. 	/* This controls the I2C connected to the WM8775 ADC Codec */
    422. 

  422. 	snd_ca0106_ptr_write(emu, I2C_D1, 0, tmp);
    423. 

  423. 

  424. 	for (retry = 0; retry < 10; retry++) {
    425. 

  425. 		/* Send the data to i2c */
    426. 

  426. 		//tmp = snd_ca0106_ptr_read(emu, I2C_A, 0);
    427. 

  427. 		//tmp = tmp & ~(I2C_A_ADC_READ|I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD_MASK);
    428. 

  428. 		tmp = 0;
    429. 

  429. 		tmp = tmp | (I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD);
    430. 

  430. 		snd_ca0106_ptr_write(emu, I2C_A, 0, tmp);
    431. 

  431. 

  432. 		/* Wait till the transaction ends */
    433. 

  433. 		while (1) {
    434. 

  434. 			status = snd_ca0106_ptr_read(emu, I2C_A, 0);
    435. 

  435. 			/*snd_printk(KERN_DEBUG "I2C:status=0x%x\n", status);*/
    436. 

  436. 			timeout++;
    437. 

  437. 			if ((status & I2C_A_ADC_START) == 0)
    438. 

  438. 				break;
    439. 

  439. 

  440. 			if (timeout > 1000)
    441. 

  441. 				break;
    442. 

  442. 		}
    443. 

  443. 		//Read back and see if the transaction is successful
    444. 

  444. 		if ((status & I2C_A_ADC_ABORT) == 0)
    445. 

  445. 			break;
    446. 

  446. 	}
    447. 

  447. 

  448. 	if (retry == 10) {
    449. 

  449. 		snd_printk(KERN_ERR "Writing to ADC failed!\n");
    450. 

  450. 		return -EINVAL;
    451. 

  451. 	}
    452. 

  452.     
    453. 

  453.     	return 0;
    454. 

  454. }
    455. 

  455. 

  456. 

  457. static void snd_ca0106_intr_enable(struct snd_ca0106 *emu, unsigned int intrenb)
    458. 

  458. {
    459. 

  459. 	unsigned long flags;
    460. 

  460. 	unsigned int intr_enable;
    461. 

  461. 

  462. 	spin_lock_irqsave(&emu->emu_lock, flags);
    463. 

  463. 	intr_enable = inl(emu->port + INTE) | intrenb;
    464. 

  464. 	outl(intr_enable, emu->port + INTE);
    465. 

  465. 	spin_unlock_irqrestore(&emu->emu_lock, flags);
    466. 

  466. }
    467. 

  467. 

  468. static void snd_ca0106_intr_disable(struct snd_ca0106 *emu, unsigned int intrenb)
    469. 

  469. {
    470. 

  470. 	unsigned long flags;
    471. 

  471. 	unsigned int intr_enable;
    472. 

  472. 

  473. 	spin_lock_irqsave(&emu->emu_lock, flags);
    474. 

  474. 	intr_enable = inl(emu->port + INTE) & ~intrenb;
    475. 

  475. 	outl(intr_enable, emu->port + INTE);
    476. 

  476. 	spin_unlock_irqrestore(&emu->emu_lock, flags);
    477. 

  477. }
    478. 

  478. 

  479. 

  480. static void snd_ca0106_pcm_free_substream(struct snd_pcm_runtime *runtime)
    481. 

  481. {
    482. 

  482. 	kfree(runtime->private_data);
    483. 

  483. }
    484. 

  484. 

  485. static const int spi_dacd_reg[] = {
    486. 

  486. 	[PCM_FRONT_CHANNEL]	= SPI_DACD4_REG,
    487. 

  487. 	[PCM_REAR_CHANNEL]	= SPI_DACD0_REG,
    488. 

  488. 	[PCM_CENTER_LFE_CHANNEL]= SPI_DACD2_REG,
    489. 

  489. 	[PCM_UNKNOWN_CHANNEL]	= SPI_DACD1_REG,
    490. 

  490. };
    491. 

  491. static const int spi_dacd_bit[] = {
    492. 

  492. 	[PCM_FRONT_CHANNEL]	= SPI_DACD4_BIT,
    493. 

  493. 	[PCM_REAR_CHANNEL]	= SPI_DACD0_BIT,
    494. 

  494. 	[PCM_CENTER_LFE_CHANNEL]= SPI_DACD2_BIT,
    495. 

  495. 	[PCM_UNKNOWN_CHANNEL]	= SPI_DACD1_BIT,
    496. 

  496. };
    497. 

  497. 

  498. static void restore_spdif_bits(struct snd_ca0106 *chip, int idx)
    499. 

  499. {
    500. 

  500. 	if (chip->spdif_str_bits[idx] != chip->spdif_bits[idx]) {
    501. 

  501. 		chip->spdif_str_bits[idx] = chip->spdif_bits[idx];
    502. 

  502. 		snd_ca0106_ptr_write(chip, SPCS0 + idx, 0,
    503. 

  503. 				     chip->spdif_str_bits[idx]);
    504. 

  504. 	}
    505. 

  505. }
    506. 

  506. 

  507. /* open_playback callback */
    508. 

  508. static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream,
    509. 

  509. 						int channel_id)
    510. 

  510. {
    511. 

  511. 	struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
    512. 

  512.         struct snd_ca0106_channel *channel = &(chip->playback_channels[channel_id]);
    513. 

  513. 	struct snd_ca0106_pcm *epcm;
    514. 

  514. 	struct snd_pcm_runtime *runtime = substream->runtime;
    515. 

  515. 	int err;
    516. 

  516. 

  517. 	epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
    518. 

  518. 

  519. 	if (epcm == NULL)
    520. 

  520. 		return -ENOMEM;
    521. 

  521. 	epcm->emu = chip;
    522. 

  522. 	epcm->substream = substream;
    523. 

  523.         epcm->channel_id=channel_id;
    524. 

  524.   
    525. 

  525. 	runtime->private_data = epcm;
    526. 

  526. 	runtime->private_free = snd_ca0106_pcm_free_substream;
    527. 

  527.   
    528. 

  528. 	runtime->hw = snd_ca0106_playback_hw;
    529. 

  529. 

  530.         channel->emu = chip;
    531. 

  531.         channel->number = channel_id;
    532. 

  532. 

  533. 	channel->use = 1;
    534. 

  534. 	/*
    535. 

  535. 	printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
    536. 

  536. 	       channel_id, chip, channel);
    537. 

  537. 	*/
    538. 

  538.         //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
    539. 

  539. 	channel->epcm = epcm;
    540. 

  540. 	if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
    541. 

  541.                 return err;
    542. 

  542. 	if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0)
    543. 

  543.                 return err;
    544. 

  544. 	snd_pcm_set_sync(substream);
    545. 

  545. 

  546. 	if (chip->details->spi_dac && channel_id != PCM_FRONT_CHANNEL) {
    547. 

  547. 		const int reg = spi_dacd_reg[channel_id];
    548. 

  548. 

  549. 		/* Power up dac */
    550. 

  550. 		chip->spi_dac_reg[reg] &= ~spi_dacd_bit[channel_id];
    551. 

  551. 		err = snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]);
    552. 

  552. 		if (err < 0)
    553. 

  553. 			return err;
    554. 

  554. 	}
    555. 

  555. 

  556. 	restore_spdif_bits(chip, channel_id);
    557. 

  557. 

  558. 	return 0;
    559. 

  559. }
    560. 

  560. 

  561. /* close callback */
    562. 

  562. static int snd_ca0106_pcm_close_playback(struct snd_pcm_substream *substream)
    563. 

  563. {
    564. 

  564. 	struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
    565. 

  565. 	struct snd_pcm_runtime *runtime = substream->runtime;
    566. 

  566.         struct snd_ca0106_pcm *epcm = runtime->private_data;
    567. 

  567. 	chip->playback_channels[epcm->channel_id].use = 0;
    568. 

  568. 

  569. 	restore_spdif_bits(chip, epcm->channel_id);
    570. 

  570. 

  571. 	if (chip->details->spi_dac && epcm->channel_id != PCM_FRONT_CHANNEL) {
    572. 

  572. 		const int reg = spi_dacd_reg[epcm->channel_id];
    573. 

  573. 

  574. 		/* Power down DAC */
    575. 

  575. 		chip->spi_dac_reg[reg] |= spi_dacd_bit[epcm->channel_id];
    576. 

  576. 		snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]);
    577. 

  577. 	}
    578. 

  578. 	/* FIXME: maybe zero others */
    579. 

  579. 	return 0;
    580. 

  580. }
    581. 

  581. 

  582. static int snd_ca0106_pcm_open_playback_front(struct snd_pcm_substream *substream)
    583. 

  583. {
    584. 

  584. 	return snd_ca0106_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL);
    585. 

  585. }
    586. 

  586. 

  587. static int snd_ca0106_pcm_open_playback_center_lfe(struct snd_pcm_substream *substream)
    588. 

  588. {
    589. 

  589. 	return snd_ca0106_pcm_open_playback_channel(substream, PCM_CENTER_LFE_CHANNEL);
    590. 

  590. }
    591. 

  591. 

  592. static int snd_ca0106_pcm_open_playback_unknown(struct snd_pcm_substream *substream)
    593. 

  593. {
    594. 

  594. 	return snd_ca0106_pcm_open_playback_channel(substream, PCM_UNKNOWN_CHANNEL);
    595. 

  595. }
    596. 

  596. 

  597. static int snd_ca0106_pcm_open_playback_rear(struct snd_pcm_substream *substream)
    598. 

  598. {
    599. 

  599. 	return snd_ca0106_pcm_open_playback_channel(substream, PCM_REAR_CHANNEL);
    600. 

  600. }
    601. 

  601. 

  602. /* open_capture callback */
    603. 

  603. static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substream,
    604. 

  604. 					       int channel_id)
    605. 

  605. {
    606. 

  606. 	struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
    607. 

  607.         struct snd_ca0106_channel *channel = &(chip->capture_channels[channel_id]);
    608. 

  608. 	struct snd_ca0106_pcm *epcm;
    609. 

  609. 	struct snd_pcm_runtime *runtime = substream->runtime;
    610. 

  610. 	int err;
    611. 

  611. 

  612. 	epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
    613. 

  613. 	if (epcm == NULL) {
    614. 

  614. 		snd_printk(KERN_ERR "open_capture_channel: failed epcm alloc\n");
    615. 

  615. 		return -ENOMEM;
    616. 

  616.         }
    617. 

  617. 	epcm->emu = chip;
    618. 

  618. 	epcm->substream = substream;
    619. 

  619.         epcm->channel_id=channel_id;
    620. 

  620.   
    621. 

  621. 	runtime->private_data = epcm;
    622. 

  622. 	runtime->private_free = snd_ca0106_pcm_free_substream;
    623. 

  623.   
    624. 

  624. 	runtime->hw = snd_ca0106_capture_hw;
    625. 

  625. 

  626.         channel->emu = chip;
    627. 

  627.         channel->number = channel_id;
    628. 

  628. 

  629. 	channel->use = 1;
    630. 

  630. 	/*
    631. 

  631.         printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
    632. 

  632. 	       channel_id, chip, channel);
    633. 

  633. 	*/
    634. 

  634.         //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
    635. 

  635.         channel->epcm = epcm;
    636. 

  636. 	if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
    637. 

  637.                 return err;
    638. 

  638. 	//snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hw_constraints_capture_period_sizes);
    639. 

  639. 	if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0)
    640. 

  640.                 return err;
    641. 

  641. 	return 0;
    642. 

  642. }
    643. 

  643. 

  644. /* close callback */
    645. 

  645. static int snd_ca0106_pcm_close_capture(struct snd_pcm_substream *substream)
    646. 

  646. {
    647. 

  647. 	struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
    648. 

  648. 	struct snd_pcm_runtime *runtime = substream->runtime;
    649. 

  649.         struct snd_ca0106_pcm *epcm = runtime->private_data;
    650. 

  650. 	chip->capture_channels[epcm->channel_id].use = 0;
    651. 

  651. 	/* FIXME: maybe zero others */
    652. 

  652. 	return 0;
    653. 

  653. }
    654. 

  654. 

  655. static int snd_ca0106_pcm_open_0_capture(struct snd_pcm_substream *substream)
    656. 

  656. {
    657. 

  657. 	return snd_ca0106_pcm_open_capture_channel(substream, 0);
    658. 

  658. }
    659. 

  659. 

  660. static int snd_ca0106_pcm_open_1_capture(struct snd_pcm_substream *substream)
    661. 

  661. {
    662. 

  662. 	return snd_ca0106_pcm_open_capture_channel(substream, 1);
    663. 

  663. }
    664. 

  664. 

  665. static int snd_ca0106_pcm_open_2_capture(struct snd_pcm_substream *substream)
    666. 

  666. {
    667. 

  667. 	return snd_ca0106_pcm_open_capture_channel(substream, 2);
    668. 

  668. }
    669. 

  669. 

  670. static int snd_ca0106_pcm_open_3_capture(struct snd_pcm_substream *substream)
    671. 

  671. {
    672. 

  672. 	return snd_ca0106_pcm_open_capture_channel(substream, 3);
    673. 

  673. }
    674. 

  674. 

  675. /* hw_params callback */
    676. 

  676. static int snd_ca0106_pcm_hw_params_playback(struct snd_pcm_substream *substream,
    677. 

  677. 				      struct snd_pcm_hw_params *hw_params)
    678. 

  678. {
    679. 

  679. 	return snd_pcm_lib_malloc_pages(substream,
    680. 

  680. 					params_buffer_bytes(hw_params));
    681. 

  681. }
    682. 

  682. 

  683. /* hw_free callback */
    684. 

  684. static int snd_ca0106_pcm_hw_free_playback(struct snd_pcm_substream *substream)
    685. 

  685. {
    686. 

  686. 	return snd_pcm_lib_free_pages(substream);
    687. 

  687. }
    688. 

  688. 

  689. /* hw_params callback */
    690. 

  690. static int snd_ca0106_pcm_hw_params_capture(struct snd_pcm_substream *substream,
    691. 

  691. 				      struct snd_pcm_hw_params *hw_params)
    692. 

  692. {
    693. 

  693. 	return snd_pcm_lib_malloc_pages(substream,
    694. 

  694. 					params_buffer_bytes(hw_params));
    695. 

  695. }
    696. 

  696. 

  697. /* hw_free callback */
    698. 

  698. static int snd_ca0106_pcm_hw_free_capture(struct snd_pcm_substream *substream)
    699. 

  699. {
    700. 

  700. 	return snd_pcm_lib_free_pages(substream);
    701. 

  701. }
    702. 

  702. 

  703. /* prepare playback callback */
    704. 

  704. static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream)
    705. 

  705. {
    706. 

  706. 	struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
    707. 

  707. 	struct snd_pcm_runtime *runtime = substream->runtime;
    708. 

  708. 	struct snd_ca0106_pcm *epcm = runtime->private_data;
    709. 

  709. 	int channel = epcm->channel_id;
    710. 

  710. 	u32 *table_base = (u32 *)(emu->buffer.area+(8*16*channel));
    711. 

  711. 	u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
    712. 

  712. 	u32 hcfg_mask = HCFG_PLAYBACK_S32_LE;
    713. 

  713. 	u32 hcfg_set = 0x00000000;
    714. 

  714. 	u32 hcfg;
    715. 

  715. 	u32 reg40_mask = 0x30000 << (channel<<1);
    716. 

  716. 	u32 reg40_set = 0;
    717. 

  717. 	u32 reg40;
    718. 

  718. 	/* FIXME: Depending on mixer selection of SPDIF out or not, select the spdif rate or the DAC rate. */
    719. 

  719. 	u32 reg71_mask = 0x03030000 ; /* Global. Set SPDIF rate. We only support 44100 to spdif, not to DAC. */
    720. 

  720. 	u32 reg71_set = 0;
    721. 

  721. 	u32 reg71;
    722. 

  722. 	int i;
    723. 

  723. 	
    724. 

  724. #if 0 /* debug */
    725. 

  725. 	snd_printk(KERN_DEBUG
    726. 

  726. 		   "prepare:channel_number=%d, rate=%d, format=0x%x, "
    727. 

  727. 		   "channels=%d, buffer_size=%ld, period_size=%ld, "
    728. 

  728. 		   "periods=%u, frames_to_bytes=%d\n",
    729. 

  729. 		   channel, runtime->rate, runtime->format,
    730. 

  730. 		   runtime->channels, runtime->buffer_size,
    731. 

  731. 		   runtime->period_size, runtime->periods,
    732. 

  732. 		   frames_to_bytes(runtime, 1));
    733. 

  733. 	snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
    734. 

  734. 		   runtime->dma_addr, runtime->dma_area, table_base);
    735. 

  735. 	snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
    736. 

  736. 		   emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
    737. 

  737. #endif /* debug */
    738. 

  738. 	/* Rate can be set per channel. */
    739. 

  739. 	/* reg40 control host to fifo */
    740. 

  740. 	/* reg71 controls DAC rate. */
    741. 

  741. 	switch (runtime->rate) {
    742. 

  742. 	case 44100:
    743. 

  743. 		reg40_set = 0x10000 << (channel<<1);
    744. 

  744. 		reg71_set = 0x01010000; 
    745. 

  745. 		break;
    746. 

  746.         case 48000:
    747. 

  747. 		reg40_set = 0;
    748. 

  748. 		reg71_set = 0; 
    749. 

  749. 		break;
    750. 

  750. 	case 96000:
    751. 

  751. 		reg40_set = 0x20000 << (channel<<1);
    752. 

  752. 		reg71_set = 0x02020000; 
    753. 

  753. 		break;
    754. 

  754. 	case 192000:
    755. 

  755. 		reg40_set = 0x30000 << (channel<<1);
    756. 

  756. 		reg71_set = 0x03030000; 
    757. 

  757. 		break;
    758. 

  758. 	default:
    759. 

  759. 		reg40_set = 0;
    760. 

  760. 		reg71_set = 0; 
    761. 

  761. 		break;
    762. 

  762. 	}
    763. 

  763. 	/* Format is a global setting */
    764. 

  764. 	/* FIXME: Only let the first channel accessed set this. */
    765. 

  765. 	switch (runtime->format) {
    766. 

  766. 	case SNDRV_PCM_FORMAT_S16_LE:
    767. 

  767. 		hcfg_set = 0;
    768. 

  768. 		break;
    769. 

  769. 	case SNDRV_PCM_FORMAT_S32_LE:
    770. 

  770. 		hcfg_set = HCFG_PLAYBACK_S32_LE;
    771. 

  771. 		break;
    772. 

  772. 	default:
    773. 

  773. 		hcfg_set = 0;
    774. 

  774. 		break;
    775. 

  775. 	}
    776. 

  776. 	hcfg = inl(emu->port + HCFG) ;
    777. 

  777. 	hcfg = (hcfg & ~hcfg_mask) | hcfg_set;
    778. 

  778. 	outl(hcfg, emu->port + HCFG);
    779. 

  779. 	reg40 = snd_ca0106_ptr_read(emu, 0x40, 0);
    780. 

  780. 	reg40 = (reg40 & ~reg40_mask) | reg40_set;
    781. 

  781. 	snd_ca0106_ptr_write(emu, 0x40, 0, reg40);
    782. 

  782. 	reg71 = snd_ca0106_ptr_read(emu, 0x71, 0);
    783. 

  783. 	reg71 = (reg71 & ~reg71_mask) | reg71_set;
    784. 

  784. 	snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
    785. 

  785. 

  786. 	/* FIXME: Check emu->buffer.size before actually writing to it. */
    787. 

  787.         for(i=0; i < runtime->periods; i++) {
    788. 

  788. 		table_base[i*2] = runtime->dma_addr + (i * period_size_bytes);
    789. 

  789. 		table_base[i*2+1] = period_size_bytes << 16;
    790. 

  790. 	}
    791. 

  791.  
    792. 

  792. 	snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer.addr+(8*16*channel));
    793. 

  793. 	snd_ca0106_ptr_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
    794. 

  794. 	snd_ca0106_ptr_write(emu, PLAYBACK_LIST_PTR, channel, 0);
    795. 

  795. 	snd_ca0106_ptr_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr);
    796. 

  796. 	snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16); // buffer size in bytes
    797. 

  797. 	/* FIXME  test what 0 bytes does. */
    798. 

  798. 	snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, 0); // buffer size in bytes
    799. 

  799. 	snd_ca0106_ptr_write(emu, PLAYBACK_POINTER, channel, 0);
    800. 

  800. 	snd_ca0106_ptr_write(emu, 0x07, channel, 0x0);
    801. 

  801. 	snd_ca0106_ptr_write(emu, 0x08, channel, 0);
    802. 

  802.         snd_ca0106_ptr_write(emu, PLAYBACK_MUTE, 0x0, 0x0); /* Unmute output */
    803. 

  803. #if 0
    804. 

  804. 	snd_ca0106_ptr_write(emu, SPCS0, 0,
    805. 

  805. 			       SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
    806. 

  806. 			       SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
    807. 

  807. 			       SPCS_GENERATIONSTATUS | 0x00001200 |
    808. 

  808. 			       0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT );
    809. 

  809. #endif
    810. 

  810. 

  811. 	return 0;
    812. 

  812. }
    813. 

  813. 

  814. /* prepare capture callback */
    815. 

  815. static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
    816. 

  816. {
    817. 

  817. 	struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
    818. 

  818. 	struct snd_pcm_runtime *runtime = substream->runtime;
    819. 

  819. 	struct snd_ca0106_pcm *epcm = runtime->private_data;
    820. 

  820. 	int channel = epcm->channel_id;
    821. 

  821. 	u32 hcfg_mask = HCFG_CAPTURE_S32_LE;
    822. 

  822. 	u32 hcfg_set = 0x00000000;
    823. 

  823. 	u32 hcfg;
    824. 

  824. 	u32 over_sampling=0x2;
    825. 

  825. 	u32 reg71_mask = 0x0000c000 ; /* Global. Set ADC rate. */
    826. 

  826. 	u32 reg71_set = 0;
    827. 

  827. 	u32 reg71;
    828. 

  828. 	
    829. 

  829. #if 0 /* debug */
    830. 

  830. 	snd_printk(KERN_DEBUG
    831. 

  831. 		   "prepare:channel_number=%d, rate=%d, format=0x%x, "
    832. 

  832. 		   "channels=%d, buffer_size=%ld, period_size=%ld, "
    833. 

  833. 		   "periods=%u, frames_to_bytes=%d\n",
    834. 

  834. 		   channel, runtime->rate, runtime->format,
    835. 

  835. 		   runtime->channels, runtime->buffer_size,
    836. 

  836. 		   runtime->period_size, runtime->periods,
    837. 

  837. 		   frames_to_bytes(runtime, 1));
    838. 

  838.         snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
    839. 

  839. 		   runtime->dma_addr, runtime->dma_area, table_base);
    840. 

  840. 	snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
    841. 

  841. 		   emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
    842. 

  842. #endif /* debug */
    843. 

  843. 	/* reg71 controls ADC rate. */
    844. 

  844. 	switch (runtime->rate) {
    845. 

  845. 	case 44100:
    846. 

  846. 		reg71_set = 0x00004000;
    847. 

  847. 		break;
    848. 

  848.         case 48000:
    849. 

  849. 		reg71_set = 0; 
    850. 

  850. 		break;
    851. 

  851. 	case 96000:
    852. 

  852. 		reg71_set = 0x00008000;
    853. 

  853. 		over_sampling=0xa;
    854. 

  854. 		break;
    855. 

  855. 	case 192000:
    856. 

  856. 		reg71_set = 0x0000c000; 
    857. 

  857. 		over_sampling=0xa;
    858. 

  858. 		break;
    859. 

  859. 	default:
    860. 

  860. 		reg71_set = 0; 
    861. 

  861. 		break;
    862. 

  862. 	}
    863. 

  863. 	/* Format is a global setting */
    864. 

  864. 	/* FIXME: Only let the first channel accessed set this. */
    865. 

  865. 	switch (runtime->format) {
    866. 

  866. 	case SNDRV_PCM_FORMAT_S16_LE:
    867. 

  867. 		hcfg_set = 0;
    868. 

  868. 		break;
    869. 

  869. 	case SNDRV_PCM_FORMAT_S32_LE:
    870. 

  870. 		hcfg_set = HCFG_CAPTURE_S32_LE;
    871. 

  871. 		break;
    872. 

  872. 	default:
    873. 

  873. 		hcfg_set = 0;
    874. 

  874. 		break;
    875. 

  875. 	}
    876. 

  876. 	hcfg = inl(emu->port + HCFG) ;
    877. 

  877. 	hcfg = (hcfg & ~hcfg_mask) | hcfg_set;
    878. 

  878. 	outl(hcfg, emu->port + HCFG);
    879. 

  879. 	reg71 = snd_ca0106_ptr_read(emu, 0x71, 0);
    880. 

  880. 	reg71 = (reg71 & ~reg71_mask) | reg71_set;
    881. 

  881. 	snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
    882. 

  882.         if (emu->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */
    883. 

  883. 	        snd_ca0106_i2c_write(emu, ADC_MASTER, over_sampling); /* Adjust the over sampler to better suit the capture rate. */
    884. 

  884. 	}
    885. 

  885. 

  886. 

  887. 	/*
    888. 

  888. 	printk(KERN_DEBUG
    889. 

  889. 	       "prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, "
    890. 

  890. 	       "buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",
    891. 

  891. 	       channel, runtime->rate, runtime->format, runtime->channels,
    892. 

  892. 	       runtime->buffer_size, runtime->period_size,
    893. 

  893. 	       frames_to_bytes(runtime, 1));
    894. 

  894. 	*/
    895. 

  895. 	snd_ca0106_ptr_write(emu, 0x13, channel, 0);
    896. 

  896. 	snd_ca0106_ptr_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr);
    897. 

  897. 	snd_ca0106_ptr_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size)<<16); // buffer size in bytes
    898. 

  898. 	snd_ca0106_ptr_write(emu, CAPTURE_POINTER, channel, 0);
    899. 

  899. 

  900. 	return 0;
    901. 

  901. }
    902. 

  902. 

  903. /* trigger_playback callback */
    904. 

  904. static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream,
    905. 

  905. 				    int cmd)
    906. 

  906. {
    907. 

  907. 	struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
    908. 

  908. 	struct snd_pcm_runtime *runtime;
    909. 

  909. 	struct snd_ca0106_pcm *epcm;
    910. 

  910. 	int channel;
    911. 

  911. 	int result = 0;
    912. 

  912.         struct snd_pcm_substream *s;
    913. 

  913. 	u32 basic = 0;
    914. 

  914. 	u32 extended = 0;
    915. 

  915. 	u32 bits;
    916. 

  916. 	int running = 0;
    917. 

  917. 

  918. 	switch (cmd) {
    919. 

  919. 	case SNDRV_PCM_TRIGGER_START:
    920. 

  920. 	case SNDRV_PCM_TRIGGER_RESUME:
    921. 

  921. 		running = 1;
    922. 

  922. 		break;
    923. 

  923. 	case SNDRV_PCM_TRIGGER_STOP:
    924. 

  924. 	case SNDRV_PCM_TRIGGER_SUSPEND:
    925. 

  925. 	default:
    926. 

  926. 		running = 0;
    927. 

  927. 		break;
    928. 

  928. 	}
    929. 

  929.         snd_pcm_group_for_each_entry(s, substream) {
    930. 

  930. 		if (snd_pcm_substream_chip(s) != emu ||
    931. 

  931. 		    s->stream != SNDRV_PCM_STREAM_PLAYBACK)
    932. 

  932. 			continue;
    933. 

  933. 		runtime = s->runtime;
    934. 

  934. 		epcm = runtime->private_data;
    935. 

  935. 		channel = epcm->channel_id;
    936. 

  936. 		/* snd_printk(KERN_DEBUG "channel=%d\n", channel); */
    937. 

  937. 		epcm->running = running;
    938. 

  938. 		basic |= (0x1 << channel);
    939. 

  939. 		extended |= (0x10 << channel);
    940. 

  940.                 snd_pcm_trigger_done(s, substream);
    941. 

  941.         }
    942. 

  942. 	/* snd_printk(KERN_DEBUG "basic=0x%x, extended=0x%x\n",basic, extended); */
    943. 

  943. 

  944. 	switch (cmd) {
    945. 

  945. 	case SNDRV_PCM_TRIGGER_START:
    946. 

  946. 	case SNDRV_PCM_TRIGGER_RESUME:
    947. 

  947. 		bits = snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0);
    948. 

  948. 		bits |= extended;
    949. 

  949. 		snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, bits);
    950. 

  950. 		bits = snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0);
    951. 

  951. 		bits |= basic;
    952. 

  952. 		snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, bits);
    953. 

  953. 		break;
    954. 

  954. 	case SNDRV_PCM_TRIGGER_STOP:
    955. 

  955. 	case SNDRV_PCM_TRIGGER_SUSPEND:
    956. 

  956. 		bits = snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0);
    957. 

  957. 		bits &= ~basic;
    958. 

  958. 		snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, bits);
    959. 

  959. 		bits = snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0);
    960. 

  960. 		bits &= ~extended;
    961. 

  961. 		snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, bits);
    962. 

  962. 		break;
    963. 

  963. 	default:
    964. 

  964. 		result = -EINVAL;
    965. 

  965. 		break;
    966. 

  966. 	}
    967. 

  967. 	return result;
    968. 

  968. }
    969. 

  969. 

  970. /* trigger_capture callback */
    971. 

  971. static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream,
    972. 

  972. 				    int cmd)
    973. 

  973. {
    974. 

  974. 	struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
    975. 

  975. 	struct snd_pcm_runtime *runtime = substream->runtime;
    976. 

  976. 	struct snd_ca0106_pcm *epcm = runtime->private_data;
    977. 

  977. 	int channel = epcm->channel_id;
    978. 

  978. 	int result = 0;
    979. 

  979. 

  980. 	switch (cmd) {
    981. 

  981. 	case SNDRV_PCM_TRIGGER_START:
    982. 

  982. 		snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
    983. 

  983. 		snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel));
    984. 

  984. 		epcm->running = 1;
    985. 

  985. 		break;
    986. 

  986. 	case SNDRV_PCM_TRIGGER_STOP:
    987. 

  987. 		snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel));
    988. 

  988. 		snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
    989. 

  989. 		epcm->running = 0;
    990. 

  990. 		break;
    991. 

  991. 	default:
    992. 

  992. 		result = -EINVAL;
    993. 

  993. 		break;
    994. 

  994. 	}
    995. 

  995. 	return result;
    996. 

  996. }
    997. 

  997. 

  998. /* pointer_playback callback */
    999. 

  999. static snd_pcm_uframes_t
    1000. 

  1000. snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
    1001. 

  1001. {
    1002. 

  1002. 	struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
    1003. 

  1003. 	struct snd_pcm_runtime *runtime = substream->runtime;
    1004. 

  1004. 	struct snd_ca0106_pcm *epcm = runtime->private_data;
    1005. 

  1005. 	snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0;
    1006. 

  1006. 	int channel = epcm->channel_id;
    1007. 

  1007. 

  1008. 	if (!epcm->running)
    1009. 

  1009. 		return 0;
    1010. 

  1010. 

  1011. 	ptr3 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
    1012. 

  1012. 	ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
    1013. 

  1013. 	ptr4 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
    1014. 

  1014. 	if (ptr3 != ptr4) ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
    1015. 

  1015. 	ptr2 = bytes_to_frames(runtime, ptr1);
    1016. 

  1016. 	ptr2+= (ptr4 >> 3) * runtime->period_size;
    1017. 

  1017. 	ptr=ptr2;
    1018. 

  1018.         if (ptr >= runtime->buffer_size)
    1019. 

  1019. 		ptr -= runtime->buffer_size;
    1020. 

  1020. 	/*
    1021. 

  1021. 	printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
    1022. 

  1022. 	       "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
    1023. 

  1023. 	       ptr1, ptr2, ptr, (int)runtime->buffer_size,
    1024. 

  1024. 	       (int)runtime->period_size, (int)runtime->frame_bits,
    1025. 

  1025. 	       (int)runtime->rate);
    1026. 

  1026. 	*/
    1027. 

  1027. 	return ptr;
    1028. 

  1028. }
    1029. 

  1029. 

  1030. /* pointer_capture callback */
    1031. 

  1031. static snd_pcm_uframes_t
    1032. 

  1032. snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream)
    1033. 

  1033. {
    1034. 

  1034. 	struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
    1035. 

  1035. 	struct snd_pcm_runtime *runtime = substream->runtime;
    1036. 

  1036. 	struct snd_ca0106_pcm *epcm = runtime->private_data;
    1037. 

  1037. 	snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
    1038. 

  1038. 	int channel = channel=epcm->channel_id;
    1039. 

  1039. 

  1040. 	if (!epcm->running)
    1041. 

  1041. 		return 0;
    1042. 

  1042. 

  1043. 	ptr1 = snd_ca0106_ptr_read(emu, CAPTURE_POINTER, channel);
    1044. 

  1044. 	ptr2 = bytes_to_frames(runtime, ptr1);
    1045. 

  1045. 	ptr=ptr2;
    1046. 

  1046.         if (ptr >= runtime->buffer_size)
    1047. 

  1047. 		ptr -= runtime->buffer_size;
    1048. 

  1048. 	/*
    1049. 

  1049. 	printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
    1050. 

  1050. 	       "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
    1051. 

  1051. 	       ptr1, ptr2, ptr, (int)runtime->buffer_size,
    1052. 

  1052. 	       (int)runtime->period_size, (int)runtime->frame_bits,
    1053. 

  1053. 	       (int)runtime->rate);
    1054. 

  1054. 	*/
    1055. 

  1055. 	return ptr;
    1056. 

  1056. }
    1057. 

  1057. 

  1058. /* operators */
    1059. 

  1059. static struct snd_pcm_ops snd_ca0106_playback_front_ops = {
    1060. 

  1060. 	.open =        snd_ca0106_pcm_open_playback_front,
    1061. 

  1061. 	.close =       snd_ca0106_pcm_close_playback,
    1062. 

  1062. 	.ioctl =       snd_pcm_lib_ioctl,
    1063. 

  1063. 	.hw_params =   snd_ca0106_pcm_hw_params_playback,
    1064. 

  1064. 	.hw_free =     snd_ca0106_pcm_hw_free_playback,
    1065. 

  1065. 	.prepare =     snd_ca0106_pcm_prepare_playback,
    1066. 

  1066. 	.trigger =     snd_ca0106_pcm_trigger_playback,
    1067. 

  1067. 	.pointer =     snd_ca0106_pcm_pointer_playback,
    1068. 

  1068. };
    1069. 

  1069. 

  1070. static struct snd_pcm_ops snd_ca0106_capture_0_ops = {
    1071. 

  1071. 	.open =        snd_ca0106_pcm_open_0_capture,
    1072. 

  1072. 	.close =       snd_ca0106_pcm_close_capture,
    1073. 

  1073. 	.ioctl =       snd_pcm_lib_ioctl,
    1074. 

  1074. 	.hw_params =   snd_ca0106_pcm_hw_params_capture,
    1075. 

  1075. 	.hw_free =     snd_ca0106_pcm_hw_free_capture,
    1076. 

  1076. 	.prepare =     snd_ca0106_pcm_prepare_capture,
    1077. 

  1077. 	.trigger =     snd_ca0106_pcm_trigger_capture,
    1078. 

  1078. 	.pointer =     snd_ca0106_pcm_pointer_capture,
    1079. 

  1079. };
    1080. 

  1080. 

  1081. static struct snd_pcm_ops snd_ca0106_capture_1_ops = {
    1082. 

  1082. 	.open =        snd_ca0106_pcm_open_1_capture,
    1083. 

  1083. 	.close =       snd_ca0106_pcm_close_capture,
    1084. 

  1084. 	.ioctl =       snd_pcm_lib_ioctl,
    1085. 

  1085. 	.hw_params =   snd_ca0106_pcm_hw_params_capture,
    1086. 

  1086. 	.hw_free =     snd_ca0106_pcm_hw_free_capture,
    1087. 

  1087. 	.prepare =     snd_ca0106_pcm_prepare_capture,
    1088. 

  1088. 	.trigger =     snd_ca0106_pcm_trigger_capture,
    1089. 

  1089. 	.pointer =     snd_ca0106_pcm_pointer_capture,
    1090. 

  1090. };
    1091. 

  1091. 

  1092. static struct snd_pcm_ops snd_ca0106_capture_2_ops = {
    1093. 

  1093. 	.open =        snd_ca0106_pcm_open_2_capture,
    1094. 

  1094. 	.close =       snd_ca0106_pcm_close_capture,
    1095. 

  1095. 	.ioctl =       snd_pcm_lib_ioctl,
    1096. 

  1096. 	.hw_params =   snd_ca0106_pcm_hw_params_capture,
    1097. 

  1097. 	.hw_free =     snd_ca0106_pcm_hw_free_capture,
    1098. 

  1098. 	.prepare =     snd_ca0106_pcm_prepare_capture,
    1099. 

  1099. 	.trigger =     snd_ca0106_pcm_trigger_capture,
    1100. 

  1100. 	.pointer =     snd_ca0106_pcm_pointer_capture,
    1101. 

  1101. };
    1102. 

  1102. 

  1103. static struct snd_pcm_ops snd_ca0106_capture_3_ops = {
    1104. 

  1104. 	.open =        snd_ca0106_pcm_open_3_capture,
    1105. 

  1105. 	.close =       snd_ca0106_pcm_close_capture,
    1106. 

  1106. 	.ioctl =       snd_pcm_lib_ioctl,
    1107. 

  1107. 	.hw_params =   snd_ca0106_pcm_hw_params_capture,
    1108. 

  1108. 	.hw_free =     snd_ca0106_pcm_hw_free_capture,
    1109. 

  1109. 	.prepare =     snd_ca0106_pcm_prepare_capture,
    1110. 

  1110. 	.trigger =     snd_ca0106_pcm_trigger_capture,
    1111. 

  1111. 	.pointer =     snd_ca0106_pcm_pointer_capture,
    1112. 

  1112. };
    1113. 

  1113. 

  1114. static struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = {
    1115. 

  1115.         .open =         snd_ca0106_pcm_open_playback_center_lfe,
    1116. 

  1116.         .close =        snd_ca0106_pcm_close_playback,
    1117. 

  1117.         .ioctl =        snd_pcm_lib_ioctl,
    1118. 

  1118.         .hw_params =    snd_ca0106_pcm_hw_params_playback,
    1119. 

  1119.         .hw_free =      snd_ca0106_pcm_hw_free_playback,
    1120. 

  1120.         .prepare =      snd_ca0106_pcm_prepare_playback,     
    1121. 

  1121.         .trigger =      snd_ca0106_pcm_trigger_playback,  
    1122. 

  1122.         .pointer =      snd_ca0106_pcm_pointer_playback, 
    1123. 

  1123. };
    1124. 

  1124. 

  1125. static struct snd_pcm_ops snd_ca0106_playback_unknown_ops = {
    1126. 

  1126.         .open =         snd_ca0106_pcm_open_playback_unknown,
    1127. 

  1127.         .close =        snd_ca0106_pcm_close_playback,
    1128. 

  1128.         .ioctl =        snd_pcm_lib_ioctl,
    1129. 

  1129.         .hw_params =    snd_ca0106_pcm_hw_params_playback,
    1130. 

  1130.         .hw_free =      snd_ca0106_pcm_hw_free_playback,
    1131. 

  1131.         .prepare =      snd_ca0106_pcm_prepare_playback,     
    1132. 

  1132.         .trigger =      snd_ca0106_pcm_trigger_playback,  
    1133. 

  1133.         .pointer =      snd_ca0106_pcm_pointer_playback, 
    1134. 

  1134. };
    1135. 

  1135. 

  1136. static struct snd_pcm_ops snd_ca0106_playback_rear_ops = {
    1137. 

  1137.         .open =         snd_ca0106_pcm_open_playback_rear,
    1138. 

  1138.         .close =        snd_ca0106_pcm_close_playback,
    1139. 

  1139.         .ioctl =        snd_pcm_lib_ioctl,
    1140. 

  1140.         .hw_params =    snd_ca0106_pcm_hw_params_playback,
    1141. 

  1141. 		.hw_free =      snd_ca0106_pcm_hw_free_playback,
    1142. 

  1142.         .prepare =      snd_ca0106_pcm_prepare_playback,     
    1143. 

  1143.         .trigger =      snd_ca0106_pcm_trigger_playback,  
    1144. 

  1144.         .pointer =      snd_ca0106_pcm_pointer_playback, 
    1145. 

  1145. };
    1146. 

  1146. 

  1147. 

  1148. static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97,
    1149. 

  1149. 					     unsigned short reg)
    1150. 

  1150. {
    1151. 

  1151. 	struct snd_ca0106 *emu = ac97->private_data;
    1152. 

  1152. 	unsigned long flags;
    1153. 

  1153. 	unsigned short val;
    1154. 

  1154. 

  1155. 	spin_lock_irqsave(&emu->emu_lock, flags);
    1156. 

  1156. 	outb(reg, emu->port + AC97ADDRESS);
    1157. 

  1157. 	val = inw(emu->port + AC97DATA);
    1158. 

  1158. 	spin_unlock_irqrestore(&emu->emu_lock, flags);
    1159. 

  1159. 	return val;
    1160. 

  1160. }
    1161. 

  1161. 

  1162. static void snd_ca0106_ac97_write(struct snd_ac97 *ac97,
    1163. 

  1163. 				    unsigned short reg, unsigned short val)
    1164. 

  1164. {
    1165. 

  1165. 	struct snd_ca0106 *emu = ac97->private_data;
    1166. 

  1166. 	unsigned long flags;
    1167. 

  1167.   
    1168. 

  1168. 	spin_lock_irqsave(&emu->emu_lock, flags);
    1169. 

  1169. 	outb(reg, emu->port + AC97ADDRESS);
    1170. 

  1170. 	outw(val, emu->port + AC97DATA);
    1171. 

  1171. 	spin_unlock_irqrestore(&emu->emu_lock, flags);
    1172. 

  1172. }
    1173. 

  1173. 

  1174. static int snd_ca0106_ac97(struct snd_ca0106 *chip)
    1175. 

  1175. {
    1176. 

  1176. 	struct snd_ac97_bus *pbus;
    1177. 

  1177. 	struct snd_ac97_template ac97;
    1178. 

  1178. 	int err;
    1179. 

  1179. 	static struct snd_ac97_bus_ops ops = {
    1180. 

  1180. 		.write = snd_ca0106_ac97_write,
    1181. 

  1181. 		.read = snd_ca0106_ac97_read,
    1182. 

  1182. 	};
    1183. 

  1183.   
    1184. 

  1184. 	if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
    1185. 

  1185. 		return err;
    1186. 

  1186. 	pbus->no_vra = 1; /* we don't need VRA */
    1187. 

  1187. 

  1188. 	memset(&ac97, 0, sizeof(ac97));
    1189. 

  1189. 	ac97.private_data = chip;
    1190. 

  1190. 	ac97.scaps = AC97_SCAP_NO_SPDIF;
    1191. 

  1191. 	return snd_ac97_mixer(pbus, &ac97, &chip->ac97);
    1192. 

  1192. }
    1193. 

  1193. 

  1194. static void ca0106_stop_chip(struct snd_ca0106 *chip);
    1195. 

  1195. 

  1196. static int snd_ca0106_free(struct snd_ca0106 *chip)
    1197. 

  1197. {
    1198. 

  1198. 	if (chip->res_port != NULL) {
    1199. 

  1199. 		/* avoid access to already used hardware */
    1200. 

  1200. 		ca0106_stop_chip(chip);
    1201. 

  1201. 	}
    1202. 

  1202. 	if (chip->irq >= 0)
    1203. 

  1203. 		free_irq(chip->irq, chip);
    1204. 

  1204. 	// release the data
    1205. 

  1205. #if 1
    1206. 

  1206. 	if (chip->buffer.area)
    1207. 

  1207. 		snd_dma_free_pages(&chip->buffer);
    1208. 

  1208. #endif
    1209. 

  1209. 

  1210. 	// release the i/o port
    1211. 

  1211. 	release_and_free_resource(chip->res_port);
    1212. 

  1212. 

  1213. 	pci_disable_device(chip->pci);
    1214. 

  1214. 	kfree(chip);
    1215. 

  1215. 	return 0;
    1216. 

  1216. }
    1217. 

  1217. 

  1218. static int snd_ca0106_dev_free(struct snd_device *device)
    1219. 

  1219. {
    1220. 

  1220. 	struct snd_ca0106 *chip = device->device_data;
    1221. 

  1221. 	return snd_ca0106_free(chip);
    1222. 

  1222. }
    1223. 

  1223. 

  1224. static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
    1225. 

  1225. {
    1226. 

  1226. 	unsigned int status;
    1227. 

  1227. 

  1228. 	struct snd_ca0106 *chip = dev_id;
    1229. 

  1229. 	int i;
    1230. 

  1230. 	int mask;
    1231. 

  1231.         unsigned int stat76;
    1232. 

  1232. 	struct snd_ca0106_channel *pchannel;
    1233. 

  1233. 

  1234. 	status = inl(chip->port + IPR);
    1235. 

  1235. 	if (! status)
    1236. 

  1236. 		return IRQ_NONE;
    1237. 

  1237. 

  1238.         stat76 = snd_ca0106_ptr_read(chip, EXTENDED_INT, 0);
    1239. 

  1239. 	/*
    1240. 

  1240. 	snd_printk(KERN_DEBUG "interrupt status = 0x%08x, stat76=0x%08x\n",
    1241. 

  1241. 		   status, stat76);
    1242. 

  1242. 	snd_printk(KERN_DEBUG "ptr=0x%08x\n",
    1243. 

  1243. 		   snd_ca0106_ptr_read(chip, PLAYBACK_POINTER, 0));
    1244. 

  1244. 	*/
    1245. 

  1245.         mask = 0x11; /* 0x1 for one half, 0x10 for the other half period. */
    1246. 

  1246. 	for(i = 0; i < 4; i++) {
    1247. 

  1247. 		pchannel = &(chip->playback_channels[i]);
    1248. 

  1248. 		if (stat76 & mask) {
    1249. 

  1249. /* FIXME: Select the correct substream for period elapsed */
    1250. 

  1250. 			if(pchannel->use) {
    1251. 

  1251. 				snd_pcm_period_elapsed(pchannel->epcm->substream);
    1252. 

  1252. 				//printk(KERN_INFO "interrupt [%d] used\n", i);
    1253. 

  1253.                         }
    1254. 

  1254. 		}
    1255. 

  1255. 	        //printk(KERN_INFO "channel=%p\n",pchannel);
    1256. 

  1256. 	        //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
    1257. 

  1257. 		mask <<= 1;
    1258. 

  1258. 	}
    1259. 

  1259.         mask = 0x110000; /* 0x1 for one half, 0x10 for the other half period. */
    1260. 

  1260. 	for(i = 0; i < 4; i++) {
    1261. 

  1261. 		pchannel = &(chip->capture_channels[i]);
    1262. 

  1262. 		if (stat76 & mask) {
    1263. 

  1263. /* FIXME: Select the correct substream for period elapsed */
    1264. 

  1264. 			if(pchannel->use) {
    1265. 

  1265. 				snd_pcm_period_elapsed(pchannel->epcm->substream);
    1266. 

  1266. 				//printk(KERN_INFO "interrupt [%d] used\n", i);
    1267. 

  1267.                         }
    1268. 

  1268. 		}
    1269. 

  1269. 	        //printk(KERN_INFO "channel=%p\n",pchannel);
    1270. 

  1270. 	        //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
    1271. 

  1271. 		mask <<= 1;
    1272. 

  1272. 	}
    1273. 

  1273. 

  1274.         snd_ca0106_ptr_write(chip, EXTENDED_INT, 0, stat76);
    1275. 

  1275. 

  1276. 	if (chip->midi.dev_id &&
    1277. 

  1277. 	    (status & (chip->midi.ipr_tx|chip->midi.ipr_rx))) {
    1278. 

  1278. 		if (chip->midi.interrupt)
    1279. 

  1279. 			chip->midi.interrupt(&chip->midi, status);
    1280. 

  1280. 		else
    1281. 

  1281. 			chip->midi.interrupt_disable(&chip->midi, chip->midi.tx_enable | chip->midi.rx_enable);
    1282. 

  1282. 	}
    1283. 

  1283. 

  1284. 	// acknowledge the interrupt if necessary
    1285. 

  1285. 	outl(status, chip->port+IPR);
    1286. 

  1286. 

  1287. 	return IRQ_HANDLED;
    1288. 

  1288. }
    1289. 

  1289. 

  1290. static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device)
    1291. 

  1291. {
    1292. 

  1292. 	struct snd_pcm *pcm;
    1293. 

  1293. 	struct snd_pcm_substream *substream;
    1294. 

  1294. 	int err;
    1295. 

  1295.   
    1296. 

  1296. 	err = snd_pcm_new(emu->card, "ca0106", device, 1, 1, &pcm);
    1297. 

  1297. 	if (err < 0)
    1298. 

  1298. 		return err;
    1299. 

  1299.   
    1300. 

  1300. 	pcm->private_data = emu;
    1301. 

  1301. 

  1302. 	switch (device) {
    1303. 

  1303. 	case 0:
    1304. 

  1304. 	  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_front_ops);
    1305. 

  1305. 	  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_0_ops);
    1306. 

  1306.           break;
    1307. 

  1307. 	case 1:
    1308. 

  1308. 	  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_rear_ops);
    1309. 

  1309. 	  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_1_ops);
    1310. 

  1310.           break;
    1311. 

  1311. 	case 2:
    1312. 

  1312. 	  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_center_lfe_ops);
    1313. 

  1313. 	  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_2_ops);
    1314. 

  1314.           break;
    1315. 

  1315. 	case 3:
    1316. 

  1316. 	  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_unknown_ops);
    1317. 

  1317. 	  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_3_ops);
    1318. 

  1318.           break;
    1319. 

  1319.         }
    1320. 

  1320. 

  1321. 	pcm->info_flags = 0;
    1322. 

  1322. 	strcpy(pcm->name, "CA0106");
    1323. 

  1323. 

  1324. 	for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; 
    1325. 

  1325. 	    substream; 
    1326. 

  1326. 	    substream = substream->next) {
    1327. 

  1327. 		if ((err = snd_pcm_lib_preallocate_pages(substream, 
    1328. 

  1328. 							 SNDRV_DMA_TYPE_DEV, 
    1329. 

  1329. 							 snd_dma_pci_data(emu->pci), 
    1330. 

  1330. 							 64*1024, 64*1024)) < 0) /* FIXME: 32*1024 for sound buffer, between 32and64 for Periods table. */
    1331. 

  1331. 			return err;
    1332. 

  1332. 	}
    1333. 

  1333. 

  1334. 	for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; 
    1335. 

  1335. 	      substream; 
    1336. 

  1336. 	      substream = substream->next) {
    1337. 

  1337.  		if ((err = snd_pcm_lib_preallocate_pages(substream, 
    1338. 

  1338. 	                                           SNDRV_DMA_TYPE_DEV, 
    1339. 

  1339. 	                                           snd_dma_pci_data(emu->pci), 
    1340. 

  1340. 	                                           64*1024, 64*1024)) < 0)
    1341. 

  1341. 			return err;
    1342. 

  1342. 	}
    1343. 

  1343.   
    1344. 

  1344. 	emu->pcm[device] = pcm;
    1345. 

  1345.   
    1346. 

  1346. 	return 0;
    1347. 

  1347. }
    1348. 

  1348. 

  1349. #define SPI_REG(reg, value)	(((reg) << SPI_REG_SHIFT) | (value))
    1350. 

  1350. static unsigned int spi_dac_init[] = {
    1351. 

  1351. 	SPI_REG(SPI_LDA1_REG,	SPI_DA_BIT_0dB), /* 0dB dig. attenuation */
    1352. 

  1352. 	SPI_REG(SPI_RDA1_REG,	SPI_DA_BIT_0dB),
    1353. 

  1353. 	SPI_REG(SPI_PL_REG,	SPI_PL_BIT_L_L | SPI_PL_BIT_R_R | SPI_IZD_BIT),
    1354. 

  1354. 	SPI_REG(SPI_FMT_REG,	SPI_FMT_BIT_I2S | SPI_IWL_BIT_24),
    1355. 

  1355. 	SPI_REG(SPI_LDA2_REG,	SPI_DA_BIT_0dB),
    1356. 

  1356. 	SPI_REG(SPI_RDA2_REG,	SPI_DA_BIT_0dB),
    1357. 

  1357. 	SPI_REG(SPI_LDA3_REG,	SPI_DA_BIT_0dB),
    1358. 

  1358. 	SPI_REG(SPI_RDA3_REG,	SPI_DA_BIT_0dB),
    1359. 

  1359. 	SPI_REG(SPI_MASTDA_REG,	SPI_DA_BIT_0dB),
    1360. 

  1360. 	SPI_REG(9,		0x00),
    1361. 

  1361. 	SPI_REG(SPI_MS_REG,	SPI_DACD0_BIT | SPI_DACD1_BIT | SPI_DACD2_BIT),
    1362. 

  1362. 	SPI_REG(12,		0x00),
    1363. 

  1363. 	SPI_REG(SPI_LDA4_REG,	SPI_DA_BIT_0dB),
    1364. 

  1364. 	SPI_REG(SPI_RDA4_REG,	SPI_DA_BIT_0dB | SPI_DA_BIT_UPDATE),
    1365. 

  1365. 	SPI_REG(SPI_DACD4_REG,	0x00),
    1366. 

  1366. };
    1367. 

  1367. 

  1368. static unsigned int i2c_adc_init[][2] = {
    1369. 

  1369. 	{ 0x17, 0x00 }, /* Reset */
    1370. 

  1370. 	{ 0x07, 0x00 }, /* Timeout */
    1371. 

  1371. 	{ 0x0b, 0x22 },  /* Interface control */
    1372. 

  1372. 	{ 0x0c, 0x22 },  /* Master mode control */
    1373. 

  1373. 	{ 0x0d, 0x08 },  /* Powerdown control */
    1374. 

  1374. 	{ 0x0e, 0xcf },  /* Attenuation Left  0x01 = -103dB, 0xff = 24dB */
    1375. 

  1375. 	{ 0x0f, 0xcf },  /* Attenuation Right 0.5dB steps */
    1376. 

  1376. 	{ 0x10, 0x7b },  /* ALC Control 1 */
    1377. 

  1377. 	{ 0x11, 0x00 },  /* ALC Control 2 */
    1378. 

  1378. 	{ 0x12, 0x32 },  /* ALC Control 3 */
    1379. 

  1379. 	{ 0x13, 0x00 },  /* Noise gate control */
    1380. 

  1380. 	{ 0x14, 0xa6 },  /* Limiter control */
    1381. 

  1381. 	{ 0x15, ADC_MUX_LINEIN },  /* ADC Mixer control */
    1382. 

  1382. };
    1383. 

  1383. 

  1384. static void ca0106_init_chip(struct snd_ca0106 *chip, int resume)
    1385. 

  1385. {
    1386. 

  1386. 	int ch;
    1387. 

  1387. 	unsigned int def_bits;
    1388. 

  1388. 

  1389. 	outl(0, chip->port + INTE);
    1390. 

  1390. 

  1391. 	/*
    1392. 

  1392. 	 *  Init to 0x02109204 :
    1393. 

  1393. 	 *  Clock accuracy    = 0     (1000ppm)
    1394. 

  1394. 	 *  Sample Rate       = 2     (48kHz)
    1395. 

  1395. 	 *  Audio Channel     = 1     (Left of 2)
    1396. 

  1396. 	 *  Source Number     = 0     (Unspecified)
    1397. 

  1397. 	 *  Generation Status = 1     (Original for Cat Code 12)
    1398. 

  1398. 	 *  Cat Code          = 12    (Digital Signal Mixer)
    1399. 

  1399. 	 *  Mode              = 0     (Mode 0)
    1400. 

  1400. 	 *  Emphasis          = 0     (None)
    1401. 

  1401. 	 *  CP                = 1     (Copyright unasserted)
    1402. 

  1402. 	 *  AN                = 0     (Audio data)
    1403. 

  1403. 	 *  P                 = 0     (Consumer)
    1404. 

  1404. 	 */
    1405. 

  1405. 	def_bits =
    1406. 

  1406. 		SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
    1407. 

  1407. 		SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
    1408. 

  1408. 		SPCS_GENERATIONSTATUS | 0x00001200 |
    1409. 

  1409. 		0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT;
    1410. 

  1410. 	if (!resume) {
    1411. 

  1411. 		chip->spdif_str_bits[0] = chip->spdif_bits[0] = def_bits;
    1412. 

  1412. 		chip->spdif_str_bits[1] = chip->spdif_bits[1] = def_bits;
    1413. 

  1413. 		chip->spdif_str_bits[2] = chip->spdif_bits[2] = def_bits;
    1414. 

  1414. 		chip->spdif_str_bits[3] = chip->spdif_bits[3] = def_bits;
    1415. 

  1415. 	}
    1416. 

  1416. 	/* Only SPCS1 has been tested */
    1417. 

  1417. 	snd_ca0106_ptr_write(chip, SPCS1, 0, chip->spdif_str_bits[1]);
    1418. 

  1418. 	snd_ca0106_ptr_write(chip, SPCS0, 0, chip->spdif_str_bits[0]);
    1419. 

  1419. 	snd_ca0106_ptr_write(chip, SPCS2, 0, chip->spdif_str_bits[2]);
    1420. 

  1420. 	snd_ca0106_ptr_write(chip, SPCS3, 0, chip->spdif_str_bits[3]);
    1421. 

  1421. 

  1422.         snd_ca0106_ptr_write(chip, PLAYBACK_MUTE, 0, 0x00fc0000);
    1423. 

  1423.         snd_ca0106_ptr_write(chip, CAPTURE_MUTE, 0, 0x00fc0000);
    1424. 

  1424. 

  1425.         /* Write 0x8000 to AC97_REC_GAIN to mute it. */
    1426. 

  1426.         outb(AC97_REC_GAIN, chip->port + AC97ADDRESS);
    1427. 

  1427.         outw(0x8000, chip->port + AC97DATA);
    1428. 

  1428. #if 0 /* FIXME: what are these? */
    1429. 

  1429. 	snd_ca0106_ptr_write(chip, SPCS0, 0, 0x2108006);
    1430. 

  1430. 	snd_ca0106_ptr_write(chip, 0x42, 0, 0x2108006);
    1431. 

  1431. 	snd_ca0106_ptr_write(chip, 0x43, 0, 0x2108006);
    1432. 

  1432. 	snd_ca0106_ptr_write(chip, 0x44, 0, 0x2108006);
    1433. 

  1433. #endif
    1434. 

  1434. 

  1435. 	/* OSS drivers set this. */
    1436. 

  1436. 	/* snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0xf0f003f); */
    1437. 

  1437. 

  1438. 	/* Analog or Digital output */
    1439. 

  1439. 	snd_ca0106_ptr_write(chip, SPDIF_SELECT1, 0, 0xf);
    1440. 

  1440. 	/* 0x0b000000 for digital, 0x000b0000 for analog, from win2000 drivers.
    1441. 

  1441. 	 * Use 0x000f0000 for surround71
    1442. 

  1442. 	 */
    1443. 

  1443. 	snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0x000f0000);
    1444. 

  1444. 

  1445. 	chip->spdif_enable = 0; /* Set digital SPDIF output off */
    1446. 

  1446. 	/*snd_ca0106_ptr_write(chip, 0x45, 0, 0);*/ /* Analogue out */
    1447. 

  1447. 	/*snd_ca0106_ptr_write(chip, 0x45, 0, 0xf00);*/ /* Digital out */
    1448. 

  1448. 

  1449. 	/* goes to 0x40c80000 when doing SPDIF IN/OUT */
    1450. 

  1450. 	snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 0, 0x40c81000);
    1451. 

  1451. 	/* (Mute) CAPTURE feedback into PLAYBACK volume.
    1452. 

  1452. 	 * Only lower 16 bits matter.
    1453. 

  1453. 	 */
    1454. 

  1454. 	snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 1, 0xffffffff);
    1455. 

  1455. 	/* SPDIF IN Volume */
    1456. 

  1456. 	snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 2, 0x30300000);
    1457. 

  1457. 	/* SPDIF IN Volume, 0x70 = (vol & 0x3f) | 0x40 */
    1458. 

  1458. 	snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 3, 0x00700000);
    1459. 

  1459. 

  1460. 	snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING1, 0, 0x32765410);
    1461. 

  1461. 	snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING2, 0, 0x76767676);
    1462. 

  1462. 	snd_ca0106_ptr_write(chip, CAPTURE_ROUTING1, 0, 0x32765410);
    1463. 

  1463. 	snd_ca0106_ptr_write(chip, CAPTURE_ROUTING2, 0, 0x76767676);
    1464. 

  1464. 

  1465. 	for (ch = 0; ch < 4; ch++) {
    1466. 

  1466. 		/* Only high 16 bits matter */
    1467. 

  1467. 		snd_ca0106_ptr_write(chip, CAPTURE_VOLUME1, ch, 0x30303030);
    1468. 

  1468. 		snd_ca0106_ptr_write(chip, CAPTURE_VOLUME2, ch, 0x30303030);
    1469. 

  1469. #if 0 /* Mute */
    1470. 

  1470. 		snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0x40404040);
    1471. 

  1471. 		snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0x40404040);
    1472. 

  1472. 		snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0xffffffff);
    1473. 

  1473. 		snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0xffffffff);
    1474. 

  1474. #endif
    1475. 

  1475. 	}
    1476. 

  1476. 	if (chip->details->i2c_adc == 1) {
    1477. 

  1477. 	        /* Select MIC, Line in, TAD in, AUX in */
    1478. 

  1478. 	        snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
    1479. 

  1479. 		/* Default to CAPTURE_SOURCE to i2s in */
    1480. 

  1480. 		if (!resume)
    1481. 

  1481. 			chip->capture_source = 3;
    1482. 

  1482. 	} else if (chip->details->ac97 == 1) {
    1483. 

  1483. 	        /* Default to AC97 in */
    1484. 

  1484. 	        snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x444400e4);
    1485. 

  1485. 		/* Default to CAPTURE_SOURCE to AC97 in */
    1486. 

  1486. 		if (!resume)
    1487. 

  1487. 			chip->capture_source = 4;
    1488. 

  1488. 	} else {
    1489. 

  1489. 	        /* Select MIC, Line in, TAD in, AUX in */
    1490. 

  1490. 	        snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
    1491. 

  1491. 		/* Default to Set CAPTURE_SOURCE to i2s in */
    1492. 

  1492. 		if (!resume)
    1493. 

  1493. 			chip->capture_source = 3;
    1494. 

  1494. 	}
    1495. 

  1495. 

  1496. 	if (chip->details->gpio_type == 2) {
    1497. 

  1497. 		/* The SB0438 use GPIO differently. */
    1498. 

  1498. 		/* FIXME: Still need to find out what the other GPIO bits do.
    1499. 

  1499. 		 * E.g. For digital spdif out.
    1500. 

  1500. 		 */
    1501. 

  1501. 		outl(0x0, chip->port+GPIO);
    1502. 

  1502. 		/* outl(0x00f0e000, chip->port+GPIO); */ /* Analog */
    1503. 

  1503. 		outl(0x005f5301, chip->port+GPIO); /* Analog */
    1504. 

  1504. 	} else if (chip->details->gpio_type == 1) {
    1505. 

  1505. 		/* The SB0410 and SB0413 use GPIO differently. */
    1506. 

  1506. 		/* FIXME: Still need to find out what the other GPIO bits do.
    1507. 

  1507. 		 * E.g. For digital spdif out.
    1508. 

  1508. 		 */
    1509. 

  1509. 		outl(0x0, chip->port+GPIO);
    1510. 

  1510. 		/* outl(0x00f0e000, chip->port+GPIO); */ /* Analog */
    1511. 

  1511. 		outl(0x005f5301, chip->port+GPIO); /* Analog */
    1512. 

  1512. 	} else {
    1513. 

  1513. 		outl(0x0, chip->port+GPIO);
    1514. 

  1514. 		outl(0x005f03a3, chip->port+GPIO); /* Analog */
    1515. 

  1515. 		/* outl(0x005f02a2, chip->port+GPIO); */ /* SPDIF */
    1516. 

  1516. 	}
    1517. 

  1517. 	snd_ca0106_intr_enable(chip, 0x105); /* Win2000 uses 0x1e0 */
    1518. 

  1518. 

  1519. 	/* outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, chip->port+HCFG); */
    1520. 

  1520. 	/* 0x1000 causes AC3 to fails. Maybe it effects 24 bit output. */
    1521. 

  1521. 	/* outl(0x00001409, chip->port+HCFG); */
    1522. 

  1522. 	/* outl(0x00000009, chip->port+HCFG); */
    1523. 

  1523. 	/* AC97 2.0, Enable outputs. */
    1524. 

  1524. 	outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG);
    1525. 

  1525. 

  1526. 	if (chip->details->i2c_adc == 1) {
    1527. 

  1527. 		/* The SB0410 and SB0413 use I2C to control ADC. */
    1528. 

  1528. 		int size, n;
    1529. 

  1529. 

  1530. 		size = ARRAY_SIZE(i2c_adc_init);
    1531. 

  1531. 		/* snd_printk(KERN_DEBUG "I2C:array size=0x%x\n", size); */
    1532. 

  1532. 		for (n = 0; n < size; n++)
    1533. 

  1533. 			snd_ca0106_i2c_write(chip, i2c_adc_init[n][0],
    1534. 

  1534. 					     i2c_adc_init[n][1]);
    1535. 

  1535. 		for (n = 0; n < 4; n++) {
    1536. 

  1536. 			chip->i2c_capture_volume[n][0] = 0xcf;
    1537. 

  1537. 			chip->i2c_capture_volume[n][1] = 0xcf;
    1538. 

  1538. 		}
    1539. 

  1539. 		chip->i2c_capture_source = 2; /* Line in */
    1540. 

  1540. 		/* Enable Line-in capture. MIC in currently untested. */
    1541. 

  1541. 		/* snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); */
    1542. 

  1542. 	}
    1543. 

  1543. 

  1544. 	if (chip->details->spi_dac == 1) {
    1545. 

  1545. 		/* The SB0570 use SPI to control DAC. */
    1546. 

  1546. 		int size, n;
    1547. 

  1547. 

  1548. 		size = ARRAY_SIZE(spi_dac_init);
    1549. 

  1549. 		for (n = 0; n < size; n++) {
    1550. 

  1550. 			int reg = spi_dac_init[n] >> SPI_REG_SHIFT;
    1551. 

  1551. 

  1552. 			snd_ca0106_spi_write(chip, spi_dac_init[n]);
    1553. 

  1553. 			if (reg < ARRAY_SIZE(chip->spi_dac_reg))
    1554. 

  1554. 				chip->spi_dac_reg[reg] = spi_dac_init[n];
    1555. 

  1555. 		}
    1556. 

  1556. 	}
    1557. 

  1557. }
    1558. 

  1558. 

  1559. static void ca0106_stop_chip(struct snd_ca0106 *chip)
    1560. 

  1560. {
    1561. 

  1561. 	/* disable interrupts */
    1562. 

  1562. 	snd_ca0106_ptr_write(chip, BASIC_INTERRUPT, 0, 0);
    1563. 

  1563. 	outl(0, chip->port + INTE);
    1564. 

  1564. 	snd_ca0106_ptr_write(chip, EXTENDED_INT_MASK, 0, 0);
    1565. 

  1565. 	udelay(1000);
    1566. 

  1566. 	/* disable audio */
    1567. 

  1567. 	/* outl(HCFG_LOCKSOUNDCACHE, chip->port + HCFG); */
    1568. 

  1568. 	outl(0, chip->port + HCFG);
    1569. 

  1569. 	/* FIXME: We need to stop and DMA transfers here.
    1570. 

  1570. 	 *        But as I am not sure how yet, we cannot from the dma pages.
    1571. 

  1571. 	 * So we can fix: snd-malloc: Memory leak?  pages not freed = 8
    1572. 

  1572. 	 */
    1573. 

  1573. }
    1574. 

  1574. 

  1575. static int __devinit snd_ca0106_create(int dev, struct snd_card *card,
    1576. 

  1576. 					 struct pci_dev *pci,
    1577. 

  1577. 					 struct snd_ca0106 **rchip)
    1578. 

  1578. {
    1579. 

  1579. 	struct snd_ca0106 *chip;
    1580. 

  1580. 	struct snd_ca0106_details *c;
    1581. 

  1581. 	int err;
    1582. 

  1582. 	static struct snd_device_ops ops = {
    1583. 

  1583. 		.dev_free = snd_ca0106_dev_free,
    1584. 

  1584. 	};
    1585. 

  1585. 

  1586. 	*rchip = NULL;
    1587. 

  1587. 

  1588. 	err = pci_enable_device(pci);
    1589. 

  1589. 	if (err < 0)
    1590. 

  1590. 		return err;
    1591. 

  1591. 	if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
    1592. 

  1592. 	    pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
    1593. 

  1593. 		printk(KERN_ERR "error to set 32bit mask DMA\n");
    1594. 

  1594. 		pci_disable_device(pci);
    1595. 

  1595. 		return -ENXIO;
    1596. 

  1596. 	}
    1597. 

  1597. 

  1598. 	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    1599. 

  1599. 	if (chip == NULL) {
    1600. 

  1600. 		pci_disable_device(pci);
    1601. 

  1601. 		return -ENOMEM;
    1602. 

  1602. 	}
    1603. 

  1603. 

  1604. 	chip->card = card;
    1605. 

  1605. 	chip->pci = pci;
    1606. 

  1606. 	chip->irq = -1;
    1607. 

  1607. 

  1608. 	spin_lock_init(&chip->emu_lock);
    1609. 

  1609. 

  1610. 	chip->port = pci_resource_start(pci, 0);
    1611. 

  1611. 	chip->res_port = request_region(chip->port, 0x20, "snd_ca0106");
    1612. 

  1612. 	if (!chip->res_port) {
    1613. 

  1613. 		snd_ca0106_free(chip);
    1614. 

  1614. 		printk(KERN_ERR "cannot allocate the port\n");
    1615. 

  1615. 		return -EBUSY;
    1616. 

  1616. 	}
    1617. 

  1617. 

  1618. 	if (request_irq(pci->irq, snd_ca0106_interrupt,
    1619. 

  1619. 			IRQF_SHARED, "snd_ca0106", chip)) {
    1620. 

  1620. 		snd_ca0106_free(chip);
    1621. 

  1621. 		printk(KERN_ERR "cannot grab irq\n");
    1622. 

  1622. 		return -EBUSY;
    1623. 

  1623. 	}
    1624. 

  1624. 	chip->irq = pci->irq;
    1625. 

  1625. 

  1626. 	/* This stores the periods table. */
    1627. 

  1627. 	if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
    1628. 

  1628. 				1024, &chip->buffer) < 0) {
    1629. 

  1629. 		snd_ca0106_free(chip);
    1630. 

  1630. 		return -ENOMEM;
    1631. 

  1631. 	}
    1632. 

  1632. 

  1633. 	pci_set_master(pci);
    1634. 

  1634. 	/* read serial */
    1635. 

  1635. 	pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
    1636. 

  1636. 	pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
    1637. 

  1637. 	printk(KERN_INFO "snd-ca0106: Model %04x Rev %08x Serial %08x\n",
    1638. 

  1638. 	       chip->model, pci->revision, chip->serial);
    1639. 

  1639. 	strcpy(card->driver, "CA0106");
    1640. 

  1640. 	strcpy(card->shortname, "CA0106");
    1641. 

  1641. 

  1642. 	for (c = ca0106_chip_details; c->serial; c++) {
    1643. 

  1643. 		if (subsystem[dev]) {
    1644. 

  1644. 			if (c->serial == subsystem[dev])
    1645. 

  1645. 				break;
    1646. 

  1646. 		} else if (c->serial == chip->serial)
    1647. 

  1647. 			break;
    1648. 

  1648. 	}
    1649. 

  1649. 	chip->details = c;
    1650. 

  1650. 	if (subsystem[dev]) {
    1651. 

  1651. 		printk(KERN_INFO "snd-ca0106: Sound card name=%s, "
    1652. 

  1652. 		       "subsystem=0x%x. Forced to subsystem=0x%x\n",
    1653. 

  1653. 		       c->name, chip->serial, subsystem[dev]);
    1654. 

  1654. 	}
    1655. 

  1655. 

  1656. 	sprintf(card->longname, "%s at 0x%lx irq %i",
    1657. 

  1657. 		c->name, chip->port, chip->irq);
    1658. 

  1658. 

  1659. 	ca0106_init_chip(chip, 0);
    1660. 

  1660. 

  1661. 	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1662. 

  1662. 	if (err < 0) {
    1663. 

  1663. 		snd_ca0106_free(chip);
    1664. 

  1664. 		return err;
    1665. 

  1665. 	}
    1666. 

  1666. 	*rchip = chip;
    1667. 

  1667. 	return 0;
    1668. 

  1668. }
    1669. 

  1669. 

  1670. 

  1671. static void ca0106_midi_interrupt_enable(struct snd_ca_midi *midi, int intr)
    1672. 

  1672. {
    1673. 

  1673. 	snd_ca0106_intr_enable((struct snd_ca0106 *)(midi->dev_id), intr);
    1674. 

  1674. }
    1675. 

  1675. 

  1676. static void ca0106_midi_interrupt_disable(struct snd_ca_midi *midi, int intr)
    1677. 

  1677. {
    1678. 

  1678. 	snd_ca0106_intr_disable((struct snd_ca0106 *)(midi->dev_id), intr);
    1679. 

  1679. }
    1680. 

  1680. 

  1681. static unsigned char ca0106_midi_read(struct snd_ca_midi *midi, int idx)
    1682. 

  1682. {
    1683. 

  1683. 	return (unsigned char)snd_ca0106_ptr_read((struct snd_ca0106 *)(midi->dev_id),
    1684. 

  1684. 						  midi->port + idx, 0);
    1685. 

  1685. }
    1686. 

  1686. 

  1687. static void ca0106_midi_write(struct snd_ca_midi *midi, int data, int idx)
    1688. 

  1688. {
    1689. 

  1689. 	snd_ca0106_ptr_write((struct snd_ca0106 *)(midi->dev_id), midi->port + idx, 0, data);
    1690. 

  1690. }
    1691. 

  1691. 

  1692. static struct snd_card *ca0106_dev_id_card(void *dev_id)
    1693. 

  1693. {
    1694. 

  1694. 	return ((struct snd_ca0106 *)dev_id)->card;
    1695. 

  1695. }
    1696. 

  1696. 

  1697. static int ca0106_dev_id_port(void *dev_id)
    1698. 

  1698. {
    1699. 

  1699. 	return ((struct snd_ca0106 *)dev_id)->port;
    1700. 

  1700. }
    1701. 

  1701. 

  1702. static int __devinit snd_ca0106_midi(struct snd_ca0106 *chip, unsigned int channel)
    1703. 

  1703. {
    1704. 

  1704. 	struct snd_ca_midi *midi;
    1705. 

  1705. 	char *name;
    1706. 

  1706. 	int err;
    1707. 

  1707. 

  1708. 	if (channel == CA0106_MIDI_CHAN_B) {
    1709. 

  1709. 		name = "CA0106 MPU-401 (UART) B";
    1710. 

  1710. 		midi =  &chip->midi2;
    1711. 

  1711. 		midi->tx_enable = INTE_MIDI_TX_B;
    1712. 

  1712. 		midi->rx_enable = INTE_MIDI_RX_B;
    1713. 

  1713. 		midi->ipr_tx = IPR_MIDI_TX_B;
    1714. 

  1714. 		midi->ipr_rx = IPR_MIDI_RX_B;
    1715. 

  1715. 		midi->port = MIDI_UART_B_DATA;
    1716. 

  1716. 	} else {
    1717. 

  1717. 		name = "CA0106 MPU-401 (UART)";
    1718. 

  1718. 		midi =  &chip->midi;
    1719. 

  1719. 		midi->tx_enable = INTE_MIDI_TX_A;
    1720. 

  1720. 		midi->rx_enable = INTE_MIDI_TX_B;
    1721. 

  1721. 		midi->ipr_tx = IPR_MIDI_TX_A;
    1722. 

  1722. 		midi->ipr_rx = IPR_MIDI_RX_A;
    1723. 

  1723. 		midi->port = MIDI_UART_A_DATA;
    1724. 

  1724. 	}
    1725. 

  1725. 

  1726. 	midi->reset = CA0106_MPU401_RESET;
    1727. 

  1727. 	midi->enter_uart = CA0106_MPU401_ENTER_UART;
    1728. 

  1728. 	midi->ack = CA0106_MPU401_ACK;
    1729. 

  1729. 

  1730. 	midi->input_avail = CA0106_MIDI_INPUT_AVAIL;
    1731. 

  1731. 	midi->output_ready = CA0106_MIDI_OUTPUT_READY;
    1732. 

  1732. 

  1733. 	midi->channel = channel;
    1734. 

  1734. 

  1735. 	midi->interrupt_enable = ca0106_midi_interrupt_enable;
    1736. 

  1736. 	midi->interrupt_disable = ca0106_midi_interrupt_disable;
    1737. 

  1737. 

  1738. 	midi->read = ca0106_midi_read;
    1739. 

  1739. 	midi->write = ca0106_midi_write;
    1740. 

  1740. 

  1741. 	midi->get_dev_id_card = ca0106_dev_id_card;
    1742. 

  1742. 	midi->get_dev_id_port = ca0106_dev_id_port;
    1743. 

  1743. 

  1744. 	midi->dev_id = chip;
    1745. 

  1745. 	
    1746. 

  1746. 	if ((err = ca_midi_init(chip, midi, 0, name)) < 0)
    1747. 

  1747. 		return err;
    1748. 

  1748. 

  1749. 	return 0;
    1750. 

  1750. }
    1751. 

  1751. 

  1752. 

  1753. static int __devinit snd_ca0106_probe(struct pci_dev *pci,
    1754. 

  1754. 					const struct pci_device_id *pci_id)
    1755. 

  1755. {
    1756. 

  1756. 	static int dev;
    1757. 

  1757. 	struct snd_card *card;
    1758. 

  1758. 	struct snd_ca0106 *chip;
    1759. 

  1759. 	int i, err;
    1760. 

  1760. 

  1761. 	if (dev >= SNDRV_CARDS)
    1762. 

  1762. 		return -ENODEV;
    1763. 

  1763. 	if (!enable[dev]) {
    1764. 

  1764. 		dev++;
    1765. 

  1765. 		return -ENOENT;
    1766. 

  1766. 	}
    1767. 

  1767. 

  1768. 	err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
    1769. 

  1769. 	if (err < 0)
    1770. 

  1770. 		return err;
    1771. 

  1771. 

  1772. 	err = snd_ca0106_create(dev, card, pci, &chip);
    1773. 

  1773. 	if (err < 0)
    1774. 

  1774. 		goto error;
    1775. 

  1775. 	card->private_data = chip;
    1776. 

  1776. 

  1777. 	for (i = 0; i < 4; i++) {
    1778. 

  1778. 		err = snd_ca0106_pcm(chip, i);
    1779. 

  1779. 		if (err < 0)
    1780. 

  1780. 			goto error;
    1781. 

  1781. 	}
    1782. 

  1782. 

  1783. 	if (chip->details->ac97 == 1) {
    1784. 

  1784. 		/* The SB0410 and SB0413 do not have an AC97 chip. */
    1785. 

  1785. 		err = snd_ca0106_ac97(chip);
    1786. 

  1786. 		if (err < 0)
    1787. 

  1787. 			goto error;
    1788. 

  1788. 	}
    1789. 

  1789. 	err = snd_ca0106_mixer(chip);
    1790. 

  1790. 	if (err < 0)
    1791. 

  1791. 		goto error;
    1792. 

  1792. 

  1793. 	snd_printdd("ca0106: probe for MIDI channel A ...");
    1794. 

  1794. 	err = snd_ca0106_midi(chip, CA0106_MIDI_CHAN_A);
    1795. 

  1795. 	if (err < 0)
    1796. 

  1796. 		goto error;
    1797. 

  1797. 	snd_printdd(" done.\n");
    1798. 

  1798. 

  1799. #ifdef CONFIG_PROC_FS
    1800. 

  1800. 	snd_ca0106_proc_init(chip);
    1801. 

  1801. #endif
    1802. 

  1802. 

  1803. 	snd_card_set_dev(card, &pci->dev);
    1804. 

  1804. 

  1805. 	err = snd_card_register(card);
    1806. 

  1806. 	if (err < 0)
    1807. 

  1807. 		goto error;
    1808. 

  1808. 

  1809. 	pci_set_drvdata(pci, card);
    1810. 

  1810. 	dev++;
    1811. 

  1811. 	return 0;
    1812. 

  1812. 

  1813.  error:
    1814. 

  1814. 	snd_card_free(card);
    1815. 

  1815. 	return err;
    1816. 

  1816. }
    1817. 

  1817. 

  1818. static void __devexit snd_ca0106_remove(struct pci_dev *pci)
    1819. 

  1819. {
    1820. 

  1820. 	snd_card_free(pci_get_drvdata(pci));
    1821. 

  1821. 	pci_set_drvdata(pci, NULL);
    1822. 

  1822. }
    1823. 

  1823. 

  1824. #ifdef CONFIG_PM
    1825. 

  1825. static int snd_ca0106_suspend(struct pci_dev *pci, pm_message_t state)
    1826. 

  1826. {
    1827. 

  1827. 	struct snd_card *card = pci_get_drvdata(pci);
    1828. 

  1828. 	struct snd_ca0106 *chip = card->private_data;
    1829. 

  1829. 	int i;
    1830. 

  1830. 

  1831. 	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
    1832. 

  1832. 	for (i = 0; i < 4; i++)
    1833. 

  1833. 		snd_pcm_suspend_all(chip->pcm[i]);
    1834. 

  1834. 	if (chip->details->ac97)
    1835. 

  1835. 		snd_ac97_suspend(chip->ac97);
    1836. 

  1836. 	snd_ca0106_mixer_suspend(chip);
    1837. 

  1837. 

  1838. 	ca0106_stop_chip(chip);
    1839. 

  1839. 

  1840. 	pci_disable_device(pci);
    1841. 

  1841. 	pci_save_state(pci);
    1842. 

  1842. 	pci_set_power_state(pci, pci_choose_state(pci, state));
    1843. 

  1843. 	return 0;
    1844. 

  1844. }
    1845. 

  1845. 

  1846. static int snd_ca0106_resume(struct pci_dev *pci)
    1847. 

  1847. {
    1848. 

  1848. 	struct snd_card *card = pci_get_drvdata(pci);
    1849. 

  1849. 	struct snd_ca0106 *chip = card->private_data;
    1850. 

  1850. 	int i;
    1851. 

  1851. 

  1852. 	pci_set_power_state(pci, PCI_D0);
    1853. 

  1853. 	pci_restore_state(pci);
    1854. 

  1854. 

  1855. 	if (pci_enable_device(pci) < 0) {
    1856. 

  1856. 		snd_card_disconnect(card);
    1857. 

  1857. 		return -EIO;
    1858. 

  1858. 	}
    1859. 

  1859. 

  1860. 	pci_set_master(pci);
    1861. 

  1861. 

  1862. 	ca0106_init_chip(chip, 1);
    1863. 

  1863. 

  1864. 	if (chip->details->ac97)
    1865. 

  1865. 		snd_ac97_resume(chip->ac97);
    1866. 

  1866. 	snd_ca0106_mixer_resume(chip);
    1867. 

  1867. 	if (chip->details->spi_dac) {
    1868. 

  1868. 		for (i = 0; i < ARRAY_SIZE(chip->spi_dac_reg); i++)
    1869. 

  1869. 			snd_ca0106_spi_write(chip, chip->spi_dac_reg[i]);
    1870. 

  1870. 	}
    1871. 

  1871. 

  1872. 	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
    1873. 

  1873. 	return 0;
    1874. 

  1874. }
    1875. 

  1875. #endif
    1876. 

  1876. 

  1877. // PCI IDs
    1878. 

  1878. static DEFINE_PCI_DEVICE_TABLE(snd_ca0106_ids) = {
    1879. 

  1879. 	{ PCI_VDEVICE(CREATIVE, 0x0007), 0 },	/* Audigy LS or Live 24bit */
    1880. 

  1880. 	{ 0, }
    1881. 

  1881. };
    1882. 

  1882. MODULE_DEVICE_TABLE(pci, snd_ca0106_ids);
    1883. 

  1883. 

  1884. // pci_driver definition
    1885. 

  1885. static struct pci_driver driver = {
    1886. 

  1886. 	.name = "CA0106",
    1887. 

  1887. 	.id_table = snd_ca0106_ids,
    1888. 

  1888. 	.probe = snd_ca0106_probe,
    1889. 

  1889. 	.remove = __devexit_p(snd_ca0106_remove),
    1890. 

  1890. #ifdef CONFIG_PM
    1891. 

  1891. 	.suspend = snd_ca0106_suspend,
    1892. 

  1892. 	.resume = snd_ca0106_resume,
    1893. 

  1893. #endif
    1894. 

  1894. };
    1895. 

  1895. 

  1896. // initialization of the module
    1897. 

  1897. static int __init alsa_card_ca0106_init(void)
    1898. 

  1898. {
    1899. 

  1899. 	return pci_register_driver(&driver);
    1900. 

  1900. }
    1901. 

  1901. 

  1902. // clean up the module
    1903. 

  1903. static void __exit alsa_card_ca0106_exit(void)
    1904. 

  1904. {
    1905. 

  1905. 	pci_unregister_driver(&driver);
    1906. 

  1906. }
    1907. 

  1907. 

  1908. module_init(alsa_card_ca0106_init)
    1909. 

  1909. module_exit(alsa_card_ca0106_exit)
    1910. 

  1910.