Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'sound-5.9-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
Pull sound fixes from Takashi Iwai:
"A collection of small changes, nothing intrusive:
- remaining tasklet API conversions, now all sound stuff have been
converted
- a few HD-audio and USB-audio quirks and minor fixes
- FireWire Tascam and Digi00xx fixes
- drop a kernel WARNING from PCM OSS for syzkaller"
* tag 'sound-5.9-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (29 commits)
ALSA: hda/realtek - Improved routing for Thinkpad X1 7th/8th Gen
ALSA: hda: use consistent HDAudio spelling in comments/docs
ALSA: hda: add dev_dbg log when driver is not selected
ALSA: hda: fix a runtime pm issue in SOF when integrated GPU is disabled
ALSA: hda: hdmi - add Rocketlake support
ALSA: ua101: convert tasklets to use new tasklet_setup() API
ALSA: usb-audio: convert tasklets to use new tasklet_setup() API
ASoC: txx9: convert tasklets to use new tasklet_setup() API
ASoC: siu: convert tasklets to use new tasklet_setup() API
ASoC: fsl_esai: convert tasklets to use new tasklet_setup() API
ALSA: hdsp: convert tasklets to use new tasklet_setup() API
ALSA: riptide: convert tasklets to use new tasklet_setup() API
ALSA: pci/asihpi: convert tasklets to use new tasklet_setup() API
ALSA: firewire: convert tasklets to use new tasklet_setup() API
ALSA: core: convert tasklets to use new tasklet_setup() API
ALSA: pcm: oss: Remove superfluous WARN_ON() for mulaw sanity check
ALSA: hda - Fix silent audio output and corrupted input on MSI X570-A PRO
ALSA: hda/hdmi: always check pin power status in i915 pin fixup
ALSA: hda/realtek: Add quirk for Samsung Galaxy Book Ion NT950XCJ-X716A
ALSA: usb-audio: Add basic capture support for Pioneer DJ DJM-250MK2
...
+227
-78
+1
-1
Documentation/sound/cards/audigy-mixer.rst
+1
-1
Documentation/sound/cards/audigy-mixer.rst
+1
-1
Documentation/sound/cards/sb-live-mixer.rst
+1
-1
Documentation/sound/cards/sb-live-mixer.rst
+1
-1
Documentation/sound/designs/timestamping.rst
+1
-1
Documentation/sound/designs/timestamping.rst
···
143
143
before returning from the ``STATUS`` and ``STATUS_EXT`` ioctl. in most cases
144
144
this driver_timestamp will be identical to the regular system tstamp.
145
145
146
-
Examples of typestamping with HDaudio:
146
+
Examples of timestamping with HDAudio:
147
147
148
148
1. DMA timestamp, no compensation for DMA+analog delay
149
149
::
+2
-2
sound/core/oss/mulaw.c
+2
-2
sound/core/oss/mulaw.c
···
329
329
snd_BUG();
330
330
return -EINVAL;
331
331
}
332
-
if (snd_BUG_ON(!snd_pcm_format_linear(format->format)))
333
-
return -ENXIO;
332
+
if (!snd_pcm_format_linear(format->format))
333
+
return -EINVAL;
334
334
335
335
err = snd_pcm_plugin_build(plug, "Mu-Law<->linear conversion",
336
336
src_format, dst_format,
+3
-4
sound/core/timer.c
+3
-4
sound/core/timer.c
···
816
816
* timer tasklet
817
817
*
818
818
*/
819
-
static void snd_timer_tasklet(unsigned long arg)
819
+
static void snd_timer_tasklet(struct tasklet_struct *t)
820
820
{
821
-
struct snd_timer *timer = (struct snd_timer *) arg;
821
+
struct snd_timer *timer = from_tasklet(timer, t, task_queue);
822
822
unsigned long flags;
823
823
824
824
if (timer->card && timer->card->shutdown) {
···
967
967
INIT_LIST_HEAD(&timer->ack_list_head);
968
968
INIT_LIST_HEAD(&timer->sack_list_head);
969
969
spin_lock_init(&timer->lock);
970
-
tasklet_init(&timer->task_queue, snd_timer_tasklet,
971
-
(unsigned long)timer);
970
+
tasklet_setup(&timer->task_queue, snd_timer_tasklet);
972
971
timer->max_instances = 1000; /* default limit per timer */
973
972
if (card != NULL) {
974
973
timer->module = card->module;
+4
-4
sound/firewire/amdtp-stream.c
+4
-4
sound/firewire/amdtp-stream.c
···
64
64
#define IT_PKT_HEADER_SIZE_CIP 8 // For 2 CIP header.
65
65
#define IT_PKT_HEADER_SIZE_NO_CIP 0 // Nothing.
66
66
67
-
static void pcm_period_tasklet(unsigned long data);
67
+
static void pcm_period_tasklet(struct tasklet_struct *t);
68
68
69
69
/**
70
70
* amdtp_stream_init - initialize an AMDTP stream structure
···
94
94
s->flags = flags;
95
95
s->context = ERR_PTR(-1);
96
96
mutex_init(&s->mutex);
97
-
tasklet_init(&s->period_tasklet, pcm_period_tasklet, (unsigned long)s);
97
+
tasklet_setup(&s->period_tasklet, pcm_period_tasklet);
98
98
s->packet_index = 0;
99
99
100
100
init_waitqueue_head(&s->callback_wait);
···
441
441
}
442
442
}
443
443
444
-
static void pcm_period_tasklet(unsigned long data)
444
+
static void pcm_period_tasklet(struct tasklet_struct *t)
445
445
{
446
-
struct amdtp_stream *s = (void *)data;
446
+
struct amdtp_stream *s = from_tasklet(s, t, period_tasklet);
447
447
struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
448
448
449
449
if (pcm)
+5
sound/firewire/digi00x/digi00x.c
+5
sound/firewire/digi00x/digi00x.c
···
14
14
#define VENDOR_DIGIDESIGN 0x00a07e
15
15
#define MODEL_CONSOLE 0x000001
16
16
#define MODEL_RACK 0x000002
17
+
#define SPEC_VERSION 0x000001
17
18
18
19
static int name_card(struct snd_dg00x *dg00x)
19
20
{
···
176
175
/* Both of 002/003 use the same ID. */
177
176
{
178
177
.match_flags = IEEE1394_MATCH_VENDOR_ID |
178
+
IEEE1394_MATCH_VERSION |
179
179
IEEE1394_MATCH_MODEL_ID,
180
180
.vendor_id = VENDOR_DIGIDESIGN,
181
+
.version = SPEC_VERSION,
181
182
.model_id = MODEL_CONSOLE,
182
183
},
183
184
{
184
185
.match_flags = IEEE1394_MATCH_VENDOR_ID |
186
+
IEEE1394_MATCH_VERSION |
185
187
IEEE1394_MATCH_MODEL_ID,
186
188
.vendor_id = VENDOR_DIGIDESIGN,
189
+
.version = SPEC_VERSION,
187
190
.model_id = MODEL_RACK,
188
191
},
189
192
{}
+29
-4
sound/firewire/tascam/tascam.c
+29
-4
sound/firewire/tascam/tascam.c
···
39
39
.midi_capture_ports = 2,
40
40
.midi_playback_ports = 4,
41
41
},
42
-
// This kernel module doesn't support FE-8 because the most of features
43
-
// can be implemented in userspace without any specific support of this
44
-
// module.
45
42
};
46
43
47
44
static int identify_model(struct snd_tscm *tscm)
···
208
211
}
209
212
210
213
static const struct ieee1394_device_id snd_tscm_id_table[] = {
214
+
// Tascam, FW-1884.
211
215
{
212
216
.match_flags = IEEE1394_MATCH_VENDOR_ID |
213
-
IEEE1394_MATCH_SPECIFIER_ID,
217
+
IEEE1394_MATCH_SPECIFIER_ID |
218
+
IEEE1394_MATCH_VERSION,
214
219
.vendor_id = 0x00022e,
215
220
.specifier_id = 0x00022e,
221
+
.version = 0x800000,
222
+
},
223
+
// Tascam, FE-8 (.version = 0x800001)
224
+
// This kernel module doesn't support FE-8 because the most of features
225
+
// can be implemented in userspace without any specific support of this
226
+
// module.
227
+
//
228
+
// .version = 0x800002 is unknown.
229
+
//
230
+
// Tascam, FW-1082.
231
+
{
232
+
.match_flags = IEEE1394_MATCH_VENDOR_ID |
233
+
IEEE1394_MATCH_SPECIFIER_ID |
234
+
IEEE1394_MATCH_VERSION,
235
+
.vendor_id = 0x00022e,
236
+
.specifier_id = 0x00022e,
237
+
.version = 0x800003,
238
+
},
239
+
// Tascam, FW-1804.
240
+
{
241
+
.match_flags = IEEE1394_MATCH_VENDOR_ID |
242
+
IEEE1394_MATCH_SPECIFIER_ID |
243
+
IEEE1394_MATCH_VERSION,
244
+
.vendor_id = 0x00022e,
245
+
.specifier_id = 0x00022e,
246
+
.version = 0x800004,
216
247
},
217
248
{}
218
249
};
+2
sound/hda/hdac_device.c
+2
sound/hda/hdac_device.c
···
127
127
void snd_hdac_device_exit(struct hdac_device *codec)
128
128
{
129
129
pm_runtime_put_noidle(&codec->dev);
130
+
/* keep balance of runtime PM child_count in parent device */
131
+
pm_runtime_set_suspended(&codec->dev);
130
132
snd_hdac_bus_remove_device(codec->bus, codec);
131
133
kfree(codec->vendor_name);
132
134
kfree(codec->chip_name);
+5
-5
sound/hda/intel-dsp-config.c
+5
-5
sound/hda/intel-dsp-config.c
···
54
54
#endif
55
55
/*
56
56
* Apollolake (Broxton-P)
57
-
* the legacy HDaudio driver is used except on Up Squared (SOF) and
57
+
* the legacy HDAudio driver is used except on Up Squared (SOF) and
58
58
* Chromebooks (SST)
59
59
*/
60
60
#if IS_ENABLED(CONFIG_SND_SOC_SOF_APOLLOLAKE)
···
89
89
},
90
90
#endif
91
91
/*
92
-
* Skylake and Kabylake use legacy HDaudio driver except for Google
92
+
* Skylake and Kabylake use legacy HDAudio driver except for Google
93
93
* Chromebooks (SST)
94
94
*/
95
95
···
135
135
#endif
136
136
137
137
/*
138
-
* Geminilake uses legacy HDaudio driver except for Google
138
+
* Geminilake uses legacy HDAudio driver except for Google
139
139
* Chromebooks
140
140
*/
141
141
/* Geminilake */
···
157
157
158
158
/*
159
159
* CoffeeLake, CannonLake, CometLake, IceLake, TigerLake use legacy
160
-
* HDaudio driver except for Google Chromebooks and when DMICs are
160
+
* HDAudio driver except for Google Chromebooks and when DMICs are
161
161
* present. Two cases are required since Coreboot does not expose NHLT
162
162
* tables.
163
163
*
···
391
391
if (pci->class == 0x040300)
392
392
return SND_INTEL_DSP_DRIVER_LEGACY;
393
393
if (pci->class != 0x040100 && pci->class != 0x040380) {
394
-
dev_err(&pci->dev, "Unknown PCI class/subclass/prog-if information (0x%06x) found, selecting HDA legacy driver\n", pci->class);
394
+
dev_err(&pci->dev, "Unknown PCI class/subclass/prog-if information (0x%06x) found, selecting HDAudio legacy driver\n", pci->class);
395
395
return SND_INTEL_DSP_DRIVER_LEGACY;
396
396
}
397
397
+4
-5
sound/pci/asihpi/asihpi.c
+4
-5
sound/pci/asihpi/asihpi.c
···
921
921
add_timer(&dpcm->timer);
922
922
}
923
923
924
-
static void snd_card_asihpi_int_task(unsigned long data)
924
+
static void snd_card_asihpi_int_task(struct tasklet_struct *t)
925
925
{
926
-
struct hpi_adapter *a = (struct hpi_adapter *)data;
927
-
struct snd_card_asihpi *asihpi;
926
+
struct snd_card_asihpi *asihpi = from_tasklet(asihpi, t, t);
927
+
struct hpi_adapter *a = asihpi->hpi;
928
928
929
929
WARN_ON(!a || !a->snd_card || !a->snd_card->private_data);
930
930
asihpi = (struct snd_card_asihpi *)a->snd_card->private_data;
···
2871
2871
if (hpi->interrupt_mode) {
2872
2872
asihpi->pcm_start = snd_card_asihpi_pcm_int_start;
2873
2873
asihpi->pcm_stop = snd_card_asihpi_pcm_int_stop;
2874
-
tasklet_init(&asihpi->t, snd_card_asihpi_int_task,
2875
-
(unsigned long)hpi);
2874
+
tasklet_setup(&asihpi->t, snd_card_asihpi_int_task);
2876
2875
hpi->interrupt_callback = snd_card_asihpi_isr;
2877
2876
} else {
2878
2877
asihpi->pcm_start = snd_card_asihpi_pcm_timer_start;
+2
-1
sound/pci/ca0106/ca0106_main.c
+2
-1
sound/pci/ca0106/ca0106_main.c
+3
-4
sound/pci/hda/hda_intel.c
+3
-4
sound/pci/hda/hda_intel.c
···
2127
2127
*/
2128
2128
if (dmic_detect) {
2129
2129
err = snd_intel_dsp_driver_probe(pci);
2130
-
if (err != SND_INTEL_DSP_DRIVER_ANY &&
2131
-
err != SND_INTEL_DSP_DRIVER_LEGACY)
2130
+
if (err != SND_INTEL_DSP_DRIVER_ANY && err != SND_INTEL_DSP_DRIVER_LEGACY) {
2131
+
dev_dbg(&pci->dev, "HDAudio driver not selected, aborting probe\n");
2132
2132
return -ENODEV;
2133
+
}
2133
2134
} else {
2134
2135
dev_warn(&pci->dev, "dmic_detect option is deprecated, pass snd-intel-dspcfg.dsp_driver=1 option instead\n");
2135
2136
}
···
2746
2745
.driver_data = AZX_DRIVER_GENERIC | AZX_DCAPS_PRESET_ATI_HDMI },
2747
2746
/* Zhaoxin */
2748
2747
{ PCI_DEVICE(0x1d17, 0x3288), .driver_data = AZX_DRIVER_ZHAOXIN },
2749
-
/* Loongson */
2750
-
{ PCI_DEVICE(0x0014, 0x7a07), .driver_data = AZX_DRIVER_GENERIC },
2751
2748
{ 0, }
2752
2749
};
2753
2750
MODULE_DEVICE_TABLE(pci, azx_ids);
+7
sound/pci/hda/hda_tegra.c
+7
sound/pci/hda/hda_tegra.c
···
179
179
struct hda_tegra *hda = container_of(chip, struct hda_tegra, chip);
180
180
181
181
if (chip && chip->running) {
182
+
/* enable controller wake up event */
183
+
azx_writew(chip, WAKEEN, azx_readw(chip, WAKEEN) |
184
+
STATESTS_INT_MASK);
185
+
182
186
azx_stop_chip(chip);
183
187
azx_enter_link_reset(chip);
184
188
}
···
204
200
if (chip && chip->running) {
205
201
hda_tegra_init(hda);
206
202
azx_init_chip(chip, 1);
203
+
/* disable controller wake up event*/
204
+
azx_writew(chip, WAKEEN, azx_readw(chip, WAKEEN) &
205
+
~STATESTS_INT_MASK);
207
206
}
208
207
209
208
return 0;
+7
sound/pci/hda/patch_hdmi.c
+7
sound/pci/hda/patch_hdmi.c
···
2794
2794
hda_nid_t cvt_nid)
2795
2795
{
2796
2796
if (per_pin) {
2797
+
haswell_verify_D0(codec, per_pin->cvt_nid, per_pin->pin_nid);
2797
2798
snd_hda_set_dev_select(codec, per_pin->pin_nid,
2798
2799
per_pin->dev_id);
2799
2800
intel_verify_pin_cvt_connect(codec, per_pin);
···
3735
3734
3736
3735
static int patch_tegra_hdmi(struct hda_codec *codec)
3737
3736
{
3737
+
struct hdmi_spec *spec;
3738
3738
int err;
3739
3739
3740
3740
err = patch_generic_hdmi(codec);
···
3743
3741
return err;
3744
3742
3745
3743
codec->patch_ops.build_pcms = tegra_hdmi_build_pcms;
3744
+
spec = codec->spec;
3745
+
spec->chmap.ops.chmap_cea_alloc_validate_get_type =
3746
+
nvhdmi_chmap_cea_alloc_validate_get_type;
3747
+
spec->chmap.ops.chmap_validate = nvhdmi_chmap_validate;
3746
3748
3747
3749
return 0;
3748
3750
}
···
4269
4263
HDA_CODEC_ENTRY(0x8086280d, "Geminilake HDMI", patch_i915_glk_hdmi),
4270
4264
HDA_CODEC_ENTRY(0x8086280f, "Icelake HDMI", patch_i915_icl_hdmi),
4271
4265
HDA_CODEC_ENTRY(0x80862812, "Tigerlake HDMI", patch_i915_tgl_hdmi),
4266
+
HDA_CODEC_ENTRY(0x80862816, "Rocketlake HDMI", patch_i915_tgl_hdmi),
4272
4267
HDA_CODEC_ENTRY(0x8086281a, "Jasperlake HDMI", patch_i915_icl_hdmi),
4273
4268
HDA_CODEC_ENTRY(0x8086281b, "Elkhartlake HDMI", patch_i915_icl_hdmi),
4274
4269
HDA_CODEC_ENTRY(0x80862880, "CedarTrail HDMI", patch_generic_hdmi),
+44
-2
sound/pci/hda/patch_realtek.c
+44
-2
sound/pci/hda/patch_realtek.c
···
2475
2475
SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2476
2476
SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2477
2477
SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2478
+
SND_PCI_QUIRK(0x1462, 0x9c37, "MSI X570-A PRO", ALC1220_FIXUP_CLEVO_P950),
2478
2479
SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2479
2480
SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2480
2481
SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
···
5868
5867
}
5869
5868
}
5870
5869
5870
+
/* Quirk for Thinkpad X1 7th and 8th Gen
5871
+
* The following fixed routing needed
5872
+
* DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
5873
+
* DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
5874
+
* DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
5875
+
*/
5876
+
static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
5877
+
const struct hda_fixup *fix, int action)
5878
+
{
5879
+
static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
5880
+
static const hda_nid_t preferred_pairs[] = {
5881
+
0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
5882
+
};
5883
+
struct alc_spec *spec = codec->spec;
5884
+
5885
+
switch (action) {
5886
+
case HDA_FIXUP_ACT_PRE_PROBE:
5887
+
snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
5888
+
spec->gen.preferred_dacs = preferred_pairs;
5889
+
break;
5890
+
case HDA_FIXUP_ACT_BUILD:
5891
+
/* The generic parser creates somewhat unintuitive volume ctls
5892
+
* with the fixed routing above, and the shared DAC2 may be
5893
+
* confusing for PA.
5894
+
* Rename those to unique names so that PA doesn't touch them
5895
+
* and use only Master volume.
5896
+
*/
5897
+
rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
5898
+
rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
5899
+
break;
5900
+
}
5901
+
}
5902
+
5871
5903
static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
5872
5904
const struct hda_fixup *fix,
5873
5905
int action)
···
6169
6135
ALC289_FIXUP_DUAL_SPK,
6170
6136
ALC294_FIXUP_SPK2_TO_DAC1,
6171
6137
ALC294_FIXUP_ASUS_DUAL_SPK,
6138
+
ALC285_FIXUP_THINKPAD_X1_GEN7,
6172
6139
ALC285_FIXUP_THINKPAD_HEADSET_JACK,
6173
6140
ALC294_FIXUP_ASUS_HPE,
6174
6141
ALC294_FIXUP_ASUS_COEF_1B,
···
7315
7280
.chained = true,
7316
7281
.chain_id = ALC294_FIXUP_SPK2_TO_DAC1
7317
7282
},
7283
+
[ALC285_FIXUP_THINKPAD_X1_GEN7] = {
7284
+
.type = HDA_FIXUP_FUNC,
7285
+
.v.func = alc285_fixup_thinkpad_x1_gen7,
7286
+
.chained = true,
7287
+
.chain_id = ALC269_FIXUP_THINKPAD_ACPI
7288
+
},
7318
7289
[ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
7319
7290
.type = HDA_FIXUP_FUNC,
7320
7291
.v.func = alc_fixup_headset_jack,
7321
7292
.chained = true,
7322
-
.chain_id = ALC285_FIXUP_SPEAKER2_TO_DAC1
7293
+
.chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
7323
7294
},
7324
7295
[ALC294_FIXUP_ASUS_HPE] = {
7325
7296
.type = HDA_FIXUP_VERBS,
···
7736
7695
SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7737
7696
SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7738
7697
SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7739
-
SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7698
+
SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7699
+
SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7740
7700
SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
7741
7701
SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7742
7702
SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
+3
-3
sound/pci/riptide/riptide.c
+3
-3
sound/pci/riptide/riptide.c
···
1070
1070
return 0;
1071
1071
}
1072
1072
1073
-
static void riptide_handleirq(unsigned long dev_id)
1073
+
static void riptide_handleirq(struct tasklet_struct *t)
1074
1074
{
1075
-
struct snd_riptide *chip = (void *)dev_id;
1075
+
struct snd_riptide *chip = from_tasklet(chip, t, riptide_tq);
1076
1076
struct cmdif *cif = chip->cif;
1077
1077
struct snd_pcm_substream *substream[PLAYBACK_SUBSTREAMS + 1];
1078
1078
struct snd_pcm_runtime *runtime;
···
1843
1843
chip->received_irqs = 0;
1844
1844
chip->handled_irqs = 0;
1845
1845
chip->cif = NULL;
1846
-
tasklet_init(&chip->riptide_tq, riptide_handleirq, (unsigned long)chip);
1846
+
tasklet_setup(&chip->riptide_tq, riptide_handleirq);
1847
1847
1848
1848
if ((chip->res_port =
1849
1849
request_region(chip->port, 64, "RIPTIDE")) == NULL) {
+3
-3
sound/pci/rme9652/hdsp.c
+3
-3
sound/pci/rme9652/hdsp.c
···
3791
3791
return 0;
3792
3792
}
3793
3793
3794
-
static void hdsp_midi_tasklet(unsigned long arg)
3794
+
static void hdsp_midi_tasklet(struct tasklet_struct *t)
3795
3795
{
3796
-
struct hdsp *hdsp = (struct hdsp *)arg;
3796
+
struct hdsp *hdsp = from_tasklet(hdsp, t, midi_tasklet);
3797
3797
3798
3798
if (hdsp->midi[0].pending)
3799
3799
snd_hdsp_midi_input_read (&hdsp->midi[0]);
···
5182
5182
5183
5183
spin_lock_init(&hdsp->lock);
5184
5184
5185
-
tasklet_init(&hdsp->midi_tasklet, hdsp_midi_tasklet, (unsigned long)hdsp);
5185
+
tasklet_setup(&hdsp->midi_tasklet, hdsp_midi_tasklet);
5186
5186
5187
5187
pci_read_config_word(hdsp->pci, PCI_CLASS_REVISION, &hdsp->firmware_rev);
5188
5188
hdsp->firmware_rev &= 0xff;
+3
-4
sound/pci/rme9652/hdspm.c
+3
-4
sound/pci/rme9652/hdspm.c
···
2169
2169
}
2170
2170
2171
2171
2172
-
static void hdspm_midi_tasklet(unsigned long arg)
2172
+
static void hdspm_midi_tasklet(struct tasklet_struct *t)
2173
2173
{
2174
-
struct hdspm *hdspm = (struct hdspm *)arg;
2174
+
struct hdspm *hdspm = from_tasklet(hdspm, t, midi_tasklet);
2175
2175
int i = 0;
2176
2176
2177
2177
while (i < hdspm->midiPorts) {
···
6836
6836
6837
6837
}
6838
6838
6839
-
tasklet_init(&hdspm->midi_tasklet,
6840
-
hdspm_midi_tasklet, (unsigned long) hdspm);
6839
+
tasklet_setup(&hdspm->midi_tasklet, hdspm_midi_tasklet);
6841
6840
6842
6841
6843
6842
if (hdspm->io_type != MADIface) {
+3
-4
sound/soc/fsl/fsl_esai.c
+3
-4
sound/soc/fsl/fsl_esai.c
···
708
708
ESAI_xFCR_xFR, 0);
709
709
}
710
710
711
-
static void fsl_esai_hw_reset(unsigned long arg)
711
+
static void fsl_esai_hw_reset(struct tasklet_struct *t)
712
712
{
713
-
struct fsl_esai *esai_priv = (struct fsl_esai *)arg;
713
+
struct fsl_esai *esai_priv = from_tasklet(esai_priv, t, task);
714
714
bool tx = true, rx = false, enabled[2];
715
715
unsigned long lock_flags;
716
716
u32 tfcr, rfcr;
···
1070
1070
return ret;
1071
1071
}
1072
1072
1073
-
tasklet_init(&esai_priv->task, fsl_esai_hw_reset,
1074
-
(unsigned long)esai_priv);
1073
+
tasklet_setup(&esai_priv->task, fsl_esai_hw_reset);
1075
1074
1076
1075
pm_runtime_enable(&pdev->dev);
1077
1076
+4
-6
sound/soc/sh/siu_pcm.c
+4
-6
sound/soc/sh/siu_pcm.c
···
198
198
return 0;
199
199
}
200
200
201
-
static void siu_io_tasklet(unsigned long data)
201
+
static void siu_io_tasklet(struct tasklet_struct *t)
202
202
{
203
-
struct siu_stream *siu_stream = (struct siu_stream *)data;
203
+
struct siu_stream *siu_stream = from_tasklet(siu_stream, t, tasklet);
204
204
struct snd_pcm_substream *substream = siu_stream->substream;
205
205
struct device *dev = substream->pcm->card->dev;
206
206
struct snd_pcm_runtime *rt = substream->runtime;
···
520
520
(*port_info)->pcm = pcm;
521
521
522
522
/* IO tasklets */
523
-
tasklet_init(&(*port_info)->playback.tasklet, siu_io_tasklet,
524
-
(unsigned long)&(*port_info)->playback);
525
-
tasklet_init(&(*port_info)->capture.tasklet, siu_io_tasklet,
526
-
(unsigned long)&(*port_info)->capture);
523
+
tasklet_setup(&(*port_info)->playback.tasklet, siu_io_tasklet);
524
+
tasklet_setup(&(*port_info)->capture.tasklet, siu_io_tasklet);
527
525
}
528
526
529
527
dev_info(card->dev, "SuperH SIU driver initialized.\n");
+3
-4
sound/soc/txx9/txx9aclc.c
+3
-4
sound/soc/txx9/txx9aclc.c
···
134
134
135
135
#define NR_DMA_CHAIN 2
136
136
137
-
static void txx9aclc_dma_tasklet(unsigned long data)
137
+
static void txx9aclc_dma_tasklet(struct tasklet_struct *t)
138
138
{
139
-
struct txx9aclc_dmadata *dmadata = (struct txx9aclc_dmadata *)data;
139
+
struct txx9aclc_dmadata *dmadata = from_tasklet(dmadata, t, tasklet);
140
140
struct dma_chan *chan = dmadata->dma_chan;
141
141
struct dma_async_tx_descriptor *desc;
142
142
struct snd_pcm_substream *substream = dmadata->substream;
···
352
352
"playback" : "capture");
353
353
return -EBUSY;
354
354
}
355
-
tasklet_init(&dmadata->tasklet, txx9aclc_dma_tasklet,
356
-
(unsigned long)dmadata);
355
+
tasklet_setup(&dmadata->tasklet, txx9aclc_dma_tasklet);
357
356
return 0;
358
357
}
359
358
+3
-4
sound/usb/midi.c
+3
-4
sound/usb/midi.c
···
344
344
spin_unlock_irqrestore(&ep->buffer_lock, flags);
345
345
}
346
346
347
-
static void snd_usbmidi_out_tasklet(unsigned long data)
347
+
static void snd_usbmidi_out_tasklet(struct tasklet_struct *t)
348
348
{
349
-
struct snd_usb_midi_out_endpoint *ep =
350
-
(struct snd_usb_midi_out_endpoint *) data;
349
+
struct snd_usb_midi_out_endpoint *ep = from_tasklet(ep, t, tasklet);
351
350
352
351
snd_usbmidi_do_output(ep);
353
352
}
···
1440
1441
}
1441
1442
1442
1443
spin_lock_init(&ep->buffer_lock);
1443
-
tasklet_init(&ep->tasklet, snd_usbmidi_out_tasklet, (unsigned long)ep);
1444
+
tasklet_setup(&ep->tasklet, snd_usbmidi_out_tasklet);
1444
1445
init_waitqueue_head(&ep->drain_wait);
1445
1446
1446
1447
for (i = 0; i < 0x10; ++i)
+3
-4
sound/usb/misc/ua101.c
+3
-4
sound/usb/misc/ua101.c
···
247
247
*value -= ua->playback.queue_length;
248
248
}
249
249
250
-
static void playback_tasklet(unsigned long data)
250
+
static void playback_tasklet(struct tasklet_struct *t)
251
251
{
252
-
struct ua101 *ua = (void *)data;
252
+
struct ua101 *ua = from_tasklet(ua, t, playback_tasklet);
253
253
unsigned long flags;
254
254
unsigned int frames;
255
255
struct ua101_urb *urb;
···
1218
1218
spin_lock_init(&ua->lock);
1219
1219
mutex_init(&ua->mutex);
1220
1220
INIT_LIST_HEAD(&ua->ready_playback_urbs);
1221
-
tasklet_init(&ua->playback_tasklet,
1222
-
playback_tasklet, (unsigned long)ua);
1221
+
tasklet_setup(&ua->playback_tasklet, playback_tasklet);
1223
1222
init_waitqueue_head(&ua->alsa_capture_wait);
1224
1223
init_waitqueue_head(&ua->rate_feedback_wait);
1225
1224
init_waitqueue_head(&ua->alsa_playback_wait);
+2
sound/usb/pcm.c
+2
sound/usb/pcm.c
···
369
369
case USB_ID(0x07fd, 0x0008): /* MOTU M Series */
370
370
case USB_ID(0x31e9, 0x0001): /* Solid State Logic SSL2 */
371
371
case USB_ID(0x31e9, 0x0002): /* Solid State Logic SSL2+ */
372
+
case USB_ID(0x0499, 0x172f): /* Steinberg UR22C */
372
373
case USB_ID(0x0d9a, 0x00df): /* RTX6001 */
373
374
ep = 0x81;
374
375
ifnum = 2;
375
376
goto add_sync_ep_from_ifnum;
376
377
case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */
378
+
case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */
377
379
ep = 0x82;
378
380
ifnum = 0;
379
381
goto add_sync_ep_from_ifnum;
+67
-11
sound/usb/quirks-table.h
+67
-11
sound/usb/quirks-table.h
···
2827
2827
/* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */
2828
2828
{
2829
2829
USB_DEVICE(0x17aa, 0x1046),
2830
-
QUIRK_DEVICE_PROFILE("Lenovo", "ThinkStation P620 Rear",
2831
-
"Lenovo-ThinkStation-P620-Rear"),
2830
+
.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2831
+
.vendor_name = "Lenovo",
2832
+
.product_name = "ThinkStation P620 Rear",
2833
+
.profile_name = "Lenovo-ThinkStation-P620-Rear",
2834
+
.ifnum = QUIRK_ANY_INTERFACE,
2835
+
.type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2836
+
}
2832
2837
},
2833
2838
/* Lenovo ThinkStation P620 Internal Speaker + Front Headset */
2834
2839
{
2835
2840
USB_DEVICE(0x17aa, 0x104d),
2836
-
QUIRK_DEVICE_PROFILE("Lenovo", "ThinkStation P620 Main",
2837
-
"Lenovo-ThinkStation-P620-Main"),
2841
+
.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2842
+
.vendor_name = "Lenovo",
2843
+
.product_name = "ThinkStation P620 Main",
2844
+
.profile_name = "Lenovo-ThinkStation-P620-Main",
2845
+
.ifnum = QUIRK_ANY_INTERFACE,
2846
+
.type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2847
+
}
2838
2848
},
2839
2849
2840
2850
/* Native Instruments MK2 series */
···
3559
3549
{
3560
3550
/*
3561
3551
* Pioneer DJ DJM-250MK2
3562
-
* PCM is 8 channels out @ 48 fixed (endpoints 0x01).
3563
-
* The output from computer to the mixer is usable.
3552
+
* PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3553
+
* and 8 channels in @ 48 fixed (endpoint 0x82).
3564
3554
*
3565
-
* The input (phono or line to computer) is not working.
3566
-
* It should be at endpoint 0x82 and probably also 8 channels,
3567
-
* but it seems that it works only with Pioneer proprietary software.
3568
-
* Even on officially supported OS, the Audacity was unable to record
3569
-
* and Mixxx to recognize the control vinyls.
3555
+
* Both playback and recording is working, even simultaneously.
3556
+
*
3557
+
* Playback channels could be mapped to:
3558
+
* - CH1
3559
+
* - CH2
3560
+
* - AUX
3561
+
*
3562
+
* Recording channels could be mapped to:
3563
+
* - Post CH1 Fader
3564
+
* - Post CH2 Fader
3565
+
* - Cross Fader A
3566
+
* - Cross Fader B
3567
+
* - MIC
3568
+
* - AUX
3569
+
* - REC OUT
3570
+
*
3571
+
* There is remaining problem with recording directly from PHONO/LINE.
3572
+
* If we map a channel to:
3573
+
* - CH1 Control Tone PHONO
3574
+
* - CH1 Control Tone LINE
3575
+
* - CH2 Control Tone PHONO
3576
+
* - CH2 Control Tone LINE
3577
+
* it is silent.
3578
+
* There is no signal even on other operating systems with official drivers.
3579
+
* The signal appears only when a supported application is started.
3580
+
* This needs to be investigated yet...
3581
+
* (there is quite a lot communication on the USB in both directions)
3582
+
*
3583
+
* In current version this mixer could be used for playback
3584
+
* and for recording from vinyls (through Post CH* Fader)
3585
+
* but not for DVS (Digital Vinyl Systems) like in Mixxx.
3570
3586
*/
3571
3587
USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3572
3588
.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
···
3611
3575
.endpoint = 0x01,
3612
3576
.ep_attr = USB_ENDPOINT_XFER_ISOC|
3613
3577
USB_ENDPOINT_SYNC_ASYNC,
3578
+
.rates = SNDRV_PCM_RATE_48000,
3579
+
.rate_min = 48000,
3580
+
.rate_max = 48000,
3581
+
.nr_rates = 1,
3582
+
.rate_table = (unsigned int[]) { 48000 }
3583
+
}
3584
+
},
3585
+
{
3586
+
.ifnum = 0,
3587
+
.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3588
+
.data = &(const struct audioformat) {
3589
+
.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3590
+
.channels = 8, // inputs
3591
+
.iface = 0,
3592
+
.altsetting = 1,
3593
+
.altset_idx = 1,
3594
+
.endpoint = 0x82,
3595
+
.ep_attr = USB_ENDPOINT_XFER_ISOC|
3596
+
USB_ENDPOINT_SYNC_ASYNC|
3597
+
USB_ENDPOINT_USAGE_IMPLICIT_FB,
3614
3598
.rates = SNDRV_PCM_RATE_48000,
3615
3599
.rate_min = 48000,
3616
3600
.rate_max = 48000,
+11
sound/usb/quirks.c
+11
sound/usb/quirks.c
···
518
518
return 1; /* Continue with creating streams and mixer */
519
519
}
520
520
521
+
static int setup_disable_autosuspend(struct snd_usb_audio *chip,
522
+
struct usb_interface *iface,
523
+
struct usb_driver *driver,
524
+
const struct snd_usb_audio_quirk *quirk)
525
+
{
526
+
driver->supports_autosuspend = 0;
527
+
return 1; /* Continue with creating streams and mixer */
528
+
}
529
+
521
530
/*
522
531
* audio-interface quirks
523
532
*
···
566
557
[QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk,
567
558
[QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk,
568
559
[QUIRK_SETUP_FMT_AFTER_RESUME] = setup_fmt_after_resume_quirk,
560
+
[QUIRK_SETUP_DISABLE_AUTOSUSPEND] = setup_disable_autosuspend,
569
561
};
570
562
571
563
if (quirk->type < QUIRK_TYPE_COUNT) {
···
1503
1493
set_format_emu_quirk(subs, fmt);
1504
1494
break;
1505
1495
case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */
1496
+
case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */
1506
1497
pioneer_djm_set_format_quirk(subs);
1507
1498
break;
1508
1499
case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */
+1
sound/usb/usbaudio.h
+1
sound/usb/usbaudio.h