Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'sound-fix-3.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
Pull sound fixes from Takashi Iwai:
"Most of changes are small and easy cleanup or fixes:
- a few HD-audio Realtek codec fixes and quirks
- Intel HDMI audio fixes for Broadwell and Haswell / ValleyView
- FireWire sound stack cleanups
- a couple of sequencer core fixes
- compress ABI fix for 64bit
- conversion to modern ktime*() API"
* tag 'sound-fix-3.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (23 commits)
ALSA: hda/realtek - Add more entry for enable HP mute led
ALSA: hda - Add quirk for external mic on Lifebook U904
ALSA: hda - fix a fixup value for codec alc293 in the pin_quirk table
ALSA: intel8x0: Use ktime and ktime_get()
ALSA: core: Use ktime_get_ts()
ALSA: hda - verify pin:converter connection on unsol event for HSW and VLV
ALSA: compress: Cancel the optimization of compiler and fix the size of struct for all platform.
ALSA: hda - Add quirk for ABit AA8XE
Revert "ALSA: hda - mask buggy stream DMA0 for Broadwell display controller"
ALSA: hda - using POS_FIX_LPIB on Broadwell HDMI Audio
ALSA: hda/realtek - Add support of ALC667 codec
ALSA: hda/realtek - Add more codec rename
ALSA: hda/realtek - New vendor ID for ALC233
ALSA: hda - add two new pin tables
ALSA: hda/realtek - Add support of ALC891 codec
ALSA: seq: Continue broadcasting events to ports if one of them fails
ALSA: bebob: Remove unused function prototype
ALSA: fireworks: Remove meaningless mutex_destroy()
ALSA: fireworks: Remove a constant over width to which it's applied
ALSA: fireworks: Improve comments about Fireworks transaction
...
+147
-56
+1
-1
include/sound/pcm.h
+1
-1
include/sound/pcm.h
+1
-1
include/uapi/sound/compress_offload.h
+1
-1
include/uapi/sound/compress_offload.h
+24
-12
sound/core/seq/seq_clientmgr.c
+24
-12
sound/core/seq/seq_clientmgr.c
···
660
660
int atomic, int hop)
661
661
{
662
662
struct snd_seq_subscribers *subs;
663
-
int err = 0, num_ev = 0;
663
+
int err, result = 0, num_ev = 0;
664
664
struct snd_seq_event event_saved;
665
665
struct snd_seq_client_port *src_port;
666
666
struct snd_seq_port_subs_info *grp;
···
685
685
subs->info.flags & SNDRV_SEQ_PORT_SUBS_TIME_REAL);
686
686
err = snd_seq_deliver_single_event(client, event,
687
687
0, atomic, hop);
688
-
if (err < 0)
689
-
break;
688
+
if (err < 0) {
689
+
/* save first error that occurs and continue */
690
+
if (!result)
691
+
result = err;
692
+
continue;
693
+
}
690
694
num_ev++;
691
695
/* restore original event record */
692
696
*event = event_saved;
···
701
697
up_read(&grp->list_mutex);
702
698
*event = event_saved; /* restore */
703
699
snd_seq_port_unlock(src_port);
704
-
return (err < 0) ? err : num_ev;
700
+
return (result < 0) ? result : num_ev;
705
701
}
706
702
707
703
···
713
709
struct snd_seq_event *event,
714
710
int atomic, int hop)
715
711
{
716
-
int num_ev = 0, err = 0;
712
+
int num_ev = 0, err, result = 0;
717
713
struct snd_seq_client *dest_client;
718
714
struct snd_seq_client_port *port;
719
715
···
728
724
err = snd_seq_deliver_single_event(NULL, event,
729
725
SNDRV_SEQ_FILTER_BROADCAST,
730
726
atomic, hop);
731
-
if (err < 0)
732
-
break;
727
+
if (err < 0) {
728
+
/* save first error that occurs and continue */
729
+
if (!result)
730
+
result = err;
731
+
continue;
732
+
}
733
733
num_ev++;
734
734
}
735
735
read_unlock(&dest_client->ports_lock);
736
736
snd_seq_client_unlock(dest_client);
737
737
event->dest.port = SNDRV_SEQ_ADDRESS_BROADCAST; /* restore */
738
-
return (err < 0) ? err : num_ev;
738
+
return (result < 0) ? result : num_ev;
739
739
}
740
740
741
741
/*
···
749
741
static int broadcast_event(struct snd_seq_client *client,
750
742
struct snd_seq_event *event, int atomic, int hop)
751
743
{
752
-
int err = 0, num_ev = 0;
744
+
int err, result = 0, num_ev = 0;
753
745
int dest;
754
746
struct snd_seq_addr addr;
755
747
···
768
760
err = snd_seq_deliver_single_event(NULL, event,
769
761
SNDRV_SEQ_FILTER_BROADCAST,
770
762
atomic, hop);
771
-
if (err < 0)
772
-
break;
763
+
if (err < 0) {
764
+
/* save first error that occurs and continue */
765
+
if (!result)
766
+
result = err;
767
+
continue;
768
+
}
773
769
num_ev += err;
774
770
}
775
771
event->dest = addr; /* restore */
776
-
return (err < 0) ? err : num_ev;
772
+
return (result < 0) ? result : num_ev;
777
773
}
778
774
779
775
+1
-1
sound/core/seq/seq_fifo.c
+1
-1
sound/core/seq/seq_fifo.c
···
124
124
snd_use_lock_use(&f->use_lock);
125
125
err = snd_seq_event_dup(f->pool, event, &cell, 1, NULL); /* always non-blocking */
126
126
if (err < 0) {
127
-
if (err == -ENOMEM)
127
+
if ((err == -ENOMEM) || (err == -EAGAIN))
128
128
atomic_inc(&f->overflow);
129
129
snd_use_lock_free(&f->use_lock);
130
130
return err;
+2
-2
sound/core/timer.c
+2
-2
sound/core/timer.c
···
390
390
struct timespec tstamp;
391
391
392
392
if (timer_tstamp_monotonic)
393
-
do_posix_clock_monotonic_gettime(&tstamp);
393
+
ktime_get_ts(&tstamp);
394
394
else
395
395
getnstimeofday(&tstamp);
396
396
if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_START ||
···
1203
1203
}
1204
1204
if (tu->last_resolution != resolution || ticks > 0) {
1205
1205
if (timer_tstamp_monotonic)
1206
-
do_posix_clock_monotonic_gettime(&tstamp);
1206
+
ktime_get_ts(&tstamp);
1207
1207
else
1208
1208
getnstimeofday(&tstamp);
1209
1209
}
-2
sound/firewire/bebob/bebob.h
-2
sound/firewire/bebob/bebob.h
···
208
208
int snd_bebob_stream_check_internal_clock(struct snd_bebob *bebob,
209
209
bool *internal);
210
210
int snd_bebob_stream_discover(struct snd_bebob *bebob);
211
-
int snd_bebob_stream_map(struct snd_bebob *bebob,
212
-
struct amdtp_stream *stream);
213
211
int snd_bebob_stream_init_duplex(struct snd_bebob *bebob);
214
212
int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate);
215
213
void snd_bebob_stream_stop_duplex(struct snd_bebob *bebob);
+2
-2
sound/firewire/bebob/bebob_stream.c
+2
-2
sound/firewire/bebob/bebob_stream.c
···
655
655
struct amdtp_stream *master, *slave;
656
656
atomic_t *master_substreams, *slave_substreams;
657
657
658
-
mutex_lock(&bebob->mutex);
659
-
660
658
if (bebob->master == &bebob->rx_stream) {
661
659
slave = &bebob->tx_stream;
662
660
master = &bebob->rx_stream;
···
666
668
slave_substreams = &bebob->playback_substreams;
667
669
master_substreams = &bebob->capture_substreams;
668
670
}
671
+
672
+
mutex_lock(&bebob->mutex);
669
673
670
674
if (atomic_read(slave_substreams) == 0) {
671
675
amdtp_stream_pcm_abort(slave);
-1
sound/firewire/fireworks/fireworks.c
-1
sound/firewire/fireworks/fireworks.c
-1
sound/firewire/fireworks/fireworks.h
-1
sound/firewire/fireworks/fireworks.h
+1
-1
sound/firewire/fireworks/fireworks_hwdep.c
+1
-1
sound/firewire/fireworks/fireworks_hwdep.c
+2
-2
sound/firewire/fireworks/fireworks_stream.c
+2
-2
sound/firewire/fireworks/fireworks_stream.c
···
284
284
struct amdtp_stream *master, *slave;
285
285
atomic_t *master_substreams, *slave_substreams;
286
286
287
-
mutex_lock(&efw->mutex);
288
-
289
287
if (efw->master == &efw->rx_stream) {
290
288
slave = &efw->tx_stream;
291
289
master = &efw->rx_stream;
···
295
297
slave_substreams = &efw->playback_substreams;
296
298
master_substreams = &efw->capture_substreams;
297
299
}
300
+
301
+
mutex_lock(&efw->mutex);
298
302
299
303
if (atomic_read(slave_substreams) == 0) {
300
304
stop_stream(efw, slave);
+9
-9
sound/firewire/fireworks/fireworks_transaction.c
+9
-9
sound/firewire/fireworks/fireworks_transaction.c
···
8
8
9
9
/*
10
10
* Fireworks have its own transaction. The transaction can be delivered by AV/C
11
-
* Vendor Specific command. But at least Windows driver and firmware version 5.5
12
-
* or later don't use it.
11
+
* Vendor Specific command frame or usual asynchronous transaction. At least,
12
+
* Windows driver and firmware version 5.5 or later don't use AV/C command.
13
13
*
14
14
* Transaction substance:
15
-
* At first, 6 data exist. Following to the 6 data, parameters for each
16
-
* commands exists. All of parameters are 32 bit alighed to big endian.
15
+
* At first, 6 data exist. Following to the data, parameters for each command
16
+
* exist. All of the parameters are 32 bit alighed to big endian.
17
17
* data[0]: Length of transaction substance
18
18
* data[1]: Transaction version
19
19
* data[2]: Sequence number. This is incremented by the device
20
-
* data[3]: transaction category
21
-
* data[4]: transaction command
22
-
* data[5]: return value in response.
23
-
* data[6-]: parameters
20
+
* data[3]: Transaction category
21
+
* data[4]: Transaction command
22
+
* data[5]: Return value in response.
23
+
* data[6-]: Parameters
24
24
*
25
25
* Transaction address:
26
26
* command: 0xecc000000000
···
148
148
149
149
efw->push_ptr += till_end;
150
150
if (efw->push_ptr >= efw->resp_buf + snd_efw_resp_buf_size)
151
-
efw->push_ptr = efw->resp_buf;
151
+
efw->push_ptr -= snd_efw_resp_buf_size;
152
152
153
153
length -= till_end;
154
154
data += till_end;
+7
-7
sound/pci/hda/hda_intel.c
+7
-7
sound/pci/hda/hda_intel.c
···
237
237
AZX_DCAPS_COUNT_LPIB_DELAY | AZX_DCAPS_PM_RUNTIME | \
238
238
AZX_DCAPS_I915_POWERWELL)
239
239
240
+
/* Broadwell HDMI can't use position buffer reliably, force to use LPIB */
241
+
#define AZX_DCAPS_INTEL_BROADWELL \
242
+
(AZX_DCAPS_SCH_SNOOP | AZX_DCAPS_ALIGN_BUFSIZE | \
243
+
AZX_DCAPS_POSFIX_LPIB | AZX_DCAPS_PM_RUNTIME | \
244
+
AZX_DCAPS_I915_POWERWELL)
245
+
240
246
/* quirks for ATI SB / AMD Hudson */
241
247
#define AZX_DCAPS_PRESET_ATI_SB \
242
248
(AZX_DCAPS_ATI_SNOOP | AZX_DCAPS_NO_TCSEL | \
···
1373
1367
/* initialize streams */
1374
1368
azx_init_stream(chip);
1375
1369
1376
-
/* workaround for Broadwell HDMI: the first stream is broken,
1377
-
* so mask it by keeping it as if opened
1378
-
*/
1379
-
if (pci->vendor == 0x8086 && pci->device == 0x160c)
1380
-
chip->azx_dev[0].opened = 1;
1381
-
1382
1370
/* initialize chip */
1383
1371
azx_init_pci(chip);
1384
1372
azx_init_chip(chip, (probe_only[dev] & 2) == 0);
···
1769
1769
.driver_data = AZX_DRIVER_HDMI | AZX_DCAPS_INTEL_HASWELL },
1770
1770
/* Broadwell */
1771
1771
{ PCI_DEVICE(0x8086, 0x160c),
1772
-
.driver_data = AZX_DRIVER_HDMI | AZX_DCAPS_INTEL_HASWELL },
1772
+
.driver_data = AZX_DRIVER_HDMI | AZX_DCAPS_INTEL_BROADWELL },
1773
1773
/* 5 Series/3400 */
1774
1774
{ PCI_DEVICE(0x8086, 0x3b56),
1775
1775
.driver_data = AZX_DRIVER_SCH | AZX_DCAPS_INTEL_PCH_NOPM },
+9
-1
sound/pci/hda/patch_hdmi.c
+9
-1
sound/pci/hda/patch_hdmi.c
···
1594
1594
* Re-setup pin and infoframe. This is needed e.g. when
1595
1595
* - sink is first plugged-in (infoframe is not set up if !monitor_present)
1596
1596
* - transcoder can change during stream playback on Haswell
1597
+
* and this can make HW reset converter selection on a pin.
1597
1598
*/
1598
-
if (eld->eld_valid && !old_eld_valid && per_pin->setup)
1599
+
if (eld->eld_valid && !old_eld_valid && per_pin->setup) {
1600
+
if (is_haswell_plus(codec) || is_valleyview(codec)) {
1601
+
intel_verify_pin_cvt_connect(codec, per_pin);
1602
+
intel_not_share_assigned_cvt(codec, pin_nid,
1603
+
per_pin->mux_idx);
1604
+
}
1605
+
1599
1606
hdmi_setup_audio_infoframe(codec, per_pin,
1600
1607
per_pin->non_pcm);
1608
+
}
1601
1609
}
1602
1610
1603
1611
if (eld_changed)
+84
-7
sound/pci/hda/patch_realtek.c
+84
-7
sound/pci/hda/patch_realtek.c
···
929
929
};
930
930
931
931
static struct alc_codec_rename_table rename_tbl[] = {
932
+
{ 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
932
933
{ 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
933
934
{ 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
934
935
{ 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
···
938
937
{ 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
939
938
{ 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
940
939
{ 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
940
+
{ 0x10ec0662, 0xffff, 0x4020, "ALC656" },
941
941
{ 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
942
942
{ 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
943
943
{ 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
···
958
956
{ 0x10ec0293, 0x1028, 0, "ALC3235" },
959
957
{ 0x10ec0255, 0x1028, 0, "ALC3234" },
960
958
{ 0x10ec0668, 0x1028, 0, "ALC3661" },
959
+
{ 0x10ec0275, 0x1028, 0, "ALC3260" },
960
+
{ 0x10ec0899, 0x1028, 0, "ALC3861" },
961
+
{ 0x10ec0670, 0x1025, 0, "ALC669X" },
962
+
{ 0x10ec0676, 0x1025, 0, "ALC679X" },
963
+
{ 0x10ec0282, 0x1043, 0, "ALC3229" },
964
+
{ 0x10ec0233, 0x1043, 0, "ALC3236" },
965
+
{ 0x10ec0280, 0x103c, 0, "ALC3228" },
966
+
{ 0x10ec0282, 0x103c, 0, "ALC3227" },
967
+
{ 0x10ec0286, 0x103c, 0, "ALC3242" },
968
+
{ 0x10ec0290, 0x103c, 0, "ALC3241" },
969
+
{ 0x10ec0668, 0x103c, 0, "ALC3662" },
970
+
{ 0x10ec0283, 0x17aa, 0, "ALC3239" },
971
+
{ 0x10ec0292, 0x17aa, 0, "ALC3232" },
961
972
{ } /* terminator */
962
973
};
963
974
···
1427
1412
SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1428
1413
SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1429
1414
SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1415
+
SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1430
1416
SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1431
1417
SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1432
1418
SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
···
4246
4230
ALC269_FIXUP_HEADSET_MIC,
4247
4231
ALC269_FIXUP_QUANTA_MUTE,
4248
4232
ALC269_FIXUP_LIFEBOOK,
4233
+
ALC269_FIXUP_LIFEBOOK_EXTMIC,
4249
4234
ALC269_FIXUP_AMIC,
4250
4235
ALC269_FIXUP_DMIC,
4251
4236
ALC269VB_FIXUP_AMIC,
···
4383
4366
},
4384
4367
.chained = true,
4385
4368
.chain_id = ALC269_FIXUP_QUANTA_MUTE
4369
+
},
4370
+
[ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
4371
+
.type = HDA_FIXUP_PINS,
4372
+
.v.pins = (const struct hda_pintbl[]) {
4373
+
{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */
4374
+
{ }
4375
+
},
4386
4376
},
4387
4377
[ALC269_FIXUP_AMIC] = {
4388
4378
.type = HDA_FIXUP_PINS,
···
4765
4741
SND_PCI_QUIRK(0x1028, 0x0614, "Dell Inspiron 3135", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4766
4742
SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
4767
4743
SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
4768
-
SND_PCI_QUIRK(0x1028, 0x062c, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4769
4744
SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
4770
4745
SND_PCI_QUIRK(0x1028, 0x063f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4771
4746
SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
4772
4747
SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
4773
-
SND_PCI_QUIRK(0x1028, 0x064d, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4774
4748
SND_PCI_QUIRK(0x1028, 0x0668, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE),
4775
4749
SND_PCI_QUIRK(0x1028, 0x0669, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE),
4776
-
SND_PCI_QUIRK(0x1028, 0x0674, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4777
-
SND_PCI_QUIRK(0x1028, 0x067e, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4778
-
SND_PCI_QUIRK(0x1028, 0x067f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4779
-
SND_PCI_QUIRK(0x1028, 0x0680, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4780
4750
SND_PCI_QUIRK(0x1028, 0x0684, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4781
4751
SND_PCI_QUIRK(0x1028, 0x15cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4782
4752
SND_PCI_QUIRK(0x1028, 0x15cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
···
4782
4764
SND_PCI_QUIRK(0x103c, 0x1983, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4783
4765
SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
4784
4766
/* ALC282 */
4767
+
SND_PCI_QUIRK(0x103c, 0x220d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4768
+
SND_PCI_QUIRK(0x103c, 0x220e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4785
4769
SND_PCI_QUIRK(0x103c, 0x220f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4770
+
SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4771
+
SND_PCI_QUIRK(0x103c, 0x2211, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4772
+
SND_PCI_QUIRK(0x103c, 0x2212, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4786
4773
SND_PCI_QUIRK(0x103c, 0x2213, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4774
+
SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4787
4775
SND_PCI_QUIRK(0x103c, 0x2266, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4788
4776
SND_PCI_QUIRK(0x103c, 0x2267, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4789
4777
SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4790
4778
SND_PCI_QUIRK(0x103c, 0x2269, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4791
4779
SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4792
4780
SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4781
+
SND_PCI_QUIRK(0x103c, 0x226c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4782
+
SND_PCI_QUIRK(0x103c, 0x226d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4783
+
SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4784
+
SND_PCI_QUIRK(0x103c, 0x226f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4793
4785
SND_PCI_QUIRK(0x103c, 0x227a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4794
4786
SND_PCI_QUIRK(0x103c, 0x227b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4795
4787
SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
···
4839
4811
SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4840
4812
SND_PCI_QUIRK(0x103c, 0x22c3, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4841
4813
SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4814
+
SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4815
+
SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4816
+
SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4817
+
SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4842
4818
SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
4843
4819
SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
4844
4820
SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
···
4866
4834
SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
4867
4835
SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
4868
4836
SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
4837
+
SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
4869
4838
SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
4870
4839
SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
4871
4840
SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
···
4999
4966
{0x1d, 0x40700001},
5000
4967
{0x1e, 0x411111f0},
5001
4968
{0x21, 0x02211030},
4969
+
},
4970
+
.value = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
4971
+
},
4972
+
{
4973
+
.codec = 0x10ec0255,
4974
+
.subvendor = 0x1028,
4975
+
#ifdef CONFIG_SND_DEBUG_VERBOSE
4976
+
.name = "Dell",
4977
+
#endif
4978
+
.pins = (const struct hda_pintbl[]) {
4979
+
{0x12, 0x90a60160},
4980
+
{0x14, 0x90170120},
4981
+
{0x17, 0x90170140},
4982
+
{0x18, 0x40000000},
4983
+
{0x19, 0x411111f0},
4984
+
{0x1a, 0x411111f0},
4985
+
{0x1b, 0x411111f0},
4986
+
{0x1d, 0x41163b05},
4987
+
{0x1e, 0x411111f0},
4988
+
{0x21, 0x0321102f},
5002
4989
},
5003
4990
.value = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5004
4991
},
···
5182
5129
{0x1d, 0x40700001},
5183
5130
{0x1e, 0x411111f0},
5184
5131
},
5185
-
.value = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5132
+
.value = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5186
5133
},
5187
5134
{}
5188
5135
};
···
6067
6014
.name = "Dell",
6068
6015
#endif
6069
6016
.pins = (const struct hda_pintbl[]) {
6017
+
{0x12, 0x99a30140},
6018
+
{0x14, 0x90170110},
6019
+
{0x15, 0x0321101f},
6020
+
{0x16, 0x03011020},
6021
+
{0x18, 0x40000008},
6022
+
{0x19, 0x411111f0},
6023
+
{0x1a, 0x411111f0},
6024
+
{0x1b, 0x411111f0},
6025
+
{0x1d, 0x41000001},
6026
+
{0x1e, 0x411111f0},
6027
+
{0x1f, 0x411111f0},
6028
+
},
6029
+
.value = ALC668_FIXUP_AUTO_MUTE,
6030
+
},
6031
+
{
6032
+
.codec = 0x10ec0668,
6033
+
.subvendor = 0x1028,
6034
+
#ifdef CONFIG_SND_DEBUG_VERBOSE
6035
+
.name = "Dell",
6036
+
#endif
6037
+
.pins = (const struct hda_pintbl[]) {
6070
6038
{0x12, 0x99a30150},
6071
6039
{0x14, 0x90170110},
6072
6040
{0x15, 0x0321101f},
···
6264
6190
{ .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
6265
6191
{ .id = 0x10ec0231, .name = "ALC231", .patch = patch_alc269 },
6266
6192
{ .id = 0x10ec0233, .name = "ALC233", .patch = patch_alc269 },
6193
+
{ .id = 0x10ec0235, .name = "ALC233", .patch = patch_alc269 },
6267
6194
{ .id = 0x10ec0255, .name = "ALC255", .patch = patch_alc269 },
6268
6195
{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
6269
6196
{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
···
6298
6223
.patch = patch_alc662 },
6299
6224
{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
6300
6225
{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6226
+
{ .id = 0x10ec0667, .name = "ALC667", .patch = patch_alc662 },
6301
6227
{ .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },
6302
6228
{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
6303
6229
{ .id = 0x10ec0671, .name = "ALC671", .patch = patch_alc662 },
6304
6230
{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
6231
+
{ .id = 0x10ec0867, .name = "ALC891", .patch = patch_alc882 },
6305
6232
{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
6306
6233
{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
6307
6234
{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
+4
-6
sound/pci/intel8x0.c
+4
-6
sound/pci/intel8x0.c
···
2779
2779
unsigned long port;
2780
2780
unsigned long pos, pos1, t;
2781
2781
int civ, timeout = 1000, attempt = 1;
2782
-
struct timespec start_time, stop_time;
2782
+
ktime_t start_time, stop_time;
2783
2783
2784
2784
if (chip->ac97_bus->clock != 48000)
2785
2785
return; /* specified in module option */
···
2813
2813
iputbyte(chip, port + ICH_REG_OFF_CR, ICH_IOCE);
2814
2814
iputdword(chip, ICHREG(ALI_DMACR), 1 << ichdev->ali_slot);
2815
2815
}
2816
-
do_posix_clock_monotonic_gettime(&start_time);
2816
+
start_time = ktime_get();
2817
2817
spin_unlock_irq(&chip->reg_lock);
2818
2818
msleep(50);
2819
2819
spin_lock_irq(&chip->reg_lock);
···
2837
2837
pos += ichdev->position;
2838
2838
}
2839
2839
chip->in_measurement = 0;
2840
-
do_posix_clock_monotonic_gettime(&stop_time);
2840
+
stop_time = ktime_get();
2841
2841
/* stop */
2842
2842
if (chip->device_type == DEVICE_ALI) {
2843
2843
iputdword(chip, ICHREG(ALI_DMACR), 1 << (ichdev->ali_slot + 16));
···
2865
2865
}
2866
2866
2867
2867
pos /= 4;
2868
-
t = stop_time.tv_sec - start_time.tv_sec;
2869
-
t *= 1000000;
2870
-
t += (stop_time.tv_nsec - start_time.tv_nsec) / 1000;
2868
+
t = ktime_us_delta(stop_time, start_time);
2871
2869
dev_info(chip->card->dev,
2872
2870
"%s: measured %lu usecs (%lu samples)\n", __func__, t, pos);
2873
2871
if (t == 0) {