1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Presonus Studio 1810c driver for ALSA |
4 | * Copyright (C) 2019 Nick Kossifidis <mickflemm@gmail.com> |
5 | * |
6 | * Based on reverse engineering of the communication protocol |
7 | * between the windows driver / Univeral Control (UC) program |
8 | * and the device, through usbmon. |
9 | * |
10 | * For now this bypasses the mixer, with all channels split, |
11 | * so that the software can mix with greater flexibility. |
12 | * It also adds controls for the 4 buttons on the front of |
13 | * the device. |
14 | */ |
15 | |
16 | #include <linux/usb.h> |
17 | #include <linux/usb/audio-v2.h> |
18 | #include <linux/slab.h> |
19 | #include <sound/core.h> |
20 | #include <sound/control.h> |
21 | |
22 | #include "usbaudio.h" |
23 | #include "mixer.h" |
24 | #include "mixer_quirks.h" |
25 | #include "helper.h" |
26 | #include "mixer_s1810c.h" |
27 | |
28 | #define SC1810C_CMD_REQ 160 |
29 | #define SC1810C_CMD_REQTYPE \ |
30 | (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT) |
31 | #define SC1810C_CMD_F1 0x50617269 |
32 | #define SC1810C_CMD_F2 0x14 |
33 | |
34 | /* |
35 | * DISCLAIMER: These are just guesses based on the |
36 | * dumps I got. |
37 | * |
38 | * It seems like a selects between |
39 | * device (0), mixer (0x64) and output (0x65) |
40 | * |
41 | * For mixer (0x64): |
42 | * * b selects an input channel (see below). |
43 | * * c selects an output channel pair (see below). |
44 | * * d selects left (0) or right (1) of that pair. |
45 | * * e 0-> disconnect, 0x01000000-> connect, |
46 | * 0x0109-> used for stereo-linking channels, |
47 | * e is also used for setting volume levels |
48 | * in which case b is also set so I guess |
49 | * this way it is possible to set the volume |
50 | * level from the specified input to the |
51 | * specified output. |
52 | * |
53 | * IN Channels: |
54 | * 0 - 7 Mic/Inst/Line (Analog inputs) |
55 | * 8 - 9 S/PDIF |
56 | * 10 - 17 ADAT |
57 | * 18 - 35 DAW (Inputs from the host) |
58 | * |
59 | * OUT Channels (pairs): |
60 | * 0 -> Main out |
61 | * 1 -> Line1/2 |
62 | * 2 -> Line3/4 |
63 | * 3 -> S/PDIF |
64 | * 4 -> ADAT? |
65 | * |
66 | * For device (0): |
67 | * * b and c are not used, at least not on the |
68 | * dumps I got. |
69 | * * d sets the control id to be modified |
70 | * (see below). |
71 | * * e sets the setting for that control. |
72 | * (so for the switches I was interested |
73 | * in it's 0/1) |
74 | * |
75 | * For output (0x65): |
76 | * * b is the output channel (see above). |
77 | * * c is zero. |
78 | * * e I guess the same as with mixer except 0x0109 |
79 | * which I didn't see in my dumps. |
80 | * |
81 | * The two fixed fields have the same values for |
82 | * mixer and output but a different set for device. |
83 | */ |
84 | struct s1810c_ctl_packet { |
85 | u32 a; |
86 | u32 b; |
87 | u32 fixed1; |
88 | u32 fixed2; |
89 | u32 c; |
90 | u32 d; |
91 | u32 e; |
92 | }; |
93 | |
94 | #define SC1810C_CTL_LINE_SW 0 |
95 | #define SC1810C_CTL_MUTE_SW 1 |
96 | #define SC1810C_CTL_AB_SW 3 |
97 | #define SC1810C_CTL_48V_SW 4 |
98 | |
99 | #define SC1810C_SET_STATE_REQ 161 |
100 | #define SC1810C_SET_STATE_REQTYPE SC1810C_CMD_REQTYPE |
101 | #define SC1810C_SET_STATE_F1 0x64656D73 |
102 | #define SC1810C_SET_STATE_F2 0xF4 |
103 | |
104 | #define SC1810C_GET_STATE_REQ 162 |
105 | #define SC1810C_GET_STATE_REQTYPE \ |
106 | (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN) |
107 | #define SC1810C_GET_STATE_F1 SC1810C_SET_STATE_F1 |
108 | #define SC1810C_GET_STATE_F2 SC1810C_SET_STATE_F2 |
109 | |
110 | #define SC1810C_STATE_F1_IDX 2 |
111 | #define SC1810C_STATE_F2_IDX 3 |
112 | |
113 | /* |
114 | * This packet includes mixer volumes and |
115 | * various other fields, it's an extended |
116 | * version of ctl_packet, with a and b |
117 | * being zero and different f1/f2. |
118 | */ |
119 | struct s1810c_state_packet { |
120 | u32 fields[63]; |
121 | }; |
122 | |
123 | #define SC1810C_STATE_48V_SW 58 |
124 | #define SC1810C_STATE_LINE_SW 59 |
125 | #define SC1810C_STATE_MUTE_SW 60 |
126 | #define SC1810C_STATE_AB_SW 62 |
127 | |
128 | struct s1810_mixer_state { |
129 | uint16_t seqnum; |
130 | struct mutex usb_mutex; |
131 | struct mutex data_mutex; |
132 | }; |
133 | |
134 | static int |
135 | snd_s1810c_send_ctl_packet(struct usb_device *dev, u32 a, |
136 | u32 b, u32 c, u32 d, u32 e) |
137 | { |
138 | struct s1810c_ctl_packet pkt = { 0 }; |
139 | int ret = 0; |
140 | |
141 | pkt.fixed1 = SC1810C_CMD_F1; |
142 | pkt.fixed2 = SC1810C_CMD_F2; |
143 | |
144 | pkt.a = a; |
145 | pkt.b = b; |
146 | pkt.c = c; |
147 | pkt.d = d; |
148 | /* |
149 | * Value for settings 0/1 for this |
150 | * output channel is always 0 (probably because |
151 | * there is no ADAT output on 1810c) |
152 | */ |
153 | pkt.e = (c == 4) ? 0 : e; |
154 | |
155 | ret = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), |
156 | SC1810C_CMD_REQ, |
157 | SC1810C_CMD_REQTYPE, value: 0, index: 0, data: &pkt, size: sizeof(pkt)); |
158 | if (ret < 0) { |
159 | dev_warn(&dev->dev, "could not send ctl packet\n" ); |
160 | return ret; |
161 | } |
162 | return 0; |
163 | } |
164 | |
165 | /* |
166 | * When opening Universal Control the program periodically |
167 | * sends and receives state packets for syncinc state between |
168 | * the device and the host. |
169 | * |
170 | * Note that if we send only the request to get data back we'll |
171 | * get an error, we need to first send an empty state packet and |
172 | * then ask to receive a filled. Their seqnumbers must also match. |
173 | */ |
174 | static int |
175 | snd_sc1810c_get_status_field(struct usb_device *dev, |
176 | u32 *field, int field_idx, uint16_t *seqnum) |
177 | { |
178 | struct s1810c_state_packet pkt_out = { { 0 } }; |
179 | struct s1810c_state_packet pkt_in = { { 0 } }; |
180 | int ret = 0; |
181 | |
182 | pkt_out.fields[SC1810C_STATE_F1_IDX] = SC1810C_SET_STATE_F1; |
183 | pkt_out.fields[SC1810C_STATE_F2_IDX] = SC1810C_SET_STATE_F2; |
184 | ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), |
185 | SC1810C_SET_STATE_REQ, |
186 | SC1810C_SET_STATE_REQTYPE, |
187 | value: (*seqnum), index: 0, data: &pkt_out, size: sizeof(pkt_out)); |
188 | if (ret < 0) { |
189 | dev_warn(&dev->dev, "could not send state packet (%d)\n" , ret); |
190 | return ret; |
191 | } |
192 | |
193 | ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), |
194 | SC1810C_GET_STATE_REQ, |
195 | SC1810C_GET_STATE_REQTYPE, |
196 | value: (*seqnum), index: 0, data: &pkt_in, size: sizeof(pkt_in)); |
197 | if (ret < 0) { |
198 | dev_warn(&dev->dev, "could not get state field %u (%d)\n" , |
199 | field_idx, ret); |
200 | return ret; |
201 | } |
202 | |
203 | (*field) = pkt_in.fields[field_idx]; |
204 | (*seqnum)++; |
205 | return 0; |
206 | } |
207 | |
208 | /* |
209 | * This is what I got when bypassing the mixer with |
210 | * all channels split. I'm not 100% sure of what's going |
211 | * on, I could probably clean this up based on my observations |
212 | * but I prefer to keep the same behavior as the windows driver. |
213 | */ |
214 | static int snd_s1810c_init_mixer_maps(struct snd_usb_audio *chip) |
215 | { |
216 | u32 a, b, c, e, n, off; |
217 | struct usb_device *dev = chip->dev; |
218 | |
219 | /* Set initial volume levels ? */ |
220 | a = 0x64; |
221 | e = 0xbc; |
222 | for (n = 0; n < 2; n++) { |
223 | off = n * 18; |
224 | for (b = off; b < 18 + off; b++) { |
225 | /* This channel to all outputs ? */ |
226 | for (c = 0; c <= 8; c++) { |
227 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 0, e); |
228 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 1, e); |
229 | } |
230 | /* This channel to main output (again) */ |
231 | snd_s1810c_send_ctl_packet(dev, a, b, c: 0, d: 0, e); |
232 | snd_s1810c_send_ctl_packet(dev, a, b, c: 0, d: 1, e); |
233 | } |
234 | /* |
235 | * I noticed on UC that DAW channels have different |
236 | * initial volumes, so this makes sense. |
237 | */ |
238 | e = 0xb53bf0; |
239 | } |
240 | |
241 | /* Connect analog outputs ? */ |
242 | a = 0x65; |
243 | e = 0x01000000; |
244 | for (b = 1; b < 3; b++) { |
245 | snd_s1810c_send_ctl_packet(dev, a, b, c: 0, d: 0, e); |
246 | snd_s1810c_send_ctl_packet(dev, a, b, c: 0, d: 1, e); |
247 | } |
248 | snd_s1810c_send_ctl_packet(dev, a, b: 0, c: 0, d: 0, e); |
249 | snd_s1810c_send_ctl_packet(dev, a, b: 0, c: 0, d: 1, e); |
250 | |
251 | /* Set initial volume levels for S/PDIF mappings ? */ |
252 | a = 0x64; |
253 | e = 0xbc; |
254 | c = 3; |
255 | for (n = 0; n < 2; n++) { |
256 | off = n * 18; |
257 | for (b = off; b < 18 + off; b++) { |
258 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 0, e); |
259 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 1, e); |
260 | } |
261 | e = 0xb53bf0; |
262 | } |
263 | |
264 | /* Connect S/PDIF output ? */ |
265 | a = 0x65; |
266 | e = 0x01000000; |
267 | snd_s1810c_send_ctl_packet(dev, a, b: 3, c: 0, d: 0, e); |
268 | snd_s1810c_send_ctl_packet(dev, a, b: 3, c: 0, d: 1, e); |
269 | |
270 | /* Connect all outputs (again) ? */ |
271 | a = 0x65; |
272 | e = 0x01000000; |
273 | for (b = 0; b < 4; b++) { |
274 | snd_s1810c_send_ctl_packet(dev, a, b, c: 0, d: 0, e); |
275 | snd_s1810c_send_ctl_packet(dev, a, b, c: 0, d: 1, e); |
276 | } |
277 | |
278 | /* Basic routing to get sound out of the device */ |
279 | a = 0x64; |
280 | e = 0x01000000; |
281 | for (c = 0; c < 4; c++) { |
282 | for (b = 0; b < 36; b++) { |
283 | if ((c == 0 && b == 18) || /* DAW1/2 -> Main */ |
284 | (c == 1 && b == 20) || /* DAW3/4 -> Line3/4 */ |
285 | (c == 2 && b == 22) || /* DAW4/5 -> Line5/6 */ |
286 | (c == 3 && b == 24)) { /* DAW5/6 -> S/PDIF */ |
287 | /* Left */ |
288 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 0, e); |
289 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 1, e: 0); |
290 | b++; |
291 | /* Right */ |
292 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 0, e: 0); |
293 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 1, e); |
294 | } else { |
295 | /* Leave the rest disconnected */ |
296 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 0, e: 0); |
297 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 1, e: 0); |
298 | } |
299 | } |
300 | } |
301 | |
302 | /* Set initial volume levels for S/PDIF (again) ? */ |
303 | a = 0x64; |
304 | e = 0xbc; |
305 | c = 3; |
306 | for (n = 0; n < 2; n++) { |
307 | off = n * 18; |
308 | for (b = off; b < 18 + off; b++) { |
309 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 0, e); |
310 | snd_s1810c_send_ctl_packet(dev, a, b, c, d: 1, e); |
311 | } |
312 | e = 0xb53bf0; |
313 | } |
314 | |
315 | /* Connect S/PDIF outputs (again) ? */ |
316 | a = 0x65; |
317 | e = 0x01000000; |
318 | snd_s1810c_send_ctl_packet(dev, a, b: 3, c: 0, d: 0, e); |
319 | snd_s1810c_send_ctl_packet(dev, a, b: 3, c: 0, d: 1, e); |
320 | |
321 | /* Again ? */ |
322 | snd_s1810c_send_ctl_packet(dev, a, b: 3, c: 0, d: 0, e); |
323 | snd_s1810c_send_ctl_packet(dev, a, b: 3, c: 0, d: 1, e); |
324 | |
325 | return 0; |
326 | } |
327 | |
328 | /* |
329 | * Sync state with the device and retrieve the requested field, |
330 | * whose index is specified in (kctl->private_value & 0xFF), |
331 | * from the received fields array. |
332 | */ |
333 | static int |
334 | snd_s1810c_get_switch_state(struct usb_mixer_interface *mixer, |
335 | struct snd_kcontrol *kctl, u32 *state) |
336 | { |
337 | struct snd_usb_audio *chip = mixer->chip; |
338 | struct s1810_mixer_state *private = mixer->private_data; |
339 | u32 field = 0; |
340 | u32 ctl_idx = (u32) (kctl->private_value & 0xFF); |
341 | int ret = 0; |
342 | |
343 | mutex_lock(&private->usb_mutex); |
344 | ret = snd_sc1810c_get_status_field(dev: chip->dev, field: &field, |
345 | field_idx: ctl_idx, seqnum: &private->seqnum); |
346 | if (ret < 0) |
347 | goto unlock; |
348 | |
349 | *state = field; |
350 | unlock: |
351 | mutex_unlock(lock: &private->usb_mutex); |
352 | return ret ? ret : 0; |
353 | } |
354 | |
355 | /* |
356 | * Send a control packet to the device for the control id |
357 | * specified in (kctl->private_value >> 8) with value |
358 | * specified in (kctl->private_value >> 16). |
359 | */ |
360 | static int |
361 | snd_s1810c_set_switch_state(struct usb_mixer_interface *mixer, |
362 | struct snd_kcontrol *kctl) |
363 | { |
364 | struct snd_usb_audio *chip = mixer->chip; |
365 | struct s1810_mixer_state *private = mixer->private_data; |
366 | u32 pval = (u32) kctl->private_value; |
367 | u32 ctl_id = (pval >> 8) & 0xFF; |
368 | u32 ctl_val = (pval >> 16) & 0x1; |
369 | int ret = 0; |
370 | |
371 | mutex_lock(&private->usb_mutex); |
372 | ret = snd_s1810c_send_ctl_packet(dev: chip->dev, a: 0, b: 0, c: 0, d: ctl_id, e: ctl_val); |
373 | mutex_unlock(lock: &private->usb_mutex); |
374 | return ret; |
375 | } |
376 | |
377 | /* Generic get/set/init functions for switch controls */ |
378 | |
379 | static int |
380 | snd_s1810c_switch_get(struct snd_kcontrol *kctl, |
381 | struct snd_ctl_elem_value *ctl_elem) |
382 | { |
383 | struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); |
384 | struct usb_mixer_interface *mixer = list->mixer; |
385 | struct s1810_mixer_state *private = mixer->private_data; |
386 | u32 pval = (u32) kctl->private_value; |
387 | u32 ctl_idx = pval & 0xFF; |
388 | u32 state = 0; |
389 | int ret = 0; |
390 | |
391 | mutex_lock(&private->data_mutex); |
392 | ret = snd_s1810c_get_switch_state(mixer, kctl, state: &state); |
393 | if (ret < 0) |
394 | goto unlock; |
395 | |
396 | switch (ctl_idx) { |
397 | case SC1810C_STATE_LINE_SW: |
398 | case SC1810C_STATE_AB_SW: |
399 | ctl_elem->value.enumerated.item[0] = (int)state; |
400 | break; |
401 | default: |
402 | ctl_elem->value.integer.value[0] = (long)state; |
403 | } |
404 | |
405 | unlock: |
406 | mutex_unlock(lock: &private->data_mutex); |
407 | return (ret < 0) ? ret : 0; |
408 | } |
409 | |
410 | static int |
411 | snd_s1810c_switch_set(struct snd_kcontrol *kctl, |
412 | struct snd_ctl_elem_value *ctl_elem) |
413 | { |
414 | struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); |
415 | struct usb_mixer_interface *mixer = list->mixer; |
416 | struct s1810_mixer_state *private = mixer->private_data; |
417 | u32 pval = (u32) kctl->private_value; |
418 | u32 ctl_idx = pval & 0xFF; |
419 | u32 curval = 0; |
420 | u32 newval = 0; |
421 | int ret = 0; |
422 | |
423 | mutex_lock(&private->data_mutex); |
424 | ret = snd_s1810c_get_switch_state(mixer, kctl, state: &curval); |
425 | if (ret < 0) |
426 | goto unlock; |
427 | |
428 | switch (ctl_idx) { |
429 | case SC1810C_STATE_LINE_SW: |
430 | case SC1810C_STATE_AB_SW: |
431 | newval = (u32) ctl_elem->value.enumerated.item[0]; |
432 | break; |
433 | default: |
434 | newval = (u32) ctl_elem->value.integer.value[0]; |
435 | } |
436 | |
437 | if (curval == newval) |
438 | goto unlock; |
439 | |
440 | kctl->private_value &= ~(0x1 << 16); |
441 | kctl->private_value |= (unsigned int)(newval & 0x1) << 16; |
442 | ret = snd_s1810c_set_switch_state(mixer, kctl); |
443 | |
444 | unlock: |
445 | mutex_unlock(lock: &private->data_mutex); |
446 | return (ret < 0) ? 0 : 1; |
447 | } |
448 | |
449 | static int |
450 | snd_s1810c_switch_init(struct usb_mixer_interface *mixer, |
451 | const struct snd_kcontrol_new *new_kctl) |
452 | { |
453 | struct snd_kcontrol *kctl; |
454 | struct usb_mixer_elem_info *elem; |
455 | |
456 | elem = kzalloc(size: sizeof(struct usb_mixer_elem_info), GFP_KERNEL); |
457 | if (!elem) |
458 | return -ENOMEM; |
459 | |
460 | elem->head.mixer = mixer; |
461 | elem->control = 0; |
462 | elem->head.id = 0; |
463 | elem->channels = 1; |
464 | |
465 | kctl = snd_ctl_new1(kcontrolnew: new_kctl, private_data: elem); |
466 | if (!kctl) { |
467 | kfree(objp: elem); |
468 | return -ENOMEM; |
469 | } |
470 | kctl->private_free = snd_usb_mixer_elem_free; |
471 | |
472 | return snd_usb_mixer_add_control(&elem->head, kctl); |
473 | } |
474 | |
475 | static int |
476 | snd_s1810c_line_sw_info(struct snd_kcontrol *kctl, |
477 | struct snd_ctl_elem_info *uinfo) |
478 | { |
479 | static const char *const texts[2] = { |
480 | "Preamp On (Mic/Inst)" , |
481 | "Preamp Off (Line in)" |
482 | }; |
483 | |
484 | return snd_ctl_enum_info(info: uinfo, channels: 1, ARRAY_SIZE(texts), names: texts); |
485 | } |
486 | |
487 | static const struct snd_kcontrol_new snd_s1810c_line_sw = { |
488 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
489 | .name = "Line 1/2 Source Type" , |
490 | .info = snd_s1810c_line_sw_info, |
491 | .get = snd_s1810c_switch_get, |
492 | .put = snd_s1810c_switch_set, |
493 | .private_value = (SC1810C_STATE_LINE_SW | SC1810C_CTL_LINE_SW << 8) |
494 | }; |
495 | |
496 | static const struct snd_kcontrol_new snd_s1810c_mute_sw = { |
497 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
498 | .name = "Mute Main Out Switch" , |
499 | .info = snd_ctl_boolean_mono_info, |
500 | .get = snd_s1810c_switch_get, |
501 | .put = snd_s1810c_switch_set, |
502 | .private_value = (SC1810C_STATE_MUTE_SW | SC1810C_CTL_MUTE_SW << 8) |
503 | }; |
504 | |
505 | static const struct snd_kcontrol_new snd_s1810c_48v_sw = { |
506 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
507 | .name = "48V Phantom Power On Mic Inputs Switch" , |
508 | .info = snd_ctl_boolean_mono_info, |
509 | .get = snd_s1810c_switch_get, |
510 | .put = snd_s1810c_switch_set, |
511 | .private_value = (SC1810C_STATE_48V_SW | SC1810C_CTL_48V_SW << 8) |
512 | }; |
513 | |
514 | static int |
515 | snd_s1810c_ab_sw_info(struct snd_kcontrol *kctl, |
516 | struct snd_ctl_elem_info *uinfo) |
517 | { |
518 | static const char *const texts[2] = { |
519 | "1/2" , |
520 | "3/4" |
521 | }; |
522 | |
523 | return snd_ctl_enum_info(info: uinfo, channels: 1, ARRAY_SIZE(texts), names: texts); |
524 | } |
525 | |
526 | static const struct snd_kcontrol_new snd_s1810c_ab_sw = { |
527 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
528 | .name = "Headphone 1 Source Route" , |
529 | .info = snd_s1810c_ab_sw_info, |
530 | .get = snd_s1810c_switch_get, |
531 | .put = snd_s1810c_switch_set, |
532 | .private_value = (SC1810C_STATE_AB_SW | SC1810C_CTL_AB_SW << 8) |
533 | }; |
534 | |
535 | static void snd_sc1810_mixer_state_free(struct usb_mixer_interface *mixer) |
536 | { |
537 | struct s1810_mixer_state *private = mixer->private_data; |
538 | kfree(objp: private); |
539 | mixer->private_data = NULL; |
540 | } |
541 | |
542 | /* Entry point, called from mixer_quirks.c */ |
543 | int snd_sc1810_init_mixer(struct usb_mixer_interface *mixer) |
544 | { |
545 | struct s1810_mixer_state *private = NULL; |
546 | struct snd_usb_audio *chip = mixer->chip; |
547 | struct usb_device *dev = chip->dev; |
548 | int ret = 0; |
549 | |
550 | /* Run this only once */ |
551 | if (!list_empty(head: &chip->mixer_list)) |
552 | return 0; |
553 | |
554 | dev_info(&dev->dev, |
555 | "Presonus Studio 1810c, device_setup: %u\n" , chip->setup); |
556 | if (chip->setup == 1) |
557 | dev_info(&dev->dev, "(8out/18in @ 48kHz)\n" ); |
558 | else if (chip->setup == 2) |
559 | dev_info(&dev->dev, "(6out/8in @ 192kHz)\n" ); |
560 | else |
561 | dev_info(&dev->dev, "(8out/14in @ 96kHz)\n" ); |
562 | |
563 | ret = snd_s1810c_init_mixer_maps(chip); |
564 | if (ret < 0) |
565 | return ret; |
566 | |
567 | private = kzalloc(size: sizeof(struct s1810_mixer_state), GFP_KERNEL); |
568 | if (!private) |
569 | return -ENOMEM; |
570 | |
571 | mutex_init(&private->usb_mutex); |
572 | mutex_init(&private->data_mutex); |
573 | |
574 | mixer->private_data = private; |
575 | mixer->private_free = snd_sc1810_mixer_state_free; |
576 | |
577 | private->seqnum = 1; |
578 | |
579 | ret = snd_s1810c_switch_init(mixer, new_kctl: &snd_s1810c_line_sw); |
580 | if (ret < 0) |
581 | return ret; |
582 | |
583 | ret = snd_s1810c_switch_init(mixer, new_kctl: &snd_s1810c_mute_sw); |
584 | if (ret < 0) |
585 | return ret; |
586 | |
587 | ret = snd_s1810c_switch_init(mixer, new_kctl: &snd_s1810c_48v_sw); |
588 | if (ret < 0) |
589 | return ret; |
590 | |
591 | ret = snd_s1810c_switch_init(mixer, new_kctl: &snd_s1810c_ab_sw); |
592 | if (ret < 0) |
593 | return ret; |
594 | return ret; |
595 | } |
596 | |