Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'sound-3.5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
Pull sound fixes from Takashi Iwai:
- Fix a regression of USB-audio PCM assignment since 3.4
- A few VGA-switcheroo-related fixes for proper HDMI audio enablement
- Fixed the missing initializations of HD-audio verbs, which may have
resulted in various breakage
- Some driver-specific ASoC updates
- A few fixes for the dynamic PCM code
- The addition of pinctrl support for the i.MX audmux which didn't make
it into -rc1 due to cross tree dependency issues
- A few minor fixes in compress API codes
* tag 'sound-3.5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound:
ALSA: hda - Don't forget to call init verbs added by fixup list
ALSA: HDA: Pin fixup for Zotac Z68 motherboard
ALSA: compress_core: cleanup pointers on stop
ALSA: compress_core: don't wake up on pause
ALSA: hda - Fix detection of Creative SoundCore3D controllers
vga_switcheroo: Enable/disable audio clients at the right time
ALSA: hda - HDMI Audio init all connectors when VGA-switcheroo is off
vga_switcheroo: Fix error without CONFIG_VGA_SWITCHEROO
ALSA: hda - Fix uninitialized HDMI controllers with VGA-switcheroo
vga_switcheroo: Add a helper function to get the client state
ALSA: usb-audio: Fix substream assignments
ASoC: tegra: add MODULE_DEVICE_TABLE to tegra30_ahub
ASoC: wm2000: Always use a 4s timeout for the firmware
ASoC: dapm: Fix input list to use source widgets
ASoC: dpcm: Fix dpcm_get_be() to check that DAI is BE
ASoC: wm8994: Apply volume updates with clocks enabled
ASoC: wm8994: Ensure all AIFnCLK events are run from the _late variants
ASoC: imx-audmux: add pinctrl support
ASoC: dapm: Fix connected widget capture path query.
+162
-100
+21
-6
drivers/gpu/vga/vga_switcheroo.c
+21
-6
drivers/gpu/vga/vga_switcheroo.c
···
190
190
return NULL;
191
191
}
192
192
193
+
int vga_switcheroo_get_client_state(struct pci_dev *pdev)
194
+
{
195
+
struct vga_switcheroo_client *client;
196
+
197
+
client = find_client_from_pci(&vgasr_priv.clients, pdev);
198
+
if (!client)
199
+
return VGA_SWITCHEROO_NOT_FOUND;
200
+
if (!vgasr_priv.active)
201
+
return VGA_SWITCHEROO_INIT;
202
+
return client->pwr_state;
203
+
}
204
+
EXPORT_SYMBOL(vga_switcheroo_get_client_state);
205
+
193
206
void vga_switcheroo_unregister_client(struct pci_dev *pdev)
194
207
{
195
208
struct vga_switcheroo_client *client;
···
304
291
vga_switchon(new_client);
305
292
306
293
vga_set_default_device(new_client->pdev);
307
-
set_audio_state(new_client->id, VGA_SWITCHEROO_ON);
308
-
309
294
return 0;
310
295
}
311
296
···
319
308
320
309
active->active = false;
321
310
311
+
set_audio_state(active->id, VGA_SWITCHEROO_OFF);
312
+
322
313
if (new_client->fb_info) {
323
314
struct fb_event event;
324
315
event.info = new_client->fb_info;
···
334
321
if (new_client->ops->reprobe)
335
322
new_client->ops->reprobe(new_client->pdev);
336
323
337
-
set_audio_state(active->id, VGA_SWITCHEROO_OFF);
338
-
339
324
if (active->pwr_state == VGA_SWITCHEROO_ON)
340
325
vga_switchoff(active);
326
+
327
+
set_audio_state(new_client->id, VGA_SWITCHEROO_ON);
341
328
342
329
new_client->active = true;
343
330
return 0;
···
384
371
/* pwr off the device not in use */
385
372
if (strncmp(usercmd, "OFF", 3) == 0) {
386
373
list_for_each_entry(client, &vgasr_priv.clients, list) {
387
-
if (client->active)
374
+
if (client->active || client_is_audio(client))
388
375
continue;
376
+
set_audio_state(client->id, VGA_SWITCHEROO_OFF);
389
377
if (client->pwr_state == VGA_SWITCHEROO_ON)
390
378
vga_switchoff(client);
391
379
}
···
395
381
/* pwr on the device not in use */
396
382
if (strncmp(usercmd, "ON", 2) == 0) {
397
383
list_for_each_entry(client, &vgasr_priv.clients, list) {
398
-
if (client->active)
384
+
if (client->active || client_is_audio(client))
399
385
continue;
400
386
if (client->pwr_state == VGA_SWITCHEROO_OFF)
401
387
vga_switchon(client);
388
+
set_audio_state(client->id, VGA_SWITCHEROO_ON);
402
389
}
403
390
goto out;
404
391
}
+7
include/linux/vga_switcheroo.h
+7
include/linux/vga_switcheroo.h
···
12
12
enum vga_switcheroo_state {
13
13
VGA_SWITCHEROO_OFF,
14
14
VGA_SWITCHEROO_ON,
15
+
/* below are referred only from vga_switcheroo_get_client_state() */
16
+
VGA_SWITCHEROO_INIT,
17
+
VGA_SWITCHEROO_NOT_FOUND,
15
18
};
16
19
17
20
enum vga_switcheroo_client_id {
···
53
50
54
51
int vga_switcheroo_process_delayed_switch(void);
55
52
53
+
int vga_switcheroo_get_client_state(struct pci_dev *dev);
54
+
56
55
#else
57
56
58
57
static inline void vga_switcheroo_unregister_client(struct pci_dev *dev) {}
···
67
62
int id, bool active) { return 0; }
68
63
static inline void vga_switcheroo_unregister_handler(void) {}
69
64
static inline int vga_switcheroo_process_delayed_switch(void) { return 0; }
65
+
static inline int vga_switcheroo_get_client_state(struct pci_dev *dev) { return VGA_SWITCHEROO_ON; }
66
+
70
67
71
68
#endif
+5
-3
sound/core/compress_offload.c
+5
-3
sound/core/compress_offload.c
···
502
502
if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
503
503
return -EPERM;
504
504
retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
505
-
if (!retval) {
505
+
if (!retval)
506
506
stream->runtime->state = SNDRV_PCM_STATE_PAUSED;
507
-
wake_up(&stream->runtime->sleep);
508
-
}
509
507
return retval;
510
508
}
511
509
···
542
544
if (!retval) {
543
545
stream->runtime->state = SNDRV_PCM_STATE_SETUP;
544
546
wake_up(&stream->runtime->sleep);
547
+
stream->runtime->hw_pointer = 0;
548
+
stream->runtime->app_pointer = 0;
549
+
stream->runtime->total_bytes_available = 0;
550
+
stream->runtime->total_bytes_transferred = 0;
545
551
}
546
552
return retval;
547
553
}
+10
-7
sound/pci/hda/hda_intel.c
+10
-7
sound/pci/hda/hda_intel.c
···
2484
2484
static int DELAYED_INIT_MARK azx_first_init(struct azx *chip);
2485
2485
static int DELAYED_INIT_MARK azx_probe_continue(struct azx *chip);
2486
2486
2487
+
#ifdef SUPPORT_VGA_SWITCHEROO
2487
2488
static struct pci_dev __devinit *get_bound_vga(struct pci_dev *pci);
2488
2489
2489
-
#ifdef SUPPORT_VGA_SWITCHEROO
2490
2490
static void azx_vs_set_state(struct pci_dev *pci,
2491
2491
enum vga_switcheroo_state state)
2492
2492
{
···
2578
2578
#else
2579
2579
#define init_vga_switcheroo(chip) /* NOP */
2580
2580
#define register_vga_switcheroo(chip) 0
2581
+
#define check_hdmi_disabled(pci) false
2581
2582
#endif /* SUPPORT_VGA_SWITCHER */
2582
2583
2583
2584
/*
···
2639
2638
return azx_free(device->device_data);
2640
2639
}
2641
2640
2641
+
#ifdef SUPPORT_VGA_SWITCHEROO
2642
2642
/*
2643
2643
* Check of disabled HDMI controller by vga-switcheroo
2644
2644
*/
···
2672
2670
struct pci_dev *p = get_bound_vga(pci);
2673
2671
2674
2672
if (p) {
2675
-
if (vga_default_device() && p != vga_default_device())
2673
+
if (vga_switcheroo_get_client_state(p) == VGA_SWITCHEROO_OFF)
2676
2674
vga_inactive = true;
2677
2675
pci_dev_put(p);
2678
2676
}
2679
2677
return vga_inactive;
2680
2678
}
2679
+
#endif /* SUPPORT_VGA_SWITCHEROO */
2681
2680
2682
2681
/*
2683
2682
* white/black-listing for position_fix
···
3354
3351
{ PCI_DEVICE(0x6549, 0x1200),
3355
3352
.driver_data = AZX_DRIVER_TERA | AZX_DCAPS_NO_64BIT },
3356
3353
/* Creative X-Fi (CA0110-IBG) */
3354
+
/* CTHDA chips */
3355
+
{ PCI_DEVICE(0x1102, 0x0010),
3356
+
.driver_data = AZX_DRIVER_CTHDA | AZX_DCAPS_PRESET_CTHDA },
3357
+
{ PCI_DEVICE(0x1102, 0x0012),
3358
+
.driver_data = AZX_DRIVER_CTHDA | AZX_DCAPS_PRESET_CTHDA },
3357
3359
#if !defined(CONFIG_SND_CTXFI) && !defined(CONFIG_SND_CTXFI_MODULE)
3358
3360
/* the following entry conflicts with snd-ctxfi driver,
3359
3361
* as ctxfi driver mutates from HD-audio to native mode with
···
3375
3367
.driver_data = AZX_DRIVER_CTX | AZX_DCAPS_CTX_WORKAROUND |
3376
3368
AZX_DCAPS_RIRB_PRE_DELAY | AZX_DCAPS_POSFIX_LPIB },
3377
3369
#endif
3378
-
/* CTHDA chips */
3379
-
{ PCI_DEVICE(0x1102, 0x0010),
3380
-
.driver_data = AZX_DRIVER_CTHDA | AZX_DCAPS_PRESET_CTHDA },
3381
-
{ PCI_DEVICE(0x1102, 0x0012),
3382
-
.driver_data = AZX_DRIVER_CTHDA | AZX_DCAPS_PRESET_CTHDA },
3383
3370
/* Vortex86MX */
3384
3371
{ PCI_DEVICE(0x17f3, 0x3010), .driver_data = AZX_DRIVER_GENERIC },
3385
3372
/* VMware HDAudio */
+1
-1
sound/pci/hda/patch_conexant.c
+1
-1
sound/pci/hda/patch_conexant.c
···
4061
4061
static int cx_auto_init(struct hda_codec *codec)
4062
4062
{
4063
4063
struct conexant_spec *spec = codec->spec;
4064
-
/*snd_hda_sequence_write(codec, cx_auto_init_verbs);*/
4064
+
snd_hda_gen_apply_verbs(codec);
4065
4065
cx_auto_init_output(codec);
4066
4066
cx_auto_init_input(codec);
4067
4067
cx_auto_init_digital(codec);
+10
sound/pci/hda/patch_realtek.c
+10
sound/pci/hda/patch_realtek.c
···
1896
1896
alc_fix_pll(codec);
1897
1897
alc_auto_init_amp(codec, spec->init_amp);
1898
1898
1899
+
snd_hda_gen_apply_verbs(codec);
1899
1900
alc_init_special_input_src(codec);
1900
1901
alc_auto_init_std(codec);
1901
1902
···
6440
6439
ALC662_FIXUP_ASUS_MODE7,
6441
6440
ALC662_FIXUP_ASUS_MODE8,
6442
6441
ALC662_FIXUP_NO_JACK_DETECT,
6442
+
ALC662_FIXUP_ZOTAC_Z68,
6443
6443
};
6444
6444
6445
6445
static const struct alc_fixup alc662_fixups[] = {
···
6590
6588
.type = ALC_FIXUP_FUNC,
6591
6589
.v.func = alc_fixup_no_jack_detect,
6592
6590
},
6591
+
[ALC662_FIXUP_ZOTAC_Z68] = {
6592
+
.type = ALC_FIXUP_PINS,
6593
+
.v.pins = (const struct alc_pincfg[]) {
6594
+
{ 0x1b, 0x02214020 }, /* Front HP */
6595
+
{ }
6596
+
}
6597
+
},
6593
6598
};
6594
6599
6595
6600
static const struct snd_pci_quirk alc662_fixup_tbl[] = {
···
6610
6601
SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
6611
6602
SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6612
6603
SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
6604
+
SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
6613
6605
SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
6614
6606
6615
6607
#if 0
+21
-38
sound/soc/codecs/wm2000.c
+21
-38
sound/soc/codecs/wm2000.c
···
99
99
}
100
100
101
101
static int wm2000_poll_bit(struct i2c_client *i2c,
102
-
unsigned int reg, u8 mask, int timeout)
102
+
unsigned int reg, u8 mask)
103
103
{
104
+
int timeout = 4000;
104
105
int val;
105
106
106
107
val = wm2000_read(i2c, reg);
···
120
119
static int wm2000_power_up(struct i2c_client *i2c, int analogue)
121
120
{
122
121
struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
123
-
int ret, timeout;
122
+
int ret;
124
123
125
124
BUG_ON(wm2000->anc_mode != ANC_OFF);
126
125
···
141
140
142
141
/* Wait for ANC engine to become ready */
143
142
if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
144
-
WM2000_ANC_ENG_IDLE, 1)) {
143
+
WM2000_ANC_ENG_IDLE)) {
145
144
dev_err(&i2c->dev, "ANC engine failed to reset\n");
146
145
return -ETIMEDOUT;
147
146
}
148
147
149
148
if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
150
-
WM2000_STATUS_BOOT_COMPLETE, 1)) {
149
+
WM2000_STATUS_BOOT_COMPLETE)) {
151
150
dev_err(&i2c->dev, "ANC engine failed to initialise\n");
152
151
return -ETIMEDOUT;
153
152
}
···
174
173
dev_dbg(&i2c->dev, "Download complete\n");
175
174
176
175
if (analogue) {
177
-
timeout = 248;
178
-
wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, timeout / 4);
176
+
wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);
179
177
180
178
wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
181
179
WM2000_MODE_ANA_SEQ_INCLUDE |
182
180
WM2000_MODE_MOUSE_ENABLE |
183
181
WM2000_MODE_THERMAL_ENABLE);
184
182
} else {
185
-
timeout = 10;
186
-
187
183
wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
188
184
WM2000_MODE_MOUSE_ENABLE |
189
185
WM2000_MODE_THERMAL_ENABLE);
···
199
201
wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
200
202
201
203
if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
202
-
WM2000_STATUS_MOUSE_ACTIVE, timeout)) {
203
-
dev_err(&i2c->dev, "Timed out waiting for device after %dms\n",
204
-
timeout * 10);
204
+
WM2000_STATUS_MOUSE_ACTIVE)) {
205
+
dev_err(&i2c->dev, "Timed out waiting for device\n");
205
206
return -ETIMEDOUT;
206
207
}
207
208
···
215
218
static int wm2000_power_down(struct i2c_client *i2c, int analogue)
216
219
{
217
220
struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
218
-
int timeout;
219
221
220
222
if (analogue) {
221
-
timeout = 248;
222
-
wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, timeout / 4);
223
+
wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, 248 / 4);
223
224
wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
224
225
WM2000_MODE_ANA_SEQ_INCLUDE |
225
226
WM2000_MODE_POWER_DOWN);
226
227
} else {
227
-
timeout = 10;
228
228
wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
229
229
WM2000_MODE_POWER_DOWN);
230
230
}
231
231
232
232
if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
233
-
WM2000_STATUS_POWER_DOWN_COMPLETE, timeout)) {
233
+
WM2000_STATUS_POWER_DOWN_COMPLETE)) {
234
234
dev_err(&i2c->dev, "Timeout waiting for ANC power down\n");
235
235
return -ETIMEDOUT;
236
236
}
237
237
238
238
if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
239
-
WM2000_ANC_ENG_IDLE, 1)) {
239
+
WM2000_ANC_ENG_IDLE)) {
240
240
dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
241
241
return -ETIMEDOUT;
242
242
}
···
262
268
}
263
269
264
270
if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
265
-
WM2000_STATUS_ANC_DISABLED, 10)) {
271
+
WM2000_STATUS_ANC_DISABLED)) {
266
272
dev_err(&i2c->dev, "Timeout waiting for ANC disable\n");
267
273
return -ETIMEDOUT;
268
274
}
269
275
270
276
if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
271
-
WM2000_ANC_ENG_IDLE, 1)) {
277
+
WM2000_ANC_ENG_IDLE)) {
272
278
dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
273
279
return -ETIMEDOUT;
274
280
}
···
305
311
wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
306
312
307
313
if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
308
-
WM2000_STATUS_MOUSE_ACTIVE, 10)) {
314
+
WM2000_STATUS_MOUSE_ACTIVE)) {
309
315
dev_err(&i2c->dev, "Timed out waiting for MOUSE\n");
310
316
return -ETIMEDOUT;
311
317
}
···
319
325
static int wm2000_enter_standby(struct i2c_client *i2c, int analogue)
320
326
{
321
327
struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
322
-
int timeout;
323
328
324
329
BUG_ON(wm2000->anc_mode != ANC_ACTIVE);
325
330
326
331
if (analogue) {
327
-
timeout = 248;
328
-
wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, timeout / 4);
332
+
wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, 248 / 4);
329
333
330
334
wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
331
335
WM2000_MODE_ANA_SEQ_INCLUDE |
332
336
WM2000_MODE_THERMAL_ENABLE |
333
337
WM2000_MODE_STANDBY_ENTRY);
334
338
} else {
335
-
timeout = 10;
336
-
337
339
wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
338
340
WM2000_MODE_THERMAL_ENABLE |
339
341
WM2000_MODE_STANDBY_ENTRY);
340
342
}
341
343
342
344
if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
343
-
WM2000_STATUS_ANC_DISABLED, timeout)) {
345
+
WM2000_STATUS_ANC_DISABLED)) {
344
346
dev_err(&i2c->dev,
345
347
"Timed out waiting for ANC disable after 1ms\n");
346
348
return -ETIMEDOUT;
347
349
}
348
350
349
-
if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT, WM2000_ANC_ENG_IDLE,
350
-
1)) {
351
+
if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT, WM2000_ANC_ENG_IDLE)) {
351
352
dev_err(&i2c->dev,
352
-
"Timed out waiting for standby after %dms\n",
353
-
timeout * 10);
353
+
"Timed out waiting for standby\n");
354
354
return -ETIMEDOUT;
355
355
}
356
356
···
362
374
static int wm2000_exit_standby(struct i2c_client *i2c, int analogue)
363
375
{
364
376
struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
365
-
int timeout;
366
377
367
378
BUG_ON(wm2000->anc_mode != ANC_STANDBY);
368
379
369
380
wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
370
381
371
382
if (analogue) {
372
-
timeout = 248;
373
-
wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, timeout / 4);
383
+
wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);
374
384
375
385
wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
376
386
WM2000_MODE_ANA_SEQ_INCLUDE |
377
387
WM2000_MODE_THERMAL_ENABLE |
378
388
WM2000_MODE_MOUSE_ENABLE);
379
389
} else {
380
-
timeout = 10;
381
-
382
390
wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
383
391
WM2000_MODE_THERMAL_ENABLE |
384
392
WM2000_MODE_MOUSE_ENABLE);
···
384
400
wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
385
401
386
402
if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
387
-
WM2000_STATUS_MOUSE_ACTIVE, timeout)) {
388
-
dev_err(&i2c->dev, "Timed out waiting for MOUSE after %dms\n",
389
-
timeout * 10);
403
+
WM2000_STATUS_MOUSE_ACTIVE)) {
404
+
dev_err(&i2c->dev, "Timed out waiting for MOUSE\n");
390
405
return -ETIMEDOUT;
391
406
}
392
407
+66
-39
sound/soc/codecs/wm8994.c
+66
-39
sound/soc/codecs/wm8994.c
···
46
46
#define WM8994_NUM_DRC 3
47
47
#define WM8994_NUM_EQ 3
48
48
49
+
static struct {
50
+
unsigned int reg;
51
+
unsigned int mask;
52
+
} wm8994_vu_bits[] = {
53
+
{ WM8994_LEFT_LINE_INPUT_1_2_VOLUME, WM8994_IN1_VU },
54
+
{ WM8994_RIGHT_LINE_INPUT_1_2_VOLUME, WM8994_IN1_VU },
55
+
{ WM8994_LEFT_LINE_INPUT_3_4_VOLUME, WM8994_IN2_VU },
56
+
{ WM8994_RIGHT_LINE_INPUT_3_4_VOLUME, WM8994_IN2_VU },
57
+
{ WM8994_SPEAKER_VOLUME_LEFT, WM8994_SPKOUT_VU },
58
+
{ WM8994_SPEAKER_VOLUME_RIGHT, WM8994_SPKOUT_VU },
59
+
{ WM8994_LEFT_OUTPUT_VOLUME, WM8994_HPOUT1_VU },
60
+
{ WM8994_RIGHT_OUTPUT_VOLUME, WM8994_HPOUT1_VU },
61
+
{ WM8994_LEFT_OPGA_VOLUME, WM8994_MIXOUT_VU },
62
+
{ WM8994_RIGHT_OPGA_VOLUME, WM8994_MIXOUT_VU },
63
+
64
+
{ WM8994_AIF1_DAC1_LEFT_VOLUME, WM8994_AIF1DAC1_VU },
65
+
{ WM8994_AIF1_DAC1_RIGHT_VOLUME, WM8994_AIF1DAC1_VU },
66
+
{ WM8994_AIF1_DAC2_LEFT_VOLUME, WM8994_AIF1DAC2_VU },
67
+
{ WM8994_AIF1_DAC2_RIGHT_VOLUME, WM8994_AIF1DAC2_VU },
68
+
{ WM8994_AIF2_DAC_LEFT_VOLUME, WM8994_AIF2DAC_VU },
69
+
{ WM8994_AIF2_DAC_RIGHT_VOLUME, WM8994_AIF2DAC_VU },
70
+
{ WM8994_AIF1_ADC1_LEFT_VOLUME, WM8994_AIF1ADC1_VU },
71
+
{ WM8994_AIF1_ADC1_RIGHT_VOLUME, WM8994_AIF1ADC1_VU },
72
+
{ WM8994_AIF1_ADC2_LEFT_VOLUME, WM8994_AIF1ADC2_VU },
73
+
{ WM8994_AIF1_ADC2_RIGHT_VOLUME, WM8994_AIF1ADC2_VU },
74
+
{ WM8994_AIF2_ADC_LEFT_VOLUME, WM8994_AIF2ADC_VU },
75
+
{ WM8994_AIF2_ADC_RIGHT_VOLUME, WM8994_AIF1ADC2_VU },
76
+
{ WM8994_DAC1_LEFT_VOLUME, WM8994_DAC1_VU },
77
+
{ WM8994_DAC1_RIGHT_VOLUME, WM8994_DAC1_VU },
78
+
{ WM8994_DAC2_LEFT_VOLUME, WM8994_DAC2_VU },
79
+
{ WM8994_DAC2_RIGHT_VOLUME, WM8994_DAC2_VU },
80
+
};
81
+
49
82
static int wm8994_drc_base[] = {
50
83
WM8994_AIF1_DRC1_1,
51
84
WM8994_AIF1_DRC2_1,
···
1022
989
struct snd_soc_codec *codec = w->codec;
1023
990
struct wm8994 *control = codec->control_data;
1024
991
int mask = WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA;
992
+
int i;
1025
993
int dac;
1026
994
int adc;
1027
995
int val;
···
1081
1047
WM8994_AIF1DAC2L_ENA);
1082
1048
break;
1083
1049
1050
+
case SND_SOC_DAPM_POST_PMU:
1051
+
for (i = 0; i < ARRAY_SIZE(wm8994_vu_bits); i++)
1052
+
snd_soc_write(codec, wm8994_vu_bits[i].reg,
1053
+
snd_soc_read(codec,
1054
+
wm8994_vu_bits[i].reg));
1055
+
break;
1056
+
1084
1057
case SND_SOC_DAPM_PRE_PMD:
1085
1058
case SND_SOC_DAPM_POST_PMD:
1086
1059
snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_5,
···
1113
1072
struct snd_kcontrol *kcontrol, int event)
1114
1073
{
1115
1074
struct snd_soc_codec *codec = w->codec;
1075
+
int i;
1116
1076
int dac;
1117
1077
int adc;
1118
1078
int val;
···
1162
1120
WM8994_AIF2DACR_ENA,
1163
1121
WM8994_AIF2DACL_ENA |
1164
1122
WM8994_AIF2DACR_ENA);
1123
+
break;
1124
+
1125
+
case SND_SOC_DAPM_POST_PMU:
1126
+
for (i = 0; i < ARRAY_SIZE(wm8994_vu_bits); i++)
1127
+
snd_soc_write(codec, wm8994_vu_bits[i].reg,
1128
+
snd_soc_read(codec,
1129
+
wm8994_vu_bits[i].reg));
1165
1130
break;
1166
1131
1167
1132
case SND_SOC_DAPM_PRE_PMD:
···
1239
1190
switch (event) {
1240
1191
case SND_SOC_DAPM_PRE_PMU:
1241
1192
if (wm8994->aif1clk_enable) {
1242
-
aif1clk_ev(w, kcontrol, event);
1193
+
aif1clk_ev(w, kcontrol, SND_SOC_DAPM_PRE_PMU);
1243
1194
snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1,
1244
1195
WM8994_AIF1CLK_ENA_MASK,
1245
1196
WM8994_AIF1CLK_ENA);
1197
+
aif1clk_ev(w, kcontrol, SND_SOC_DAPM_POST_PMU);
1246
1198
wm8994->aif1clk_enable = 0;
1247
1199
}
1248
1200
if (wm8994->aif2clk_enable) {
1249
-
aif2clk_ev(w, kcontrol, event);
1201
+
aif2clk_ev(w, kcontrol, SND_SOC_DAPM_PRE_PMU);
1250
1202
snd_soc_update_bits(codec, WM8994_AIF2_CLOCKING_1,
1251
1203
WM8994_AIF2CLK_ENA_MASK,
1252
1204
WM8994_AIF2CLK_ENA);
1205
+
aif2clk_ev(w, kcontrol, SND_SOC_DAPM_POST_PMU);
1253
1206
wm8994->aif2clk_enable = 0;
1254
1207
}
1255
1208
break;
···
1272
1221
switch (event) {
1273
1222
case SND_SOC_DAPM_POST_PMD:
1274
1223
if (wm8994->aif1clk_disable) {
1224
+
aif1clk_ev(w, kcontrol, SND_SOC_DAPM_PRE_PMD);
1275
1225
snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1,
1276
1226
WM8994_AIF1CLK_ENA_MASK, 0);
1277
-
aif1clk_ev(w, kcontrol, event);
1227
+
aif1clk_ev(w, kcontrol, SND_SOC_DAPM_POST_PMD);
1278
1228
wm8994->aif1clk_disable = 0;
1279
1229
}
1280
1230
if (wm8994->aif2clk_disable) {
1231
+
aif2clk_ev(w, kcontrol, SND_SOC_DAPM_PRE_PMD);
1281
1232
snd_soc_update_bits(codec, WM8994_AIF2_CLOCKING_1,
1282
1233
WM8994_AIF2CLK_ENA_MASK, 0);
1283
-
aif2clk_ev(w, kcontrol, event);
1234
+
aif2clk_ev(w, kcontrol, SND_SOC_DAPM_POST_PMD);
1284
1235
wm8994->aif2clk_disable = 0;
1285
1236
}
1286
1237
break;
···
1580
1527
1581
1528
static const struct snd_soc_dapm_widget wm8994_lateclk_widgets[] = {
1582
1529
SND_SOC_DAPM_SUPPLY("AIF1CLK", WM8994_AIF1_CLOCKING_1, 0, 0, aif1clk_ev,
1583
-
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD),
1530
+
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1531
+
SND_SOC_DAPM_PRE_PMD),
1584
1532
SND_SOC_DAPM_SUPPLY("AIF2CLK", WM8994_AIF2_CLOCKING_1, 0, 0, aif2clk_ev,
1585
-
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD),
1533
+
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1534
+
SND_SOC_DAPM_PRE_PMD),
1586
1535
SND_SOC_DAPM_PGA("Direct Voice", SND_SOC_NOPM, 0, 0, NULL, 0),
1587
1536
SND_SOC_DAPM_MIXER("SPKL", WM8994_POWER_MANAGEMENT_3, 8, 0,
1588
1537
left_speaker_mixer, ARRAY_SIZE(left_speaker_mixer)),
···
3934
3879
3935
3880
pm_runtime_put(codec->dev);
3936
3881
3937
-
/* Latch volume updates (right only; we always do left then right). */
3938
-
snd_soc_update_bits(codec, WM8994_AIF1_DAC1_LEFT_VOLUME,
3939
-
WM8994_AIF1DAC1_VU, WM8994_AIF1DAC1_VU);
3940
-
snd_soc_update_bits(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME,
3941
-
WM8994_AIF1DAC1_VU, WM8994_AIF1DAC1_VU);
3942
-
snd_soc_update_bits(codec, WM8994_AIF1_DAC2_LEFT_VOLUME,
3943
-
WM8994_AIF1DAC2_VU, WM8994_AIF1DAC2_VU);
3944
-
snd_soc_update_bits(codec, WM8994_AIF1_DAC2_RIGHT_VOLUME,
3945
-
WM8994_AIF1DAC2_VU, WM8994_AIF1DAC2_VU);
3946
-
snd_soc_update_bits(codec, WM8994_AIF2_DAC_LEFT_VOLUME,
3947
-
WM8994_AIF2DAC_VU, WM8994_AIF2DAC_VU);
3948
-
snd_soc_update_bits(codec, WM8994_AIF2_DAC_RIGHT_VOLUME,
3949
-
WM8994_AIF2DAC_VU, WM8994_AIF2DAC_VU);
3950
-
snd_soc_update_bits(codec, WM8994_AIF1_ADC1_LEFT_VOLUME,
3951
-
WM8994_AIF1ADC1_VU, WM8994_AIF1ADC1_VU);
3952
-
snd_soc_update_bits(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME,
3953
-
WM8994_AIF1ADC1_VU, WM8994_AIF1ADC1_VU);
3954
-
snd_soc_update_bits(codec, WM8994_AIF1_ADC2_LEFT_VOLUME,
3955
-
WM8994_AIF1ADC2_VU, WM8994_AIF1ADC2_VU);
3956
-
snd_soc_update_bits(codec, WM8994_AIF1_ADC2_RIGHT_VOLUME,
3957
-
WM8994_AIF1ADC2_VU, WM8994_AIF1ADC2_VU);
3958
-
snd_soc_update_bits(codec, WM8994_AIF2_ADC_LEFT_VOLUME,
3959
-
WM8994_AIF2ADC_VU, WM8994_AIF1ADC2_VU);
3960
-
snd_soc_update_bits(codec, WM8994_AIF2_ADC_RIGHT_VOLUME,
3961
-
WM8994_AIF2ADC_VU, WM8994_AIF1ADC2_VU);
3962
-
snd_soc_update_bits(codec, WM8994_DAC1_LEFT_VOLUME,
3963
-
WM8994_DAC1_VU, WM8994_DAC1_VU);
3964
-
snd_soc_update_bits(codec, WM8994_DAC1_RIGHT_VOLUME,
3965
-
WM8994_DAC1_VU, WM8994_DAC1_VU);
3966
-
snd_soc_update_bits(codec, WM8994_DAC2_LEFT_VOLUME,
3967
-
WM8994_DAC2_VU, WM8994_DAC2_VU);
3968
-
snd_soc_update_bits(codec, WM8994_DAC2_RIGHT_VOLUME,
3969
-
WM8994_DAC2_VU, WM8994_DAC2_VU);
3882
+
/* Latch volume update bits */
3883
+
for (i = 0; i < ARRAY_SIZE(wm8994_vu_bits); i++)
3884
+
snd_soc_update_bits(codec, wm8994_vu_bits[i].reg,
3885
+
wm8994_vu_bits[i].mask,
3886
+
wm8994_vu_bits[i].mask);
3970
3887
3971
3888
/* Set the low bit of the 3D stereo depth so TLV matches */
3972
3889
snd_soc_update_bits(codec, WM8994_AIF1_DAC1_FILTERS_2,
+8
sound/soc/fsl/imx-audmux.c
+8
sound/soc/fsl/imx-audmux.c
···
26
26
#include <linux/of_device.h>
27
27
#include <linux/platform_device.h>
28
28
#include <linux/slab.h>
29
+
#include <linux/pinctrl/consumer.h>
29
30
30
31
#include "imx-audmux.h"
31
32
···
250
249
static int __devinit imx_audmux_probe(struct platform_device *pdev)
251
250
{
252
251
struct resource *res;
252
+
struct pinctrl *pinctrl;
253
253
const struct of_device_id *of_id =
254
254
of_match_device(imx_audmux_dt_ids, &pdev->dev);
255
255
···
258
256
audmux_base = devm_request_and_ioremap(&pdev->dev, res);
259
257
if (!audmux_base)
260
258
return -EADDRNOTAVAIL;
259
+
260
+
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
261
+
if (IS_ERR(pinctrl)) {
262
+
dev_err(&pdev->dev, "setup pinctrl failed!");
263
+
return PTR_ERR(pinctrl);
264
+
}
261
265
262
266
audmux_clk = clk_get(&pdev->dev, "audmux");
263
267
if (IS_ERR(audmux_clk)) {
+2
-2
sound/soc/soc-dapm.c
+2
-2
sound/soc/soc-dapm.c
···
913
913
/* do we need to add this widget to the list ? */
914
914
if (list) {
915
915
int err;
916
-
err = dapm_list_add_widget(list, path->sink);
916
+
err = dapm_list_add_widget(list, path->source);
917
917
if (err < 0) {
918
918
dev_err(widget->dapm->dev, "could not add widget %s\n",
919
919
widget->name);
···
954
954
if (stream == SNDRV_PCM_STREAM_PLAYBACK)
955
955
paths = is_connected_output_ep(dai->playback_widget, list);
956
956
else
957
-
paths = is_connected_input_ep(dai->playback_widget, list);
957
+
paths = is_connected_input_ep(dai->capture_widget, list);
958
958
959
959
trace_snd_soc_dapm_connected(paths, stream);
960
960
dapm_clear_walk(&card->dapm);
+6
sound/soc/soc-pcm.c
+6
sound/soc/soc-pcm.c
···
794
794
for (i = 0; i < card->num_links; i++) {
795
795
be = &card->rtd[i];
796
796
797
+
if (!be->dai_link->no_pcm)
798
+
continue;
799
+
797
800
if (be->cpu_dai->playback_widget == widget ||
798
801
be->codec_dai->playback_widget == widget)
799
802
return be;
···
805
802
806
803
for (i = 0; i < card->num_links; i++) {
807
804
be = &card->rtd[i];
805
+
806
+
if (!be->dai_link->no_pcm)
807
+
continue;
808
808
809
809
if (be->cpu_dai->capture_widget == widget ||
810
810
be->codec_dai->capture_widget == widget)
+1
sound/soc/tegra/tegra30_ahub.c
+1
sound/soc/tegra/tegra30_ahub.c
+1
sound/usb/card.h
+1
sound/usb/card.h
···
119
119
unsigned long unlink_mask; /* bitmask of unlinked urbs */
120
120
121
121
/* data and sync endpoints for this stream */
122
+
unsigned int ep_num; /* the endpoint number */
122
123
struct snd_usb_endpoint *data_endpoint;
123
124
struct snd_usb_endpoint *sync_endpoint;
124
125
unsigned long flags;
+3
-4
sound/usb/stream.c
+3
-4
sound/usb/stream.c
···
97
97
subs->formats |= fp->formats;
98
98
subs->num_formats++;
99
99
subs->fmt_type = fp->fmt_type;
100
+
subs->ep_num = fp->endpoint;
100
101
}
101
102
102
103
/*
···
120
119
if (as->fmt_type != fp->fmt_type)
121
120
continue;
122
121
subs = &as->substream[stream];
123
-
if (!subs->data_endpoint)
124
-
continue;
125
-
if (subs->data_endpoint->ep_num == fp->endpoint) {
122
+
if (subs->ep_num == fp->endpoint) {
126
123
list_add_tail(&fp->list, &subs->fmt_list);
127
124
subs->num_formats++;
128
125
subs->formats |= fp->formats;
···
133
134
if (as->fmt_type != fp->fmt_type)
134
135
continue;
135
136
subs = &as->substream[stream];
136
-
if (subs->data_endpoint)
137
+
if (subs->ep_num)
137
138
continue;
138
139
err = snd_pcm_new_stream(as->pcm, stream, 1);
139
140
if (err < 0)