1 /* 2 * Copyright (c) 2004 James Courtier-Dutton <James@superbug.demon.co.uk> 3 * Driver CA0106 chips. e.g. Sound Blaster Audigy LS and Live 24bit 4 * Version: 0.0.17 5 * 6 * FEATURES currently supported: 7 * See ca0106_main.c for features. 8 * 9 * Changelog: 10 * Support interrupts per period. 11 * Removed noise from Center/LFE channel when in Analog mode. 12 * Rename and remove mixer controls. 13 * 0.0.6 14 * Use separate card based DMA buffer for periods table list. 15 * 0.0.7 16 * Change remove and rename ctrls into lists. 17 * 0.0.8 18 * Try to fix capture sources. 19 * 0.0.9 20 * Fix AC3 output. 21 * Enable S32_LE format support. 22 * 0.0.10 23 * Enable playback 48000 and 96000 rates. (Rates other that these do not work, even with "plug:front".) 24 * 0.0.11 25 * Add Model name recognition. 26 * 0.0.12 27 * Correct interrupt timing. interrupt at end of period, instead of in the middle of a playback period. 28 * Remove redundent "voice" handling. 29 * 0.0.13 30 * Single trigger call for multi channels. 31 * 0.0.14 32 * Set limits based on what the sound card hardware can do. 33 * playback periods_min=2, periods_max=8 34 * capture hw constraints require period_size = n * 64 bytes. 35 * playback hw constraints require period_size = n * 64 bytes. 36 * 0.0.15 37 * Separated ca0106.c into separate functional .c files. 38 * 0.0.16 39 * Modified Copyright message. 40 * 0.0.17 41 * Implement Mic and Line in Capture. 42 * 43 * This code was initally based on code from ALSA's emu10k1x.c which is: 44 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com> 45 * 46 * This program is free software; you can redistribute it and/or modify 47 * it under the terms of the GNU General Public License as published by 48 * the Free Software Foundation; either version 2 of the License, or 49 * (at your option) any later version. 50 * 51 * This program is distributed in the hope that it will be useful, 52 * but WITHOUT ANY WARRANTY; without even the implied warranty of 53 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 54 * GNU General Public License for more details. 55 * 56 * You should have received a copy of the GNU General Public License 57 * along with this program; if not, write to the Free Software 58 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 59 * 60 */ 61 #include <sound/driver.h> 62 #include <linux/delay.h> 63 #include <linux/init.h> 64 #include <linux/interrupt.h> 65 #include <linux/pci.h> 66 #include <linux/slab.h> 67 #include <linux/moduleparam.h> 68 #include <sound/core.h> 69 #include <sound/initval.h> 70 #include <sound/pcm.h> 71 #include <sound/ac97_codec.h> 72 #include <sound/info.h> 73 74 #include "ca0106.h" 75 76 static int snd_ca0106_shared_spdif_info(struct snd_kcontrol *kcontrol, 77 struct snd_ctl_elem_info *uinfo) 78 { 79 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 80 uinfo->count = 1; 81 uinfo->value.integer.min = 0; 82 uinfo->value.integer.max = 1; 83 return 0; 84 } 85 86 static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol, 87 struct snd_ctl_elem_value *ucontrol) 88 { 89 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 90 91 ucontrol->value.enumerated.item[0] = emu->spdif_enable; 92 return 0; 93 } 94 95 static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol, 96 struct snd_ctl_elem_value *ucontrol) 97 { 98 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 99 unsigned int val; 100 int change = 0; 101 u32 mask; 102 103 val = ucontrol->value.enumerated.item[0] ; 104 change = (emu->spdif_enable != val); 105 if (change) { 106 emu->spdif_enable = val; 107 if (val == 1) { 108 /* Digital */ 109 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf); 110 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000); 111 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, 112 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000); 113 mask = inl(emu->port + GPIO) & ~0x101; 114 outl(mask, emu->port + GPIO); 115 116 } else { 117 /* Analog */ 118 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf); 119 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000); 120 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, 121 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000); 122 mask = inl(emu->port + GPIO) | 0x101; 123 outl(mask, emu->port + GPIO); 124 } 125 } 126 return change; 127 } 128 129 static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol, 130 struct snd_ctl_elem_info *uinfo) 131 { 132 static char *texts[6] = { 133 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out" 134 }; 135 136 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 137 uinfo->count = 1; 138 uinfo->value.enumerated.items = 6; 139 if (uinfo->value.enumerated.item > 5) 140 uinfo->value.enumerated.item = 5; 141 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 142 return 0; 143 } 144 145 static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol, 146 struct snd_ctl_elem_value *ucontrol) 147 { 148 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 149 150 ucontrol->value.enumerated.item[0] = emu->capture_source; 151 return 0; 152 } 153 154 static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol, 155 struct snd_ctl_elem_value *ucontrol) 156 { 157 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 158 unsigned int val; 159 int change = 0; 160 u32 mask; 161 u32 source; 162 163 val = ucontrol->value.enumerated.item[0] ; 164 change = (emu->capture_source != val); 165 if (change) { 166 emu->capture_source = val; 167 source = (val << 28) | (val << 24) | (val << 20) | (val << 16); 168 mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff; 169 snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask); 170 } 171 return change; 172 } 173 174 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol, 175 struct snd_ctl_elem_info *uinfo) 176 { 177 static char *texts[2] = { "Line in", "Mic in" }; 178 179 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 180 uinfo->count = 1; 181 uinfo->value.enumerated.items = 2; 182 if (uinfo->value.enumerated.item > 1) 183 uinfo->value.enumerated.item = 1; 184 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 185 return 0; 186 } 187 188 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol, 189 struct snd_ctl_elem_value *ucontrol) 190 { 191 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 192 193 ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in; 194 return 0; 195 } 196 197 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol, 198 struct snd_ctl_elem_value *ucontrol) 199 { 200 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 201 unsigned int val; 202 int change = 0; 203 u32 tmp; 204 205 val = ucontrol->value.enumerated.item[0] ; 206 change = (emu->capture_mic_line_in != val); 207 if (change) { 208 emu->capture_mic_line_in = val; 209 if (val) { 210 snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_PHONE); /* Mute input */ 211 tmp = inl(emu->port+GPIO) & ~0x400; 212 tmp = tmp | 0x400; 213 outl(tmp, emu->port+GPIO); 214 snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC); 215 } else { 216 snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_PHONE); /* Mute input */ 217 tmp = inl(emu->port+GPIO) & ~0x400; 218 outl(tmp, emu->port+GPIO); 219 snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN); 220 } 221 } 222 return change; 223 } 224 225 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata = 226 { 227 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 228 .name = "Mic/Line in Capture", 229 .info = snd_ca0106_capture_mic_line_in_info, 230 .get = snd_ca0106_capture_mic_line_in_get, 231 .put = snd_ca0106_capture_mic_line_in_put 232 }; 233 234 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol, 235 struct snd_ctl_elem_info *uinfo) 236 { 237 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 238 uinfo->count = 1; 239 return 0; 240 } 241 242 static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol, 243 struct snd_ctl_elem_value *ucontrol) 244 { 245 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 246 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 247 248 ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff; 249 ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff; 250 ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff; 251 ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff; 252 return 0; 253 } 254 255 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol, 256 struct snd_ctl_elem_value *ucontrol) 257 { 258 ucontrol->value.iec958.status[0] = 0xff; 259 ucontrol->value.iec958.status[1] = 0xff; 260 ucontrol->value.iec958.status[2] = 0xff; 261 ucontrol->value.iec958.status[3] = 0xff; 262 return 0; 263 } 264 265 static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol, 266 struct snd_ctl_elem_value *ucontrol) 267 { 268 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 269 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 270 int change; 271 unsigned int val; 272 273 val = (ucontrol->value.iec958.status[0] << 0) | 274 (ucontrol->value.iec958.status[1] << 8) | 275 (ucontrol->value.iec958.status[2] << 16) | 276 (ucontrol->value.iec958.status[3] << 24); 277 change = val != emu->spdif_bits[idx]; 278 if (change) { 279 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, val); 280 emu->spdif_bits[idx] = val; 281 } 282 return change; 283 } 284 285 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol, 286 struct snd_ctl_elem_info *uinfo) 287 { 288 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 289 uinfo->count = 2; 290 uinfo->value.integer.min = 0; 291 uinfo->value.integer.max = 255; 292 return 0; 293 } 294 295 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol, 296 struct snd_ctl_elem_value *ucontrol) 297 { 298 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 299 unsigned int value; 300 int channel_id, reg; 301 302 channel_id = (kcontrol->private_value >> 8) & 0xff; 303 reg = kcontrol->private_value & 0xff; 304 305 value = snd_ca0106_ptr_read(emu, reg, channel_id); 306 ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */ 307 ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */ 308 return 0; 309 } 310 311 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol, 312 struct snd_ctl_elem_value *ucontrol) 313 { 314 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); 315 unsigned int oval, nval; 316 int channel_id, reg; 317 318 channel_id = (kcontrol->private_value >> 8) & 0xff; 319 reg = kcontrol->private_value & 0xff; 320 321 oval = snd_ca0106_ptr_read(emu, reg, channel_id); 322 nval = ((0xff - ucontrol->value.integer.value[0]) << 24) | 323 ((0xff - ucontrol->value.integer.value[1]) << 16); 324 nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) | 325 ((0xff - ucontrol->value.integer.value[1]) ); 326 if (oval == nval) 327 return 0; 328 snd_ca0106_ptr_write(emu, reg, channel_id, nval); 329 return 1; 330 } 331 332 #define CA_VOLUME(xname,chid,reg) \ 333 { \ 334 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ 335 .info = snd_ca0106_volume_info, \ 336 .get = snd_ca0106_volume_get, \ 337 .put = snd_ca0106_volume_put, \ 338 .private_value = ((chid) << 8) | (reg) \ 339 } 340 341 342 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = { 343 CA_VOLUME("Analog Front Playback Volume", 344 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2), 345 CA_VOLUME("Analog Rear Playback Volume", 346 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2), 347 CA_VOLUME("Analog Center/LFE Playback Volume", 348 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2), 349 CA_VOLUME("Analog Side Playback Volume", 350 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2), 351 352 CA_VOLUME("IEC958 Front Playback Volume", 353 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1), 354 CA_VOLUME("IEC958 Rear Playback Volume", 355 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1), 356 CA_VOLUME("IEC958 Center/LFE Playback Volume", 357 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1), 358 CA_VOLUME("IEC958 Unknown Playback Volume", 359 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1), 360 361 CA_VOLUME("CAPTURE feedback Playback Volume", 362 1, CAPTURE_CONTROL), 363 364 { 365 .access = SNDRV_CTL_ELEM_ACCESS_READ, 366 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 367 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), 368 .count = 4, 369 .info = snd_ca0106_spdif_info, 370 .get = snd_ca0106_spdif_get_mask 371 }, 372 { 373 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 374 .name = "IEC958 Playback Switch", 375 .info = snd_ca0106_shared_spdif_info, 376 .get = snd_ca0106_shared_spdif_get, 377 .put = snd_ca0106_shared_spdif_put 378 }, 379 { 380 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 381 .name = "Capture Source", 382 .info = snd_ca0106_capture_source_info, 383 .get = snd_ca0106_capture_source_get, 384 .put = snd_ca0106_capture_source_put 385 }, 386 { 387 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 388 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 389 .count = 4, 390 .info = snd_ca0106_spdif_info, 391 .get = snd_ca0106_spdif_get, 392 .put = snd_ca0106_spdif_put 393 }, 394 }; 395 396 static int __devinit remove_ctl(struct snd_card *card, const char *name) 397 { 398 struct snd_ctl_elem_id id; 399 memset(&id, 0, sizeof(id)); 400 strcpy(id.name, name); 401 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 402 return snd_ctl_remove_id(card, &id); 403 } 404 405 static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name) 406 { 407 struct snd_ctl_elem_id sid; 408 memset(&sid, 0, sizeof(sid)); 409 /* FIXME: strcpy is bad. */ 410 strcpy(sid.name, name); 411 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 412 return snd_ctl_find_id(card, &sid); 413 } 414 415 static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst) 416 { 417 struct snd_kcontrol *kctl = ctl_find(card, src); 418 if (kctl) { 419 strcpy(kctl->id.name, dst); 420 return 0; 421 } 422 return -ENOENT; 423 } 424 425 int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu) 426 { 427 int i, err; 428 struct snd_card *card = emu->card; 429 char **c; 430 static char *ca0106_remove_ctls[] = { 431 "Master Mono Playback Switch", 432 "Master Mono Playback Volume", 433 "3D Control - Switch", 434 "3D Control Sigmatel - Depth", 435 "PCM Playback Switch", 436 "PCM Playback Volume", 437 "CD Playback Switch", 438 "CD Playback Volume", 439 "Phone Playback Switch", 440 "Phone Playback Volume", 441 "Video Playback Switch", 442 "Video Playback Volume", 443 "PC Speaker Playback Switch", 444 "PC Speaker Playback Volume", 445 "Mono Output Select", 446 "Capture Source", 447 "Capture Switch", 448 "Capture Volume", 449 "External Amplifier", 450 "Sigmatel 4-Speaker Stereo Playback Switch", 451 "Sigmatel Surround Phase Inversion Playback ", 452 NULL 453 }; 454 static char *ca0106_rename_ctls[] = { 455 "Master Playback Switch", "Capture Switch", 456 "Master Playback Volume", "Capture Volume", 457 "Line Playback Switch", "AC97 Line Capture Switch", 458 "Line Playback Volume", "AC97 Line Capture Volume", 459 "Aux Playback Switch", "AC97 Aux Capture Switch", 460 "Aux Playback Volume", "AC97 Aux Capture Volume", 461 "Mic Playback Switch", "AC97 Mic Capture Switch", 462 "Mic Playback Volume", "AC97 Mic Capture Volume", 463 "Mic Select", "AC97 Mic Select", 464 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)", 465 NULL 466 }; 467 #if 1 468 for (c = ca0106_remove_ctls; *c; c++) 469 remove_ctl(card, *c); 470 for (c = ca0106_rename_ctls; *c; c += 2) 471 rename_ctl(card, c[0], c[1]); 472 #endif 473 474 for (i = 0; i < ARRAY_SIZE(snd_ca0106_volume_ctls); i++) { 475 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_volume_ctls[i], emu)); 476 if (err < 0) 477 return err; 478 } 479 if (emu->details->i2c_adc == 1) { 480 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu)); 481 if (err < 0) 482 return err; 483 } 484 return 0; 485 } 486 487