forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
595 lines
15 KiB
595 lines
15 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Presonus Studio 1810c driver for ALSA |
|
* Copyright (C) 2019 Nick Kossifidis <[email protected]> |
|
* |
|
* Based on reverse engineering of the communication protocol |
|
* between the windows driver / Univeral Control (UC) program |
|
* and the device, through usbmon. |
|
* |
|
* For now this bypasses the mixer, with all channels split, |
|
* so that the software can mix with greater flexibility. |
|
* It also adds controls for the 4 buttons on the front of |
|
* the device. |
|
*/ |
|
|
|
#include <linux/usb.h> |
|
#include <linux/usb/audio-v2.h> |
|
#include <linux/slab.h> |
|
#include <sound/core.h> |
|
#include <sound/control.h> |
|
|
|
#include "usbaudio.h" |
|
#include "mixer.h" |
|
#include "mixer_quirks.h" |
|
#include "helper.h" |
|
#include "mixer_s1810c.h" |
|
|
|
#define SC1810C_CMD_REQ 160 |
|
#define SC1810C_CMD_REQTYPE \ |
|
(USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT) |
|
#define SC1810C_CMD_F1 0x50617269 |
|
#define SC1810C_CMD_F2 0x14 |
|
|
|
/* |
|
* DISCLAIMER: These are just guesses based on the |
|
* dumps I got. |
|
* |
|
* It seems like a selects between |
|
* device (0), mixer (0x64) and output (0x65) |
|
* |
|
* For mixer (0x64): |
|
* * b selects an input channel (see below). |
|
* * c selects an output channel pair (see below). |
|
* * d selects left (0) or right (1) of that pair. |
|
* * e 0-> disconnect, 0x01000000-> connect, |
|
* 0x0109-> used for stereo-linking channels, |
|
* e is also used for setting volume levels |
|
* in which case b is also set so I guess |
|
* this way it is possible to set the volume |
|
* level from the specified input to the |
|
* specified output. |
|
* |
|
* IN Channels: |
|
* 0 - 7 Mic/Inst/Line (Analog inputs) |
|
* 8 - 9 S/PDIF |
|
* 10 - 17 ADAT |
|
* 18 - 35 DAW (Inputs from the host) |
|
* |
|
* OUT Channels (pairs): |
|
* 0 -> Main out |
|
* 1 -> Line1/2 |
|
* 2 -> Line3/4 |
|
* 3 -> S/PDIF |
|
* 4 -> ADAT? |
|
* |
|
* For device (0): |
|
* * b and c are not used, at least not on the |
|
* dumps I got. |
|
* * d sets the control id to be modified |
|
* (see below). |
|
* * e sets the setting for that control. |
|
* (so for the switches I was interested |
|
* in it's 0/1) |
|
* |
|
* For output (0x65): |
|
* * b is the output channel (see above). |
|
* * c is zero. |
|
* * e I guess the same as with mixer except 0x0109 |
|
* which I didn't see in my dumps. |
|
* |
|
* The two fixed fields have the same values for |
|
* mixer and output but a different set for device. |
|
*/ |
|
struct s1810c_ctl_packet { |
|
u32 a; |
|
u32 b; |
|
u32 fixed1; |
|
u32 fixed2; |
|
u32 c; |
|
u32 d; |
|
u32 e; |
|
}; |
|
|
|
#define SC1810C_CTL_LINE_SW 0 |
|
#define SC1810C_CTL_MUTE_SW 1 |
|
#define SC1810C_CTL_AB_SW 3 |
|
#define SC1810C_CTL_48V_SW 4 |
|
|
|
#define SC1810C_SET_STATE_REQ 161 |
|
#define SC1810C_SET_STATE_REQTYPE SC1810C_CMD_REQTYPE |
|
#define SC1810C_SET_STATE_F1 0x64656D73 |
|
#define SC1810C_SET_STATE_F2 0xF4 |
|
|
|
#define SC1810C_GET_STATE_REQ 162 |
|
#define SC1810C_GET_STATE_REQTYPE \ |
|
(USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN) |
|
#define SC1810C_GET_STATE_F1 SC1810C_SET_STATE_F1 |
|
#define SC1810C_GET_STATE_F2 SC1810C_SET_STATE_F2 |
|
|
|
#define SC1810C_STATE_F1_IDX 2 |
|
#define SC1810C_STATE_F2_IDX 3 |
|
|
|
/* |
|
* This packet includes mixer volumes and |
|
* various other fields, it's an extended |
|
* version of ctl_packet, with a and b |
|
* being zero and different f1/f2. |
|
*/ |
|
struct s1810c_state_packet { |
|
u32 fields[63]; |
|
}; |
|
|
|
#define SC1810C_STATE_48V_SW 58 |
|
#define SC1810C_STATE_LINE_SW 59 |
|
#define SC1810C_STATE_MUTE_SW 60 |
|
#define SC1810C_STATE_AB_SW 62 |
|
|
|
struct s1810_mixer_state { |
|
uint16_t seqnum; |
|
struct mutex usb_mutex; |
|
struct mutex data_mutex; |
|
}; |
|
|
|
static int |
|
snd_s1810c_send_ctl_packet(struct usb_device *dev, u32 a, |
|
u32 b, u32 c, u32 d, u32 e) |
|
{ |
|
struct s1810c_ctl_packet pkt = { 0 }; |
|
int ret = 0; |
|
|
|
pkt.fixed1 = SC1810C_CMD_F1; |
|
pkt.fixed2 = SC1810C_CMD_F2; |
|
|
|
pkt.a = a; |
|
pkt.b = b; |
|
pkt.c = c; |
|
pkt.d = d; |
|
/* |
|
* Value for settings 0/1 for this |
|
* output channel is always 0 (probably because |
|
* there is no ADAT output on 1810c) |
|
*/ |
|
pkt.e = (c == 4) ? 0 : e; |
|
|
|
ret = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), |
|
SC1810C_CMD_REQ, |
|
SC1810C_CMD_REQTYPE, 0, 0, &pkt, sizeof(pkt)); |
|
if (ret < 0) { |
|
dev_warn(&dev->dev, "could not send ctl packet\n"); |
|
return ret; |
|
} |
|
return 0; |
|
} |
|
|
|
/* |
|
* When opening Universal Control the program periodicaly |
|
* sends and receives state packets for syncinc state between |
|
* the device and the host. |
|
* |
|
* Note that if we send only the request to get data back we'll |
|
* get an error, we need to first send an empty state packet and |
|
* then ask to receive a filled. Their seqnumbers must also match. |
|
*/ |
|
static int |
|
snd_sc1810c_get_status_field(struct usb_device *dev, |
|
u32 *field, int field_idx, uint16_t *seqnum) |
|
{ |
|
struct s1810c_state_packet pkt_out = { { 0 } }; |
|
struct s1810c_state_packet pkt_in = { { 0 } }; |
|
int ret = 0; |
|
|
|
pkt_out.fields[SC1810C_STATE_F1_IDX] = SC1810C_SET_STATE_F1; |
|
pkt_out.fields[SC1810C_STATE_F2_IDX] = SC1810C_SET_STATE_F2; |
|
ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), |
|
SC1810C_SET_STATE_REQ, |
|
SC1810C_SET_STATE_REQTYPE, |
|
(*seqnum), 0, &pkt_out, sizeof(pkt_out)); |
|
if (ret < 0) { |
|
dev_warn(&dev->dev, "could not send state packet (%d)\n", ret); |
|
return ret; |
|
} |
|
|
|
ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), |
|
SC1810C_GET_STATE_REQ, |
|
SC1810C_GET_STATE_REQTYPE, |
|
(*seqnum), 0, &pkt_in, sizeof(pkt_in)); |
|
if (ret < 0) { |
|
dev_warn(&dev->dev, "could not get state field %u (%d)\n", |
|
field_idx, ret); |
|
return ret; |
|
} |
|
|
|
(*field) = pkt_in.fields[field_idx]; |
|
(*seqnum)++; |
|
return 0; |
|
} |
|
|
|
/* |
|
* This is what I got when bypassing the mixer with |
|
* all channels split. I'm not 100% sure of what's going |
|
* on, I could probably clean this up based on my observations |
|
* but I prefer to keep the same behavior as the windows driver. |
|
*/ |
|
static int snd_s1810c_init_mixer_maps(struct snd_usb_audio *chip) |
|
{ |
|
u32 a, b, c, e, n, off; |
|
struct usb_device *dev = chip->dev; |
|
|
|
/* Set initial volume levels ? */ |
|
a = 0x64; |
|
e = 0xbc; |
|
for (n = 0; n < 2; n++) { |
|
off = n * 18; |
|
for (b = off, c = 0; b < 18 + off; b++) { |
|
/* This channel to all outputs ? */ |
|
for (c = 0; c <= 8; c++) { |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e); |
|
} |
|
/* This channel to main output (again) */ |
|
snd_s1810c_send_ctl_packet(dev, a, b, 0, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, b, 0, 1, e); |
|
} |
|
/* |
|
* I noticed on UC that DAW channels have different |
|
* initial volumes, so this makes sense. |
|
*/ |
|
e = 0xb53bf0; |
|
} |
|
|
|
/* Connect analog outputs ? */ |
|
a = 0x65; |
|
e = 0x01000000; |
|
for (b = 1; b < 3; b++) { |
|
snd_s1810c_send_ctl_packet(dev, a, b, 0, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, b, 0, 1, e); |
|
} |
|
snd_s1810c_send_ctl_packet(dev, a, 0, 0, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, 0, 0, 1, e); |
|
|
|
/* Set initial volume levels for S/PDIF mappings ? */ |
|
a = 0x64; |
|
e = 0xbc; |
|
c = 3; |
|
for (n = 0; n < 2; n++) { |
|
off = n * 18; |
|
for (b = off; b < 18 + off; b++) { |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e); |
|
} |
|
e = 0xb53bf0; |
|
} |
|
|
|
/* Connect S/PDIF output ? */ |
|
a = 0x65; |
|
e = 0x01000000; |
|
snd_s1810c_send_ctl_packet(dev, a, 3, 0, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, 3, 0, 1, e); |
|
|
|
/* Connect all outputs (again) ? */ |
|
a = 0x65; |
|
e = 0x01000000; |
|
for (b = 0; b < 4; b++) { |
|
snd_s1810c_send_ctl_packet(dev, a, b, 0, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, b, 0, 1, e); |
|
} |
|
|
|
/* Basic routing to get sound out of the device */ |
|
a = 0x64; |
|
e = 0x01000000; |
|
for (c = 0; c < 4; c++) { |
|
for (b = 0; b < 36; b++) { |
|
if ((c == 0 && b == 18) || /* DAW1/2 -> Main */ |
|
(c == 1 && b == 20) || /* DAW3/4 -> Line3/4 */ |
|
(c == 2 && b == 22) || /* DAW4/5 -> Line5/6 */ |
|
(c == 3 && b == 24)) { /* DAW5/6 -> S/PDIF */ |
|
/* Left */ |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 1, 0); |
|
b++; |
|
/* Right */ |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 0, 0); |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e); |
|
} else { |
|
/* Leave the rest disconnected */ |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 0, 0); |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 1, 0); |
|
} |
|
} |
|
} |
|
|
|
/* Set initial volume levels for S/PDIF (again) ? */ |
|
a = 0x64; |
|
e = 0xbc; |
|
c = 3; |
|
for (n = 0; n < 2; n++) { |
|
off = n * 18; |
|
for (b = off; b < 18 + off; b++) { |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e); |
|
} |
|
e = 0xb53bf0; |
|
} |
|
|
|
/* Connect S/PDIF outputs (again) ? */ |
|
a = 0x65; |
|
e = 0x01000000; |
|
snd_s1810c_send_ctl_packet(dev, a, 3, 0, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, 3, 0, 1, e); |
|
|
|
/* Again ? */ |
|
snd_s1810c_send_ctl_packet(dev, a, 3, 0, 0, e); |
|
snd_s1810c_send_ctl_packet(dev, a, 3, 0, 1, e); |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* Sync state with the device and retrieve the requested field, |
|
* whose index is specified in (kctl->private_value & 0xFF), |
|
* from the received fields array. |
|
*/ |
|
static int |
|
snd_s1810c_get_switch_state(struct usb_mixer_interface *mixer, |
|
struct snd_kcontrol *kctl, u32 *state) |
|
{ |
|
struct snd_usb_audio *chip = mixer->chip; |
|
struct s1810_mixer_state *private = mixer->private_data; |
|
u32 field = 0; |
|
u32 ctl_idx = (u32) (kctl->private_value & 0xFF); |
|
int ret = 0; |
|
|
|
mutex_lock(&private->usb_mutex); |
|
ret = snd_sc1810c_get_status_field(chip->dev, &field, |
|
ctl_idx, &private->seqnum); |
|
if (ret < 0) |
|
goto unlock; |
|
|
|
*state = field; |
|
unlock: |
|
mutex_unlock(&private->usb_mutex); |
|
return ret ? ret : 0; |
|
} |
|
|
|
/* |
|
* Send a control packet to the device for the control id |
|
* specified in (kctl->private_value >> 8) with value |
|
* specified in (kctl->private_value >> 16). |
|
*/ |
|
static int |
|
snd_s1810c_set_switch_state(struct usb_mixer_interface *mixer, |
|
struct snd_kcontrol *kctl) |
|
{ |
|
struct snd_usb_audio *chip = mixer->chip; |
|
struct s1810_mixer_state *private = mixer->private_data; |
|
u32 pval = (u32) kctl->private_value; |
|
u32 ctl_id = (pval >> 8) & 0xFF; |
|
u32 ctl_val = (pval >> 16) & 0x1; |
|
int ret = 0; |
|
|
|
mutex_lock(&private->usb_mutex); |
|
ret = snd_s1810c_send_ctl_packet(chip->dev, 0, 0, 0, ctl_id, ctl_val); |
|
mutex_unlock(&private->usb_mutex); |
|
return ret; |
|
} |
|
|
|
/* Generic get/set/init functions for switch controls */ |
|
|
|
static int |
|
snd_s1810c_switch_get(struct snd_kcontrol *kctl, |
|
struct snd_ctl_elem_value *ctl_elem) |
|
{ |
|
struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); |
|
struct usb_mixer_interface *mixer = list->mixer; |
|
struct s1810_mixer_state *private = mixer->private_data; |
|
u32 pval = (u32) kctl->private_value; |
|
u32 ctl_idx = pval & 0xFF; |
|
u32 state = 0; |
|
int ret = 0; |
|
|
|
mutex_lock(&private->data_mutex); |
|
ret = snd_s1810c_get_switch_state(mixer, kctl, &state); |
|
if (ret < 0) |
|
goto unlock; |
|
|
|
switch (ctl_idx) { |
|
case SC1810C_STATE_LINE_SW: |
|
case SC1810C_STATE_AB_SW: |
|
ctl_elem->value.enumerated.item[0] = (int)state; |
|
break; |
|
default: |
|
ctl_elem->value.integer.value[0] = (long)state; |
|
} |
|
|
|
unlock: |
|
mutex_unlock(&private->data_mutex); |
|
return (ret < 0) ? ret : 0; |
|
} |
|
|
|
static int |
|
snd_s1810c_switch_set(struct snd_kcontrol *kctl, |
|
struct snd_ctl_elem_value *ctl_elem) |
|
{ |
|
struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); |
|
struct usb_mixer_interface *mixer = list->mixer; |
|
struct s1810_mixer_state *private = mixer->private_data; |
|
u32 pval = (u32) kctl->private_value; |
|
u32 ctl_idx = pval & 0xFF; |
|
u32 curval = 0; |
|
u32 newval = 0; |
|
int ret = 0; |
|
|
|
mutex_lock(&private->data_mutex); |
|
ret = snd_s1810c_get_switch_state(mixer, kctl, &curval); |
|
if (ret < 0) |
|
goto unlock; |
|
|
|
switch (ctl_idx) { |
|
case SC1810C_STATE_LINE_SW: |
|
case SC1810C_STATE_AB_SW: |
|
newval = (u32) ctl_elem->value.enumerated.item[0]; |
|
break; |
|
default: |
|
newval = (u32) ctl_elem->value.integer.value[0]; |
|
} |
|
|
|
if (curval == newval) |
|
goto unlock; |
|
|
|
kctl->private_value &= ~(0x1 << 16); |
|
kctl->private_value |= (unsigned int)(newval & 0x1) << 16; |
|
ret = snd_s1810c_set_switch_state(mixer, kctl); |
|
|
|
unlock: |
|
mutex_unlock(&private->data_mutex); |
|
return (ret < 0) ? 0 : 1; |
|
} |
|
|
|
static int |
|
snd_s1810c_switch_init(struct usb_mixer_interface *mixer, |
|
const struct snd_kcontrol_new *new_kctl) |
|
{ |
|
struct snd_kcontrol *kctl; |
|
struct usb_mixer_elem_info *elem; |
|
|
|
elem = kzalloc(sizeof(struct usb_mixer_elem_info), GFP_KERNEL); |
|
if (!elem) |
|
return -ENOMEM; |
|
|
|
elem->head.mixer = mixer; |
|
elem->control = 0; |
|
elem->head.id = 0; |
|
elem->channels = 1; |
|
|
|
kctl = snd_ctl_new1(new_kctl, elem); |
|
if (!kctl) { |
|
kfree(elem); |
|
return -ENOMEM; |
|
} |
|
kctl->private_free = snd_usb_mixer_elem_free; |
|
|
|
return snd_usb_mixer_add_control(&elem->head, kctl); |
|
} |
|
|
|
static int |
|
snd_s1810c_line_sw_info(struct snd_kcontrol *kctl, |
|
struct snd_ctl_elem_info *uinfo) |
|
{ |
|
static const char *const texts[2] = { |
|
"Preamp On (Mic/Inst)", |
|
"Preamp Off (Line in)" |
|
}; |
|
|
|
return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); |
|
} |
|
|
|
static const struct snd_kcontrol_new snd_s1810c_line_sw = { |
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
|
.name = "Line 1/2 Source Type", |
|
.info = snd_s1810c_line_sw_info, |
|
.get = snd_s1810c_switch_get, |
|
.put = snd_s1810c_switch_set, |
|
.private_value = (SC1810C_STATE_LINE_SW | SC1810C_CTL_LINE_SW << 8) |
|
}; |
|
|
|
static const struct snd_kcontrol_new snd_s1810c_mute_sw = { |
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
|
.name = "Mute Main Out Switch", |
|
.info = snd_ctl_boolean_mono_info, |
|
.get = snd_s1810c_switch_get, |
|
.put = snd_s1810c_switch_set, |
|
.private_value = (SC1810C_STATE_MUTE_SW | SC1810C_CTL_MUTE_SW << 8) |
|
}; |
|
|
|
static const struct snd_kcontrol_new snd_s1810c_48v_sw = { |
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
|
.name = "48V Phantom Power On Mic Inputs Switch", |
|
.info = snd_ctl_boolean_mono_info, |
|
.get = snd_s1810c_switch_get, |
|
.put = snd_s1810c_switch_set, |
|
.private_value = (SC1810C_STATE_48V_SW | SC1810C_CTL_48V_SW << 8) |
|
}; |
|
|
|
static int |
|
snd_s1810c_ab_sw_info(struct snd_kcontrol *kctl, |
|
struct snd_ctl_elem_info *uinfo) |
|
{ |
|
static const char *const texts[2] = { |
|
"1/2", |
|
"3/4" |
|
}; |
|
|
|
return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); |
|
} |
|
|
|
static const struct snd_kcontrol_new snd_s1810c_ab_sw = { |
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
|
.name = "Headphone 1 Source Route", |
|
.info = snd_s1810c_ab_sw_info, |
|
.get = snd_s1810c_switch_get, |
|
.put = snd_s1810c_switch_set, |
|
.private_value = (SC1810C_STATE_AB_SW | SC1810C_CTL_AB_SW << 8) |
|
}; |
|
|
|
static void snd_sc1810_mixer_state_free(struct usb_mixer_interface *mixer) |
|
{ |
|
struct s1810_mixer_state *private = mixer->private_data; |
|
kfree(private); |
|
mixer->private_data = NULL; |
|
} |
|
|
|
/* Entry point, called from mixer_quirks.c */ |
|
int snd_sc1810_init_mixer(struct usb_mixer_interface *mixer) |
|
{ |
|
struct s1810_mixer_state *private = NULL; |
|
struct snd_usb_audio *chip = mixer->chip; |
|
struct usb_device *dev = chip->dev; |
|
int ret = 0; |
|
|
|
/* Run this only once */ |
|
if (!list_empty(&chip->mixer_list)) |
|
return 0; |
|
|
|
dev_info(&dev->dev, |
|
"Presonus Studio 1810c, device_setup: %u\n", chip->setup); |
|
if (chip->setup == 1) |
|
dev_info(&dev->dev, "(8out/18in @ 48kHz)\n"); |
|
else if (chip->setup == 2) |
|
dev_info(&dev->dev, "(6out/8in @ 192kHz)\n"); |
|
else |
|
dev_info(&dev->dev, "(8out/14in @ 96kHz)\n"); |
|
|
|
ret = snd_s1810c_init_mixer_maps(chip); |
|
if (ret < 0) |
|
return ret; |
|
|
|
private = kzalloc(sizeof(struct s1810_mixer_state), GFP_KERNEL); |
|
if (!private) |
|
return -ENOMEM; |
|
|
|
mutex_init(&private->usb_mutex); |
|
mutex_init(&private->data_mutex); |
|
|
|
mixer->private_data = private; |
|
mixer->private_free = snd_sc1810_mixer_state_free; |
|
|
|
private->seqnum = 1; |
|
|
|
ret = snd_s1810c_switch_init(mixer, &snd_s1810c_line_sw); |
|
if (ret < 0) |
|
return ret; |
|
|
|
ret = snd_s1810c_switch_init(mixer, &snd_s1810c_mute_sw); |
|
if (ret < 0) |
|
return ret; |
|
|
|
ret = snd_s1810c_switch_init(mixer, &snd_s1810c_48v_sw); |
|
if (ret < 0) |
|
return ret; |
|
|
|
ret = snd_s1810c_switch_init(mixer, &snd_s1810c_ab_sw); |
|
if (ret < 0) |
|
return ret; |
|
return ret; |
|
}
|
|
|