sound/usb/mixer_s1810c.c

   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, 0, 0, &pkt, 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                               (*seqnum), 0, &pkt_out, 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                               (*seqnum), 0, &pkt_in, 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, c = 0; 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, 0, e);
 228                                 snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e);
 229                         }
 230                         /* This channel to main output (again) */
 231                         snd_s1810c_send_ctl_packet(dev, a, b, 0, 0, e);
 232                         snd_s1810c_send_ctl_packet(dev, a, b, 0, 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, 0, 0, e);
 246                 snd_s1810c_send_ctl_packet(dev, a, b, 0, 1, e);
 247         }
 248         snd_s1810c_send_ctl_packet(dev, a, 0, 0, 0, e);
 249         snd_s1810c_send_ctl_packet(dev, a, 0, 0, 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, 0, e);
 259                         snd_s1810c_send_ctl_packet(dev, a, b, c, 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, 3, 0, 0, e);
 268         snd_s1810c_send_ctl_packet(dev, a, 3, 0, 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, 0, 0, e);
 275                 snd_s1810c_send_ctl_packet(dev, a, b, 0, 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, 0, e);
 289                                 snd_s1810c_send_ctl_packet(dev, a, b, c, 1, 0);
 290                                 b++;
 291                                 /* Right */
 292                                 snd_s1810c_send_ctl_packet(dev, a, b, c, 0, 0);
 293                                 snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e);
 294                         } else {
 295                                 /* Leave the rest disconnected */
 296                                 snd_s1810c_send_ctl_packet(dev, a, b, c, 0, 0);
 297                                 snd_s1810c_send_ctl_packet(dev, a, b, c, 1, 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, 0, e);
 310                         snd_s1810c_send_ctl_packet(dev, a, b, c, 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, 3, 0, 0, e);
 319         snd_s1810c_send_ctl_packet(dev, a, 3, 0, 1, e);
 320
 321         /* Again ? */
 322         snd_s1810c_send_ctl_packet(dev, a, 3, 0, 0, e);
 323         snd_s1810c_send_ctl_packet(dev, a, 3, 0, 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(chip->dev, &field,
 345                                            ctl_idx, &private->seqnum);
 346         if (ret < 0)
 347                 goto unlock;
 348
 349         *state = field;
 350  unlock:
 351         mutex_unlock(&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(chip->dev, 0, 0, 0, ctl_id, ctl_val);
 373         mutex_unlock(&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);
 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(&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, &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(&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(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(new_kctl, elem);
 466         if (!kctl) {
 467                 kfree(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(uinfo, 1, ARRAY_SIZE(texts), 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(uinfo, 1, ARRAY_SIZE(texts), 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(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(&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(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, &snd_s1810c_line_sw);
 580         if (ret < 0)
 581                 return ret;
 582
 583         ret = snd_s1810c_switch_init(mixer, &snd_s1810c_mute_sw);
 584         if (ret < 0)
 585                 return ret;
 586
 587         ret = snd_s1810c_switch_init(mixer, &snd_s1810c_48v_sw);
 588         if (ret < 0)
 589                 return ret;
 590
 591         ret = snd_s1810c_switch_init(mixer, &snd_s1810c_ab_sw);
 592         if (ret < 0)
 593                 return ret;
 594         return ret;
 595 }