tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'sound-3.6' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound

Pull sound fixes from Takashi Iwai:
"This update became slightly bigger than usual for rc3, but most of the
commits are small and trivial. A large chunk is found for HD-audio
ca0132 codec, which is mostly a clean up of the specific code, to make
SPDIF working properly, and also in the new ASoC Arizona driver.

One important fix is for usb-audio Oops fix since 3.5. We still see
some EHCI related bandwidth problem, but usb-audio should be more
stabilized now.

Other than that, a Kconfig fix is spread over files, and various
HD-audio and ASoC fixes as usual, in addition to Julia's error path
fixes."

* tag 'sound-3.6' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (42 commits)
ALSA: snd-als100: fix suspend/resume
ALSA: hda - Fix leftover codec->power_transition
ALSA: hda - don't create dysfunctional mixer controls for ca0132
ALSA: sound/ppc/snd_ps3.c: fix error return code
ALSA: sound/pci/rme9652/hdspm.c: fix error return code
ALSA: sound/pci/sis7019.c: fix error return code
ALSA: sound/pci/ctxfi/ctatc.c: fix error return code
ALSA: sound/atmel/ac97c.c: fix error return code
ALSA: sound/atmel/abdac.c: fix error return code
ALSA: fix pcm.h kernel-doc warning and notation
sound: oss/sb_audio: prevent divide by zero bug
ASoC: wm9712: Fix inverted capture volume
ASoC: wm9712: Fix microphone source selection
ASoC: wm5102: Remove DRC2
ALSA: hda - Don't send invalid volume knob command on IDT 92hd75bxx
ALSA: usb-audio: Fix scheduling-while-atomic bug in PCM capture stream
ALSA: lx6464es: Add a missing error check
ALSA: hda - Fix 'Beep Playback Switch' with no underlying mute switch
ASoC: jack: Always notify full jack status
ASoC: wm5110: Add missing input PGA routes
...

Linus Torvalds 4459f397 f341861f

+261 -237
+6 -1
MAINTAINERS
··· 7670 7670 F: Documentation/hwmon/wm83?? 7671 7671 F: arch/arm/mach-s3c64xx/mach-crag6410* 7672 7672 F: drivers/clk/clk-wm83*.c 7673 + F: drivers/extcon/extcon-arizona.c 7673 7674 F: drivers/leds/leds-wm83*.c 7674 7675 F: drivers/gpio/gpio-*wm*.c 7676 + F: drivers/gpio/gpio-arizona.c 7675 7677 F: drivers/hwmon/wm83??-hwmon.c 7676 7678 F: drivers/input/misc/wm831x-on.c 7677 7679 F: drivers/input/touchscreen/wm831x-ts.c 7678 7680 F: drivers/input/touchscreen/wm97*.c 7679 - F: drivers/mfd/wm8*.c 7681 + F: drivers/mfd/arizona* 7682 + F: drivers/mfd/wm*.c 7680 7683 F: drivers/power/wm83*.c 7681 7684 F: drivers/rtc/rtc-wm83*.c 7682 7685 F: drivers/regulator/wm8*.c 7683 7686 F: drivers/video/backlight/wm83*_bl.c 7684 7687 F: drivers/watchdog/wm83*_wdt.c 7688 + F: include/linux/mfd/arizona/ 7685 7689 F: include/linux/mfd/wm831x/ 7686 7690 F: include/linux/mfd/wm8350/ 7687 7691 F: include/linux/mfd/wm8400* 7688 7692 F: include/linux/wm97xx.h 7689 7693 F: include/sound/wm????.h 7694 + F: sound/soc/codecs/arizona.? 7690 7695 F: sound/soc/codecs/wm* 7691 7696 7692 7697 WORKQUEUE
+2 -1
include/sound/pcm.h
··· 1075 1075 const char *snd_pcm_format_name(snd_pcm_format_t format); 1076 1076 1077 1077 /** 1078 - * Get a string naming the direction of a stream 1078 + * snd_pcm_stream_str - Get a string naming the direction of a stream 1079 + * @substream: the pcm substream instance 1079 1080 */ 1080 1081 static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream) 1081 1082 {
+2 -2
sound/arm/pxa2xx-ac97.c
··· 106 106 .prepare = pxa2xx_ac97_pcm_prepare, 107 107 }; 108 108 109 - #ifdef CONFIG_PM 109 + #ifdef CONFIG_PM_SLEEP 110 110 111 111 static int pxa2xx_ac97_do_suspend(struct snd_card *card) 112 112 { ··· 243 243 .driver = { 244 244 .name = "pxa2xx-ac97", 245 245 .owner = THIS_MODULE, 246 - #ifdef CONFIG_PM 246 + #ifdef CONFIG_PM_SLEEP 247 247 .pm = &pxa2xx_ac97_pm_ops, 248 248 #endif 249 249 },
+2 -1
sound/atmel/abdac.c
··· 452 452 dac->regs = ioremap(regs->start, resource_size(regs)); 453 453 if (!dac->regs) { 454 454 dev_dbg(&pdev->dev, "could not remap register memory\n"); 455 + retval = -ENOMEM; 455 456 goto out_free_card; 456 457 } 457 458 ··· 535 534 return retval; 536 535 } 537 536 538 - #ifdef CONFIG_PM 537 + #ifdef CONFIG_PM_SLEEP 539 538 static int atmel_abdac_suspend(struct device *pdev) 540 539 { 541 540 struct snd_card *card = dev_get_drvdata(pdev);
+5 -9
sound/atmel/ac97c.c
··· 278 278 if (retval < 0) 279 279 return retval; 280 280 /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */ 281 - if (cpu_is_at32ap7000()) { 282 - if (retval < 0) 283 - return retval; 284 - /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */ 285 - if (retval == 1) 286 - if (test_and_clear_bit(DMA_RX_READY, &chip->flags)) 287 - dw_dma_cyclic_free(chip->dma.rx_chan); 288 - } 281 + if (cpu_is_at32ap7000() && retval == 1) 282 + if (test_and_clear_bit(DMA_RX_READY, &chip->flags)) 283 + dw_dma_cyclic_free(chip->dma.rx_chan); 289 284 290 285 /* Set restrictions to params. */ 291 286 mutex_lock(&opened_mutex); ··· 975 980 976 981 if (!chip->regs) { 977 982 dev_dbg(&pdev->dev, "could not remap register memory\n"); 983 + retval = -ENOMEM; 978 984 goto err_ioremap; 979 985 } 980 986 ··· 1130 1134 return retval; 1131 1135 } 1132 1136 1133 - #ifdef CONFIG_PM 1137 + #ifdef CONFIG_PM_SLEEP 1134 1138 static int atmel_ac97c_suspend(struct device *pdev) 1135 1139 { 1136 1140 struct snd_card *card = dev_get_drvdata(pdev);
+1 -1
sound/drivers/aloop.c
··· 1176 1176 return 0; 1177 1177 } 1178 1178 1179 - #ifdef CONFIG_PM 1179 + #ifdef CONFIG_PM_SLEEP 1180 1180 static int loopback_suspend(struct device *pdev) 1181 1181 { 1182 1182 struct snd_card *card = dev_get_drvdata(pdev);
+1 -1
sound/drivers/dummy.c
··· 1064 1064 return 0; 1065 1065 } 1066 1066 1067 - #ifdef CONFIG_PM 1067 + #ifdef CONFIG_PM_SLEEP 1068 1068 static int snd_dummy_suspend(struct device *pdev) 1069 1069 { 1070 1070 struct snd_card *card = dev_get_drvdata(pdev);
+2 -2
sound/drivers/pcsp/pcsp.c
··· 199 199 pcspkr_stop_sound(); 200 200 } 201 201 202 - #ifdef CONFIG_PM 202 + #ifdef CONFIG_PM_SLEEP 203 203 static int pcsp_suspend(struct device *dev) 204 204 { 205 205 struct snd_pcsp *chip = dev_get_drvdata(dev); ··· 212 212 #define PCSP_PM_OPS &pcsp_pm 213 213 #else 214 214 #define PCSP_PM_OPS NULL 215 - #endif /* CONFIG_PM */ 215 + #endif /* CONFIG_PM_SLEEP */ 216 216 217 217 static void pcsp_shutdown(struct platform_device *dev) 218 218 {
+1 -1
sound/isa/als100.c
··· 233 233 irq[dev], dma8[dev], dma16[dev]); 234 234 } 235 235 236 - if ((error = snd_sb16dsp_pcm(chip, 0, NULL)) < 0) { 236 + if ((error = snd_sb16dsp_pcm(chip, 0, &chip->pcm)) < 0) { 237 237 snd_card_free(card); 238 238 return error; 239 239 }
+3 -1
sound/oss/sb_audio.c
··· 575 575 if (speed > 0) 576 576 { 577 577 int tmp; 578 - int s = speed * devc->channels; 578 + int s; 579 579 580 580 if (speed < 5000) 581 581 speed = 5000; 582 582 if (speed > 44100) 583 583 speed = 44100; 584 + 585 + s = speed * devc->channels; 584 586 585 587 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff; 586 588
+1 -1
sound/pci/cs46xx/cs46xx_lib.c
··· 94 94 95 95 if (snd_BUG_ON(codec_index != CS46XX_PRIMARY_CODEC_INDEX && 96 96 codec_index != CS46XX_SECONDARY_CODEC_INDEX)) 97 - return -EINVAL; 97 + return 0xffff; 98 98 99 99 chip->active_ctrl(chip, 1); 100 100
+3 -1
sound/pci/ctxfi/ctatc.c
··· 1725 1725 atc_connect_resources(atc); 1726 1726 1727 1727 atc->timer = ct_timer_new(atc); 1728 - if (!atc->timer) 1728 + if (!atc->timer) { 1729 + err = -ENOMEM; 1729 1730 goto error1; 1731 + } 1730 1732 1731 1733 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, atc, &ops); 1732 1734 if (err < 0)
+23 -6
sound/pci/hda/hda_beep.c
··· 231 231 } 232 232 EXPORT_SYMBOL_HDA(snd_hda_detach_beep_device); 233 233 234 + static bool ctl_has_mute(struct snd_kcontrol *kcontrol) 235 + { 236 + struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 237 + return query_amp_caps(codec, get_amp_nid(kcontrol), 238 + get_amp_direction(kcontrol)) & AC_AMPCAP_MUTE; 239 + } 240 + 234 241 /* get/put callbacks for beep mute mixer switches */ 235 242 int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol, 236 243 struct snd_ctl_elem_value *ucontrol) 237 244 { 238 245 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 239 246 struct hda_beep *beep = codec->beep; 240 - if (beep) { 247 + if (beep && (!beep->enabled || !ctl_has_mute(kcontrol))) { 241 248 ucontrol->value.integer.value[0] = 242 - ucontrol->value.integer.value[1] = 243 - beep->enabled; 249 + ucontrol->value.integer.value[1] = beep->enabled; 244 250 return 0; 245 251 } 246 252 return snd_hda_mixer_amp_switch_get(kcontrol, ucontrol); ··· 258 252 { 259 253 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 260 254 struct hda_beep *beep = codec->beep; 261 - if (beep) 262 - snd_hda_enable_beep_device(codec, 263 - *ucontrol->value.integer.value); 255 + if (beep) { 256 + u8 chs = get_amp_channels(kcontrol); 257 + int enable = 0; 258 + long *valp = ucontrol->value.integer.value; 259 + if (chs & 1) { 260 + enable |= *valp; 261 + valp++; 262 + } 263 + if (chs & 2) 264 + enable |= *valp; 265 + snd_hda_enable_beep_device(codec, enable); 266 + } 267 + if (!ctl_has_mute(kcontrol)) 268 + return 0; 264 269 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 265 270 } 266 271 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
+48 -25
sound/pci/hda/hda_codec.c
··· 1386 1386 } 1387 1387 EXPORT_SYMBOL_HDA(snd_hda_codec_configure); 1388 1388 1389 + /* update the stream-id if changed */ 1390 + static void update_pcm_stream_id(struct hda_codec *codec, 1391 + struct hda_cvt_setup *p, hda_nid_t nid, 1392 + u32 stream_tag, int channel_id) 1393 + { 1394 + unsigned int oldval, newval; 1395 + 1396 + if (p->stream_tag != stream_tag || p->channel_id != channel_id) { 1397 + oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0); 1398 + newval = (stream_tag << 4) | channel_id; 1399 + if (oldval != newval) 1400 + snd_hda_codec_write(codec, nid, 0, 1401 + AC_VERB_SET_CHANNEL_STREAMID, 1402 + newval); 1403 + p->stream_tag = stream_tag; 1404 + p->channel_id = channel_id; 1405 + } 1406 + } 1407 + 1408 + /* update the format-id if changed */ 1409 + static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p, 1410 + hda_nid_t nid, int format) 1411 + { 1412 + unsigned int oldval; 1413 + 1414 + if (p->format_id != format) { 1415 + oldval = snd_hda_codec_read(codec, nid, 0, 1416 + AC_VERB_GET_STREAM_FORMAT, 0); 1417 + if (oldval != format) { 1418 + msleep(1); 1419 + snd_hda_codec_write(codec, nid, 0, 1420 + AC_VERB_SET_STREAM_FORMAT, 1421 + format); 1422 + } 1423 + p->format_id = format; 1424 + } 1425 + } 1426 + 1389 1427 /** 1390 1428 * snd_hda_codec_setup_stream - set up the codec for streaming 1391 1429 * @codec: the CODEC to set up ··· 1438 1400 { 1439 1401 struct hda_codec *c; 1440 1402 struct hda_cvt_setup *p; 1441 - unsigned int oldval, newval; 1442 1403 int type; 1443 1404 int i; 1444 1405 ··· 1450 1413 p = get_hda_cvt_setup(codec, nid); 1451 1414 if (!p) 1452 1415 return; 1453 - /* update the stream-id if changed */ 1454 - if (p->stream_tag != stream_tag || p->channel_id != channel_id) { 1455 - oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0); 1456 - newval = (stream_tag << 4) | channel_id; 1457 - if (oldval != newval) 1458 - snd_hda_codec_write(codec, nid, 0, 1459 - AC_VERB_SET_CHANNEL_STREAMID, 1460 - newval); 1461 - p->stream_tag = stream_tag; 1462 - p->channel_id = channel_id; 1463 - } 1464 - /* update the format-id if changed */ 1465 - if (p->format_id != format) { 1466 - oldval = snd_hda_codec_read(codec, nid, 0, 1467 - AC_VERB_GET_STREAM_FORMAT, 0); 1468 - if (oldval != format) { 1469 - msleep(1); 1470 - snd_hda_codec_write(codec, nid, 0, 1471 - AC_VERB_SET_STREAM_FORMAT, 1472 - format); 1473 - } 1474 - p->format_id = format; 1475 - } 1416 + 1417 + if (codec->pcm_format_first) 1418 + update_pcm_format(codec, p, nid, format); 1419 + update_pcm_stream_id(codec, p, nid, stream_tag, channel_id); 1420 + if (!codec->pcm_format_first) 1421 + update_pcm_format(codec, p, nid, format); 1422 + 1476 1423 p->active = 1; 1477 1424 p->dirty = 0; 1478 1425 ··· 3518 3497 { 3519 3498 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE); 3520 3499 3521 - if (sup < 0) 3500 + if (sup == -1) 3522 3501 return false; 3523 3502 if (sup & power_state) 3524 3503 return true; ··· 4454 4433 * then there is no need to go through power up here. 4455 4434 */ 4456 4435 if (codec->power_on) { 4436 + if (codec->power_transition < 0) 4437 + codec->power_transition = 0; 4457 4438 spin_unlock(&codec->power_lock); 4458 4439 return; 4459 4440 }
+1
sound/pci/hda/hda_codec.h
··· 861 861 unsigned int no_trigger_sense:1; /* don't trigger at pin-sensing */ 862 862 unsigned int ignore_misc_bit:1; /* ignore MISC_NO_PRESENCE bit */ 863 863 unsigned int no_jack_detect:1; /* Machine has no jack-detection */ 864 + unsigned int pcm_format_first:1; /* PCM format must be set first */ 864 865 #ifdef CONFIG_SND_HDA_POWER_SAVE 865 866 unsigned int power_on :1; /* current (global) power-state */ 866 867 int power_transition; /* power-state in transition */
+9
sound/pci/hda/hda_intel.c
··· 151 151 "{Intel, CPT}," 152 152 "{Intel, PPT}," 153 153 "{Intel, LPT}," 154 + "{Intel, LPT_LP}," 154 155 "{Intel, HPT}," 155 156 "{Intel, PBG}," 156 157 "{Intel, SCH}," ··· 3269 3268 AZX_DCAPS_BUFSIZE | AZX_DCAPS_POSFIX_COMBO }, 3270 3269 /* Lynx Point */ 3271 3270 { PCI_DEVICE(0x8086, 0x8c20), 3271 + .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_SCH_SNOOP | 3272 + AZX_DCAPS_BUFSIZE | AZX_DCAPS_POSFIX_COMBO }, 3273 + /* Lynx Point-LP */ 3274 + { PCI_DEVICE(0x8086, 0x9c20), 3275 + .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_SCH_SNOOP | 3276 + AZX_DCAPS_BUFSIZE | AZX_DCAPS_POSFIX_COMBO }, 3277 + /* Lynx Point-LP */ 3278 + { PCI_DEVICE(0x8086, 0x9c21), 3272 3279 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_SCH_SNOOP | 3273 3280 AZX_DCAPS_BUFSIZE | AZX_DCAPS_POSFIX_COMBO }, 3274 3281 /* Haswell */
+1 -1
sound/pci/hda/hda_proc.c
··· 412 412 if (digi1 & AC_DIG1_EMPHASIS) 413 413 snd_iprintf(buffer, " Preemphasis"); 414 414 if (digi1 & AC_DIG1_COPYRIGHT) 415 - snd_iprintf(buffer, " Copyright"); 415 + snd_iprintf(buffer, " Non-Copyright"); 416 416 if (digi1 & AC_DIG1_NONAUDIO) 417 417 snd_iprintf(buffer, " Non-Audio"); 418 418 if (digi1 & AC_DIG1_PROFESSIONAL)
+57 -125
sound/pci/hda/patch_ca0132.c
··· 246 246 AC_VERB_SET_AMP_GAIN_MUTE, 247 247 AMP_OUT_UNMUTE); 248 248 } 249 - if (dac) 249 + if (dac && (get_wcaps(codec, dac) & AC_WCAP_OUT_AMP)) 250 250 snd_hda_codec_write(codec, dac, 0, 251 251 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO); 252 252 } ··· 261 261 AC_VERB_SET_AMP_GAIN_MUTE, 262 262 AMP_IN_UNMUTE(0)); 263 263 } 264 - if (adc) 264 + if (adc && (get_wcaps(codec, adc) & AC_WCAP_IN_AMP)) 265 265 snd_hda_codec_write(codec, adc, 0, AC_VERB_SET_AMP_GAIN_MUTE, 266 266 AMP_IN_UNMUTE(0)); 267 267 } ··· 275 275 int type = dir ? HDA_INPUT : HDA_OUTPUT; 276 276 struct snd_kcontrol_new knew = 277 277 HDA_CODEC_MUTE_MONO(namestr, nid, chan, 0, type); 278 + if ((query_amp_caps(codec, nid, type) & AC_AMPCAP_MUTE) == 0) { 279 + snd_printdd("Skipping '%s %s Switch' (no mute on node 0x%x)\n", pfx, dirstr[dir], nid); 280 + return 0; 281 + } 278 282 sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]); 279 283 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 280 284 } ··· 290 286 int type = dir ? HDA_INPUT : HDA_OUTPUT; 291 287 struct snd_kcontrol_new knew = 292 288 HDA_CODEC_VOLUME_MONO(namestr, nid, chan, 0, type); 289 + if ((query_amp_caps(codec, nid, type) & AC_AMPCAP_NUM_STEPS) == 0) { 290 + snd_printdd("Skipping '%s %s Volume' (no amp on node 0x%x)\n", pfx, dirstr[dir], nid); 291 + return 0; 292 + } 293 293 sprintf(namestr, "%s %s Volume", pfx, dirstr[dir]); 294 294 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 295 295 } ··· 472 464 } 473 465 474 466 /* 475 - * PCM stuffs 476 - */ 477 - static void ca0132_setup_stream(struct hda_codec *codec, hda_nid_t nid, 478 - u32 stream_tag, 479 - int channel_id, int format) 480 - { 481 - unsigned int oldval, newval; 482 - 483 - if (!nid) 484 - return; 485 - 486 - snd_printdd("ca0132_setup_stream: " 487 - "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n", 488 - nid, stream_tag, channel_id, format); 489 - 490 - /* update the format-id if changed */ 491 - oldval = snd_hda_codec_read(codec, nid, 0, 492 - AC_VERB_GET_STREAM_FORMAT, 493 - 0); 494 - if (oldval != format) { 495 - msleep(20); 496 - snd_hda_codec_write(codec, nid, 0, 497 - AC_VERB_SET_STREAM_FORMAT, 498 - format); 499 - } 500 - 501 - oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0); 502 - newval = (stream_tag << 4) | channel_id; 503 - if (oldval != newval) { 504 - snd_hda_codec_write(codec, nid, 0, 505 - AC_VERB_SET_CHANNEL_STREAMID, 506 - newval); 507 - } 508 - } 509 - 510 - static void ca0132_cleanup_stream(struct hda_codec *codec, hda_nid_t nid) 511 - { 512 - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0); 513 - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0); 514 - } 515 - 516 - /* 517 467 * PCM callbacks 518 468 */ 469 + static int ca0132_playback_pcm_open(struct hda_pcm_stream *hinfo, 470 + struct hda_codec *codec, 471 + struct snd_pcm_substream *substream) 472 + { 473 + struct ca0132_spec *spec = codec->spec; 474 + return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 475 + hinfo); 476 + } 477 + 519 478 static int ca0132_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 520 479 struct hda_codec *codec, 521 480 unsigned int stream_tag, ··· 490 515 struct snd_pcm_substream *substream) 491 516 { 492 517 struct ca0132_spec *spec = codec->spec; 493 - 494 - ca0132_setup_stream(codec, spec->dacs[0], stream_tag, 0, format); 495 - 496 - return 0; 518 + return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 519 + stream_tag, format, substream); 497 520 } 498 521 499 522 static int ca0132_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, ··· 499 526 struct snd_pcm_substream *substream) 500 527 { 501 528 struct ca0132_spec *spec = codec->spec; 502 - 503 - ca0132_cleanup_stream(codec, spec->dacs[0]); 504 - 505 - return 0; 529 + return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 506 530 } 507 531 508 532 /* 509 533 * Digital out 510 534 */ 535 + static int ca0132_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 536 + struct hda_codec *codec, 537 + struct snd_pcm_substream *substream) 538 + { 539 + struct ca0132_spec *spec = codec->spec; 540 + return snd_hda_multi_out_dig_open(codec, &spec->multiout); 541 + } 542 + 511 543 static int ca0132_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 512 544 struct hda_codec *codec, 513 545 unsigned int stream_tag, ··· 520 542 struct snd_pcm_substream *substream) 521 543 { 522 544 struct ca0132_spec *spec = codec->spec; 523 - 524 - ca0132_setup_stream(codec, spec->dig_out, stream_tag, 0, format); 525 - 526 - return 0; 545 + return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 546 + stream_tag, format, substream); 527 547 } 528 548 529 549 static int ca0132_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, ··· 529 553 struct snd_pcm_substream *substream) 530 554 { 531 555 struct ca0132_spec *spec = codec->spec; 532 - 533 - ca0132_cleanup_stream(codec, spec->dig_out); 534 - 535 - return 0; 556 + return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 536 557 } 537 558 538 - /* 539 - * Analog capture 540 - */ 541 - static int ca0132_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 542 - struct hda_codec *codec, 543 - unsigned int stream_tag, 544 - unsigned int format, 545 - struct snd_pcm_substream *substream) 559 + static int ca0132_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 560 + struct hda_codec *codec, 561 + struct snd_pcm_substream *substream) 546 562 { 547 563 struct ca0132_spec *spec = codec->spec; 548 - 549 - ca0132_setup_stream(codec, spec->adcs[substream->number], 550 - stream_tag, 0, format); 551 - 552 - return 0; 553 - } 554 - 555 - static int ca0132_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 556 - struct hda_codec *codec, 557 - struct snd_pcm_substream *substream) 558 - { 559 - struct ca0132_spec *spec = codec->spec; 560 - 561 - ca0132_cleanup_stream(codec, spec->adcs[substream->number]); 562 - 563 - return 0; 564 - } 565 - 566 - /* 567 - * Digital capture 568 - */ 569 - static int ca0132_dig_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 570 - struct hda_codec *codec, 571 - unsigned int stream_tag, 572 - unsigned int format, 573 - struct snd_pcm_substream *substream) 574 - { 575 - struct ca0132_spec *spec = codec->spec; 576 - 577 - ca0132_setup_stream(codec, spec->dig_in, stream_tag, 0, format); 578 - 579 - return 0; 580 - } 581 - 582 - static int ca0132_dig_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 583 - struct hda_codec *codec, 584 - struct snd_pcm_substream *substream) 585 - { 586 - struct ca0132_spec *spec = codec->spec; 587 - 588 - ca0132_cleanup_stream(codec, spec->dig_in); 589 - 590 - return 0; 564 + return snd_hda_multi_out_dig_close(codec, &spec->multiout); 591 565 } 592 566 593 567 /* ··· 547 621 .channels_min = 2, 548 622 .channels_max = 2, 549 623 .ops = { 624 + .open = ca0132_playback_pcm_open, 550 625 .prepare = ca0132_playback_pcm_prepare, 551 626 .cleanup = ca0132_playback_pcm_cleanup 552 627 }, ··· 557 630 .substreams = 1, 558 631 .channels_min = 2, 559 632 .channels_max = 2, 560 - .ops = { 561 - .prepare = ca0132_capture_pcm_prepare, 562 - .cleanup = ca0132_capture_pcm_cleanup 563 - }, 564 633 }; 565 634 566 635 static struct hda_pcm_stream ca0132_pcm_digital_playback = { ··· 564 641 .channels_min = 2, 565 642 .channels_max = 2, 566 643 .ops = { 644 + .open = ca0132_dig_playback_pcm_open, 645 + .close = ca0132_dig_playback_pcm_close, 567 646 .prepare = ca0132_dig_playback_pcm_prepare, 568 647 .cleanup = ca0132_dig_playback_pcm_cleanup 569 648 }, ··· 575 650 .substreams = 1, 576 651 .channels_min = 2, 577 652 .channels_max = 2, 578 - .ops = { 579 - .prepare = ca0132_dig_capture_pcm_prepare, 580 - .cleanup = ca0132_dig_capture_pcm_cleanup 581 - }, 582 653 }; 583 654 584 655 static int ca0132_build_pcms(struct hda_codec *codec) ··· 849 928 spec->dig_out); 850 929 if (err < 0) 851 930 return err; 852 - err = add_out_volume(codec, spec->dig_out, "IEC958"); 931 + err = snd_hda_create_spdif_share_sw(codec, &spec->multiout); 853 932 if (err < 0) 854 933 return err; 934 + /* spec->multiout.share_spdif = 1; */ 855 935 } 856 936 857 937 if (spec->dig_in) { 858 938 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in); 859 - if (err < 0) 860 - return err; 861 - err = add_in_volume(codec, spec->dig_in, "IEC958"); 862 939 if (err < 0) 863 940 return err; 864 941 } ··· 879 960 { 880 961 struct ca0132_spec *spec = codec->spec; 881 962 struct auto_pin_cfg *cfg = &spec->autocfg; 963 + 964 + codec->pcm_format_first = 1; 965 + codec->no_sticky_stream = 1; 882 966 883 967 /* line-outs */ 884 968 cfg->line_outs = 1; ··· 910 988 911 989 /* Mic-in */ 912 990 spec->input_pins[0] = 0x12; 913 - spec->input_labels[0] = "Mic-In"; 991 + spec->input_labels[0] = "Mic"; 914 992 spec->adcs[0] = 0x07; 915 993 916 994 /* Line-In */ 917 995 spec->input_pins[1] = 0x11; 918 - spec->input_labels[1] = "Line-In"; 996 + spec->input_labels[1] = "Line"; 919 997 spec->adcs[1] = 0x08; 920 998 spec->num_inputs = 2; 999 + 1000 + /* SPDIF I/O */ 1001 + spec->dig_out = 0x05; 1002 + spec->multiout.dig_out_nid = spec->dig_out; 1003 + cfg->dig_out_pins[0] = 0x0c; 1004 + cfg->dig_outs = 1; 1005 + cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF; 1006 + spec->dig_in = 0x09; 1007 + cfg->dig_in_pin = 0x0e; 1008 + cfg->dig_in_type = HDA_PCM_TYPE_SPDIF; 921 1009 } 922 1010 923 1011 static void ca0132_init_chip(struct hda_codec *codec)
+5 -4
sound/pci/hda/patch_sigmatel.c
··· 4272 4272 unsigned int gpio; 4273 4273 int i; 4274 4274 4275 - snd_hda_sequence_write(codec, spec->init); 4275 + if (spec->init) 4276 + snd_hda_sequence_write(codec, spec->init); 4276 4277 4277 4278 /* power down adcs initially */ 4278 4279 if (spec->powerdown_adcs) ··· 5749 5748 /* fallthru */ 5750 5749 case 0x111d76b4: /* 6 Port without Analog Mixer */ 5751 5750 case 0x111d76b5: 5752 - spec->init = stac92hd71bxx_core_init; 5753 5751 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; 5754 5752 spec->num_dmics = stac92xx_connected_ports(codec, 5755 5753 stac92hd71bxx_dmic_nids, ··· 5773 5773 spec->stream_delay = 40; /* 40 milliseconds */ 5774 5774 5775 5775 /* disable VSW */ 5776 - spec->init = stac92hd71bxx_core_init; 5777 5776 unmute_init++; 5778 5777 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0); 5779 5778 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3); ··· 5787 5788 5788 5789 /* fallthru */ 5789 5790 default: 5790 - spec->init = stac92hd71bxx_core_init; 5791 5791 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; 5792 5792 spec->num_dmics = stac92xx_connected_ports(codec, 5793 5793 stac92hd71bxx_dmic_nids, 5794 5794 STAC92HD71BXX_NUM_DMICS); 5795 5795 break; 5796 5796 } 5797 + 5798 + if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB) 5799 + spec->init = stac92hd71bxx_core_init; 5797 5800 5798 5801 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP) 5799 5802 snd_hda_sequence_write_cache(codec, unmute_init);
+8
sound/pci/hda/patch_via.c
··· 1752 1752 { 1753 1753 struct via_spec *spec = codec->spec; 1754 1754 vt1708_stop_hp_work(spec); 1755 + 1756 + if (spec->codec_type == VT1802) { 1757 + /* Fix pop noise on headphones */ 1758 + int i; 1759 + for (i = 0; i < spec->autocfg.hp_outs; i++) 1760 + snd_hda_set_pin_ctl(codec, spec->autocfg.hp_pins[i], 0); 1761 + } 1762 + 1755 1763 return 0; 1756 1764 } 1757 1765 #endif
+2
sound/pci/lx6464es/lx6464es.c
··· 851 851 /* hardcoded device name & channel count */ 852 852 err = snd_pcm_new(chip->card, (char *)card_name, 0, 853 853 1, 1, &pcm); 854 + if (err < 0) 855 + return err; 854 856 855 857 pcm->private_data = chip; 856 858
+1 -1
sound/pci/rme9652/hdspm.c
··· 6585 6585 snd_printk(KERN_ERR "HDSPM: " 6586 6586 "unable to kmalloc Mixer memory of %d Bytes\n", 6587 6587 (int)sizeof(struct hdspm_mixer)); 6588 - return err; 6588 + return -ENOMEM; 6589 6589 } 6590 6590 6591 6591 hdspm->port_names_in = NULL;
+3 -2
sound/pci/sis7019.c
··· 1377 1377 if (rc) 1378 1378 goto error_out_cleanup; 1379 1379 1380 - if (request_irq(pci->irq, sis_interrupt, IRQF_SHARED, KBUILD_MODNAME, 1381 - sis)) { 1380 + rc = request_irq(pci->irq, sis_interrupt, IRQF_SHARED, KBUILD_MODNAME, 1381 + sis); 1382 + if (rc) { 1382 1383 dev_err(&pci->dev, "unable to allocate irq %d\n", sis->irq); 1383 1384 goto error_out_cleanup; 1384 1385 }
+1 -1
sound/ppc/powermac.c
··· 143 143 return 0; 144 144 } 145 145 146 - #ifdef CONFIG_PM 146 + #ifdef CONFIG_PM_SLEEP 147 147 static int snd_pmac_driver_suspend(struct device *dev) 148 148 { 149 149 struct snd_card *card = dev_get_drvdata(dev);
+1
sound/ppc/snd_ps3.c
··· 1040 1040 GFP_KERNEL); 1041 1041 if (!the_card.null_buffer_start_vaddr) { 1042 1042 pr_info("%s: nullbuffer alloc failed\n", __func__); 1043 + ret = -ENOMEM; 1043 1044 goto clean_preallocate; 1044 1045 } 1045 1046 pr_debug("%s: null vaddr=%p dma=%#llx\n", __func__,
+7
sound/soc/blackfin/bf6xx-sport.c
··· 413 413 414 414 void sport_delete(struct sport_device *sport) 415 415 { 416 + if (sport->tx_desc) 417 + dma_free_coherent(NULL, sport->tx_desc_size, 418 + sport->tx_desc, 0); 419 + if (sport->rx_desc) 420 + dma_free_coherent(NULL, sport->rx_desc_size, 421 + sport->rx_desc, 0); 416 422 sport_free_resource(sport); 423 + kfree(sport); 417 424 } 418 425 EXPORT_SYMBOL(sport_delete); 419 426
+9 -16
sound/soc/codecs/wm5102.c
··· 128 128 129 129 ARIZONA_MIXER_CONTROLS("DRC1L", ARIZONA_DRC1LMIX_INPUT_1_SOURCE), 130 130 ARIZONA_MIXER_CONTROLS("DRC1R", ARIZONA_DRC1RMIX_INPUT_1_SOURCE), 131 - ARIZONA_MIXER_CONTROLS("DRC2L", ARIZONA_DRC2LMIX_INPUT_1_SOURCE), 132 - ARIZONA_MIXER_CONTROLS("DRC2R", ARIZONA_DRC2RMIX_INPUT_1_SOURCE), 133 131 134 132 SND_SOC_BYTES_MASK("DRC1", ARIZONA_DRC1_CTRL1, 5, 135 133 ARIZONA_DRC1R_ENA | ARIZONA_DRC1L_ENA), 136 - SND_SOC_BYTES_MASK("DRC2", ARIZONA_DRC2_CTRL1, 5, 137 - ARIZONA_DRC2R_ENA | ARIZONA_DRC2L_ENA), 138 134 139 135 ARIZONA_MIXER_CONTROLS("LHPF1", ARIZONA_HPLP1MIX_INPUT_1_SOURCE), 140 136 ARIZONA_MIXER_CONTROLS("LHPF2", ARIZONA_HPLP2MIX_INPUT_1_SOURCE), ··· 232 236 233 237 ARIZONA_MIXER_ENUMS(DRC1L, ARIZONA_DRC1LMIX_INPUT_1_SOURCE); 234 238 ARIZONA_MIXER_ENUMS(DRC1R, ARIZONA_DRC1RMIX_INPUT_1_SOURCE); 235 - ARIZONA_MIXER_ENUMS(DRC2L, ARIZONA_DRC2LMIX_INPUT_1_SOURCE); 236 - ARIZONA_MIXER_ENUMS(DRC2R, ARIZONA_DRC2RMIX_INPUT_1_SOURCE); 237 239 238 240 ARIZONA_MIXER_ENUMS(LHPF1, ARIZONA_HPLP1MIX_INPUT_1_SOURCE); 239 241 ARIZONA_MIXER_ENUMS(LHPF2, ARIZONA_HPLP2MIX_INPUT_1_SOURCE); ··· 342 348 SND_SOC_DAPM_PGA("DRC1L", ARIZONA_DRC1_CTRL1, ARIZONA_DRC1L_ENA_SHIFT, 0, 343 349 NULL, 0), 344 350 SND_SOC_DAPM_PGA("DRC1R", ARIZONA_DRC1_CTRL1, ARIZONA_DRC1R_ENA_SHIFT, 0, 345 - NULL, 0), 346 - SND_SOC_DAPM_PGA("DRC2L", ARIZONA_DRC2_CTRL1, ARIZONA_DRC2L_ENA_SHIFT, 0, 347 - NULL, 0), 348 - SND_SOC_DAPM_PGA("DRC2R", ARIZONA_DRC2_CTRL1, ARIZONA_DRC2R_ENA_SHIFT, 0, 349 351 NULL, 0), 350 352 351 353 SND_SOC_DAPM_PGA("LHPF1", ARIZONA_HPLPF1_1, ARIZONA_LHPF1_ENA_SHIFT, 0, ··· 456 466 457 467 ARIZONA_MIXER_WIDGETS(DRC1L, "DRC1L"), 458 468 ARIZONA_MIXER_WIDGETS(DRC1R, "DRC1R"), 459 - ARIZONA_MIXER_WIDGETS(DRC2L, "DRC2L"), 460 - ARIZONA_MIXER_WIDGETS(DRC2R, "DRC2R"), 461 469 462 470 ARIZONA_MIXER_WIDGETS(LHPF1, "LHPF1"), 463 471 ARIZONA_MIXER_WIDGETS(LHPF2, "LHPF2"), ··· 541 553 { name, "EQ4", "EQ4" }, \ 542 554 { name, "DRC1L", "DRC1L" }, \ 543 555 { name, "DRC1R", "DRC1R" }, \ 544 - { name, "DRC2L", "DRC2L" }, \ 545 - { name, "DRC2R", "DRC2R" }, \ 546 556 { name, "LHPF1", "LHPF1" }, \ 547 557 { name, "LHPF2", "LHPF2" }, \ 548 558 { name, "LHPF3", "LHPF3" }, \ ··· 625 639 { "AIF2 Capture", NULL, "SYSCLK" }, 626 640 { "AIF3 Capture", NULL, "SYSCLK" }, 627 641 642 + { "IN1L PGA", NULL, "IN1L" }, 643 + { "IN1R PGA", NULL, "IN1R" }, 644 + 645 + { "IN2L PGA", NULL, "IN2L" }, 646 + { "IN2R PGA", NULL, "IN2R" }, 647 + 648 + { "IN3L PGA", NULL, "IN3L" }, 649 + { "IN3R PGA", NULL, "IN3R" }, 650 + 628 651 ARIZONA_MIXER_ROUTES("OUT1L", "HPOUT1L"), 629 652 ARIZONA_MIXER_ROUTES("OUT1R", "HPOUT1R"), 630 653 ARIZONA_MIXER_ROUTES("OUT2L", "HPOUT2L"), ··· 670 675 671 676 ARIZONA_MIXER_ROUTES("DRC1L", "DRC1L"), 672 677 ARIZONA_MIXER_ROUTES("DRC1R", "DRC1R"), 673 - ARIZONA_MIXER_ROUTES("DRC2L", "DRC2L"), 674 - ARIZONA_MIXER_ROUTES("DRC2R", "DRC2R"), 675 678 676 679 ARIZONA_MIXER_ROUTES("LHPF1", "LHPF1"), 677 680 ARIZONA_MIXER_ROUTES("LHPF2", "LHPF2"),
+12
sound/soc/codecs/wm5110.c
··· 681 681 { "AIF2 Capture", NULL, "SYSCLK" }, 682 682 { "AIF3 Capture", NULL, "SYSCLK" }, 683 683 684 + { "IN1L PGA", NULL, "IN1L" }, 685 + { "IN1R PGA", NULL, "IN1R" }, 686 + 687 + { "IN2L PGA", NULL, "IN2L" }, 688 + { "IN2R PGA", NULL, "IN2R" }, 689 + 690 + { "IN3L PGA", NULL, "IN3L" }, 691 + { "IN3R PGA", NULL, "IN3R" }, 692 + 693 + { "IN4L PGA", NULL, "IN4L" }, 694 + { "IN4R PGA", NULL, "IN4R" }, 695 + 684 696 ARIZONA_MIXER_ROUTES("OUT1L", "HPOUT1L"), 685 697 ARIZONA_MIXER_ROUTES("OUT1R", "HPOUT1R"), 686 698 ARIZONA_MIXER_ROUTES("OUT2L", "HPOUT2L"),
-15
sound/soc/codecs/wm8962.c
··· 3733 3733 3734 3734 regcache_sync(wm8962->regmap); 3735 3735 3736 - regmap_update_bits(wm8962->regmap, WM8962_ANTI_POP, 3737 - WM8962_STARTUP_BIAS_ENA | WM8962_VMID_BUF_ENA, 3738 - WM8962_STARTUP_BIAS_ENA | WM8962_VMID_BUF_ENA); 3739 - 3740 - /* Bias enable at 2*50k for ramp */ 3741 - regmap_update_bits(wm8962->regmap, WM8962_PWR_MGMT_1, 3742 - WM8962_VMID_SEL_MASK | WM8962_BIAS_ENA, 3743 - WM8962_BIAS_ENA | 0x180); 3744 - 3745 - msleep(5); 3746 - 3747 - /* VMID back to 2x250k for standby */ 3748 - regmap_update_bits(wm8962->regmap, WM8962_PWR_MGMT_1, 3749 - WM8962_VMID_SEL_MASK, 0x100); 3750 - 3751 3736 return 0; 3752 3737 } 3753 3738
+2
sound/soc/codecs/wm8994.c
··· 4038 4038 break; 4039 4039 case WM8958: 4040 4040 if (wm8994->revision < 1) { 4041 + snd_soc_dapm_add_routes(dapm, wm8994_intercon, 4042 + ARRAY_SIZE(wm8994_intercon)); 4041 4043 snd_soc_dapm_add_routes(dapm, wm8994_revd_intercon, 4042 4044 ARRAY_SIZE(wm8994_revd_intercon)); 4043 4045 snd_soc_dapm_add_routes(dapm, wm8994_lateclk_revd_intercon,
+18 -3
sound/soc/codecs/wm9712.c
··· 148 148 149 149 SOC_SINGLE("Capture ADC Switch", AC97_REC_GAIN, 15, 1, 1), 150 150 SOC_ENUM("Capture Volume Steps", wm9712_enum[6]), 151 - SOC_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 63, 1), 151 + SOC_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 63, 0), 152 152 SOC_SINGLE("Capture ZC Switch", AC97_REC_GAIN, 7, 1, 0), 153 153 154 154 SOC_SINGLE_TLV("Mic 1 Volume", AC97_MIC, 8, 31, 1, main_tlv), ··· 272 272 273 273 /* Mic select */ 274 274 static const struct snd_kcontrol_new wm9712_mic_src_controls = 275 - SOC_DAPM_ENUM("Route", wm9712_enum[7]); 275 + SOC_DAPM_ENUM("Mic Source Select", wm9712_enum[7]); 276 276 277 277 /* diff select */ 278 278 static const struct snd_kcontrol_new wm9712_diff_sel_controls = ··· 291 291 &wm9712_capture_selectl_controls), 292 292 SND_SOC_DAPM_MUX("Right Capture Select", SND_SOC_NOPM, 0, 0, 293 293 &wm9712_capture_selectr_controls), 294 - SND_SOC_DAPM_MUX("Mic Select Source", SND_SOC_NOPM, 0, 0, 294 + SND_SOC_DAPM_MUX("Left Mic Select Source", SND_SOC_NOPM, 0, 0, 295 + &wm9712_mic_src_controls), 296 + SND_SOC_DAPM_MUX("Right Mic Select Source", SND_SOC_NOPM, 0, 0, 295 297 &wm9712_mic_src_controls), 296 298 SND_SOC_DAPM_MUX("Differential Source", SND_SOC_NOPM, 0, 0, 297 299 &wm9712_diff_sel_controls), ··· 321 319 SND_SOC_DAPM_PGA("Line PGA", AC97_INT_PAGING, 2, 1, NULL, 0), 322 320 SND_SOC_DAPM_PGA("Phone PGA", AC97_INT_PAGING, 1, 1, NULL, 0), 323 321 SND_SOC_DAPM_PGA("Mic PGA", AC97_INT_PAGING, 0, 1, NULL, 0), 322 + SND_SOC_DAPM_PGA("Differential Mic", SND_SOC_NOPM, 0, 0, NULL, 0), 324 323 SND_SOC_DAPM_MICBIAS("Mic Bias", AC97_INT_PAGING, 10, 1), 325 324 SND_SOC_DAPM_OUTPUT("MONOOUT"), 326 325 SND_SOC_DAPM_OUTPUT("HPOUTL"), ··· 381 378 {"Phone PGA", NULL, "PHONE"}, 382 379 {"Mic PGA", NULL, "MIC1"}, 383 380 {"Mic PGA", NULL, "MIC2"}, 381 + 382 + /* microphones */ 383 + {"Differential Mic", NULL, "MIC1"}, 384 + {"Differential Mic", NULL, "MIC2"}, 385 + {"Left Mic Select Source", "Mic 1", "MIC1"}, 386 + {"Left Mic Select Source", "Mic 2", "MIC2"}, 387 + {"Left Mic Select Source", "Stereo", "MIC1"}, 388 + {"Left Mic Select Source", "Differential", "Differential Mic"}, 389 + {"Right Mic Select Source", "Mic 1", "MIC1"}, 390 + {"Right Mic Select Source", "Mic 2", "MIC2"}, 391 + {"Right Mic Select Source", "Stereo", "MIC2"}, 392 + {"Right Mic Select Source", "Differential", "Differential Mic"}, 384 393 385 394 /* left capture selector */ 386 395 {"Left Capture Select", "Mic", "MIC1"},
+8 -2
sound/soc/davinci/davinci-mcasp.c
··· 380 380 static void davinci_mcasp_start(struct davinci_audio_dev *dev, int stream) 381 381 { 382 382 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 383 - if (dev->txnumevt) /* enable FIFO */ 383 + if (dev->txnumevt) { /* enable FIFO */ 384 + mcasp_clr_bits(dev->base + DAVINCI_MCASP_WFIFOCTL, 385 + FIFO_ENABLE); 384 386 mcasp_set_bits(dev->base + DAVINCI_MCASP_WFIFOCTL, 385 387 FIFO_ENABLE); 388 + } 386 389 mcasp_start_tx(dev); 387 390 } else { 388 - if (dev->rxnumevt) /* enable FIFO */ 391 + if (dev->rxnumevt) { /* enable FIFO */ 392 + mcasp_clr_bits(dev->base + DAVINCI_MCASP_RFIFOCTL, 393 + FIFO_ENABLE); 389 394 mcasp_set_bits(dev->base + DAVINCI_MCASP_RFIFOCTL, 390 395 FIFO_ENABLE); 396 + } 391 397 mcasp_start_rx(dev); 392 398 } 393 399 }
+3 -2
sound/soc/fsl/imx-ssi.c
··· 380 380 static struct snd_soc_dai_driver imx_ssi_dai = { 381 381 .probe = imx_ssi_dai_probe, 382 382 .playback = { 383 - .channels_min = 1, 383 + /* The SSI does not support monaural audio. */ 384 + .channels_min = 2, 384 385 .channels_max = 2, 385 386 .rates = SNDRV_PCM_RATE_8000_96000, 386 387 .formats = SNDRV_PCM_FMTBIT_S16_LE, 387 388 }, 388 389 .capture = { 389 - .channels_min = 1, 390 + .channels_min = 2, 390 391 .channels_max = 2, 391 392 .rates = SNDRV_PCM_RATE_8000_96000, 392 393 .formats = SNDRV_PCM_FMTBIT_S16_LE,
+1 -1
sound/soc/mxs/Kconfig
··· 10 10 if SND_MXS_SOC 11 11 12 12 config SND_SOC_MXS_SGTL5000 13 - tristate "SoC Audio support for i.MX boards with sgtl5000" 13 + tristate "SoC Audio support for MXS boards with sgtl5000" 14 14 depends on I2C 15 15 select SND_SOC_SGTL5000 16 16 help
+1 -1
sound/soc/omap/mcbsp.c
··· 745 745 { 746 746 const char *signal, *src; 747 747 748 - if (mcbsp->pdata->mux_signal) 748 + if (!mcbsp->pdata->mux_signal) 749 749 return -EINVAL; 750 750 751 751 switch (mux) {
+1 -1
sound/soc/samsung/pcm.c
··· 20 20 #include <sound/pcm_params.h> 21 21 22 22 #include <plat/audio.h> 23 - #include <plat/dma.h> 23 + #include <mach/dma.h> 24 24 25 25 #include "dma.h" 26 26 #include "pcm.h"
+6 -4
sound/soc/soc-core.c
··· 826 826 } 827 827 828 828 if (!rtd->cpu_dai) { 829 - dev_dbg(card->dev, "CPU DAI %s not registered\n", 829 + dev_err(card->dev, "CPU DAI %s not registered\n", 830 830 dai_link->cpu_dai_name); 831 831 return -EPROBE_DEFER; 832 832 } ··· 857 857 } 858 858 859 859 if (!rtd->codec_dai) { 860 - dev_dbg(card->dev, "CODEC DAI %s not registered\n", 860 + dev_err(card->dev, "CODEC DAI %s not registered\n", 861 861 dai_link->codec_dai_name); 862 862 return -EPROBE_DEFER; 863 863 } 864 864 } 865 865 866 866 if (!rtd->codec) { 867 - dev_dbg(card->dev, "CODEC %s not registered\n", 867 + dev_err(card->dev, "CODEC %s not registered\n", 868 868 dai_link->codec_name); 869 869 return -EPROBE_DEFER; 870 870 } ··· 888 888 rtd->platform = platform; 889 889 } 890 890 if (!rtd->platform) { 891 - dev_dbg(card->dev, "platform %s not registered\n", 891 + dev_err(card->dev, "platform %s not registered\n", 892 892 dai_link->platform_name); 893 893 return -EPROBE_DEFER; 894 894 } ··· 1480 1480 if (!strcmp(codec->name, aux_dev->codec_name)) 1481 1481 return 0; 1482 1482 } 1483 + 1484 + dev_err(card->dev, "%s not registered\n", aux_dev->codec_name); 1483 1485 1484 1486 return -EPROBE_DEFER; 1485 1487 }
+1 -1
sound/soc/soc-jack.c
··· 103 103 } 104 104 105 105 /* Report before the DAPM sync to help users updating micbias status */ 106 - blocking_notifier_call_chain(&jack->notifier, status, jack); 106 + blocking_notifier_call_chain(&jack->notifier, jack->status, jack); 107 107 108 108 snd_soc_dapm_sync(dapm); 109 109
-4
sound/usb/endpoint.c
··· 821 821 if (++ep->use_count != 1) 822 822 return 0; 823 823 824 - /* just to be sure */ 825 - deactivate_urbs(ep, 0, 1); 826 - wait_clear_urbs(ep); 827 - 828 824 ep->active_mask = 0; 829 825 ep->unlink_mask = 0; 830 826 ep->phase = 0;
+3
sound/usb/pcm.c
··· 544 544 subs->last_frame_number = 0; 545 545 runtime->delay = 0; 546 546 547 + /* clear the pending deactivation on the target EPs */ 548 + deactivate_endpoints(subs); 549 + 547 550 /* for playback, submit the URBs now; otherwise, the first hwptr_done 548 551 * updates for all URBs would happen at the same time when starting */ 549 552 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK)