sound/usb/6fire/control.c

   1 /*
   2  * Linux driver for TerraTec DMX 6Fire USB
   3  *
   4  * Mixer control
   5  *
   6  * Author:      Torsten Schenk <torsten.schenk@zoho.com>
   7  * Created:     Jan 01, 2011
   8  * Copyright:   (C) Torsten Schenk
   9  *
  10  * Thanks to:
  11  * - Holger Ruckdeschel: he found out how to control individual channel
  12  *   volumes and introduced mute switch
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  */
  19
  20 #include <linux/interrupt.h>
  21 #include <sound/control.h>
  22 #include <sound/tlv.h>
  23
  24 #include "control.h"
  25 #include "comm.h"
  26 #include "chip.h"
  27
  28 static char *opt_coax_texts[2] = { "Optical", "Coax" };
  29 static char *line_phono_texts[2] = { "Line", "Phono" };
  30
  31 /*
  32  * data that needs to be sent to device. sets up card internal stuff.
  33  * values dumped from windows driver and filtered by trial'n'error.
  34  */
  35 static const struct {
  36         u8 type;
  37         u8 reg;
  38         u8 value;
  39 }
  40 init_data[] = {
  41         { 0x22, 0x00, 0x00 }, { 0x20, 0x00, 0x08 }, { 0x22, 0x01, 0x01 },
  42         { 0x20, 0x01, 0x08 }, { 0x22, 0x02, 0x00 }, { 0x20, 0x02, 0x08 },
  43         { 0x22, 0x03, 0x00 }, { 0x20, 0x03, 0x08 }, { 0x22, 0x04, 0x00 },
  44         { 0x20, 0x04, 0x08 }, { 0x22, 0x05, 0x01 }, { 0x20, 0x05, 0x08 },
  45         { 0x22, 0x04, 0x01 }, { 0x12, 0x04, 0x00 }, { 0x12, 0x05, 0x00 },
  46         { 0x12, 0x0d, 0x38 }, { 0x12, 0x21, 0x82 }, { 0x12, 0x22, 0x80 },
  47         { 0x12, 0x23, 0x00 }, { 0x12, 0x06, 0x02 }, { 0x12, 0x03, 0x00 },
  48         { 0x12, 0x02, 0x00 }, { 0x22, 0x03, 0x01 },
  49         { 0 } /* TERMINATING ENTRY */
  50 };
  51
  52 static const int rates_altsetting[] = { 1, 1, 2, 2, 3, 3 };
  53 /* values to write to soundcard register for all samplerates */
  54 static const u16 rates_6fire_vl[] = {0x00, 0x01, 0x00, 0x01, 0x00, 0x01};
  55 static const u16 rates_6fire_vh[] = {0x11, 0x11, 0x10, 0x10, 0x00, 0x00};
  56
  57 static DECLARE_TLV_DB_MINMAX(tlv_output, -9000, 0);
  58 static DECLARE_TLV_DB_MINMAX(tlv_input, -1500, 1500);
  59
  60 enum {
  61         DIGITAL_THRU_ONLY_SAMPLERATE = 3
  62 };
  63
  64 static void usb6fire_control_output_vol_update(struct control_runtime *rt)
  65 {
  66         struct comm_runtime *comm_rt = rt->chip->comm;
  67         int i;
  68
  69         if (comm_rt)
  70                 for (i = 0; i < 6; i++)
  71                         if (!(rt->ovol_updated & (1 << i))) {
  72                                 comm_rt->write8(comm_rt, 0x12, 0x0f + i,
  73                                         180 - rt->output_vol[i]);
  74                                 rt->ovol_updated |= 1 << i;
  75                         }
  76 }
  77
  78 static void usb6fire_control_output_mute_update(struct control_runtime *rt)
  79 {
  80         struct comm_runtime *comm_rt = rt->chip->comm;
  81
  82         if (comm_rt)
  83                 comm_rt->write8(comm_rt, 0x12, 0x0e, ~rt->output_mute);
  84 }
  85
  86 static void usb6fire_control_input_vol_update(struct control_runtime *rt)
  87 {
  88         struct comm_runtime *comm_rt = rt->chip->comm;
  89         int i;
  90
  91         if (comm_rt)
  92                 for (i = 0; i < 2; i++)
  93                         if (!(rt->ivol_updated & (1 << i))) {
  94                                 comm_rt->write8(comm_rt, 0x12, 0x1c + i,
  95                                         rt->input_vol[i] & 0x3f);
  96                                 rt->ivol_updated |= 1 << i;
  97                         }
  98 }
  99
 100 static void usb6fire_control_line_phono_update(struct control_runtime *rt)
 101 {
 102         struct comm_runtime *comm_rt = rt->chip->comm;
 103         if (comm_rt) {
 104                 comm_rt->write8(comm_rt, 0x22, 0x02, rt->line_phono_switch);
 105                 comm_rt->write8(comm_rt, 0x21, 0x02, rt->line_phono_switch);
 106         }
 107 }
 108
 109 static void usb6fire_control_opt_coax_update(struct control_runtime *rt)
 110 {
 111         struct comm_runtime *comm_rt = rt->chip->comm;
 112         if (comm_rt) {
 113                 comm_rt->write8(comm_rt, 0x22, 0x00, rt->opt_coax_switch);
 114                 comm_rt->write8(comm_rt, 0x21, 0x00, rt->opt_coax_switch);
 115         }
 116 }
 117
 118 static int usb6fire_control_set_rate(struct control_runtime *rt, int rate)
 119 {
 120         int ret;
 121         struct usb_device *device = rt->chip->dev;
 122         struct comm_runtime *comm_rt = rt->chip->comm;
 123
 124         if (rate < 0 || rate >= CONTROL_N_RATES)
 125                 return -EINVAL;
 126
 127         ret = usb_set_interface(device, 1, rates_altsetting[rate]);
 128         if (ret < 0)
 129                 return ret;
 130
 131         /* set soundcard clock */
 132         ret = comm_rt->write16(comm_rt, 0x02, 0x01, rates_6fire_vl[rate],
 133                         rates_6fire_vh[rate]);
 134         if (ret < 0)
 135                 return ret;
 136
 137         return 0;
 138 }
 139
 140 static int usb6fire_control_set_channels(
 141         struct control_runtime *rt, int n_analog_out,
 142         int n_analog_in, bool spdif_out, bool spdif_in)
 143 {
 144         int ret;
 145         struct comm_runtime *comm_rt = rt->chip->comm;
 146
 147         /* enable analog inputs and outputs
 148          * (one bit per stereo-channel) */
 149         ret = comm_rt->write16(comm_rt, 0x02, 0x02,
 150                         (1 << (n_analog_out / 2)) - 1,
 151                         (1 << (n_analog_in / 2)) - 1);
 152         if (ret < 0)
 153                 return ret;
 154
 155         /* disable digital inputs and outputs */
 156         /* TODO: use spdif_x to enable/disable digital channels */
 157         ret = comm_rt->write16(comm_rt, 0x02, 0x03, 0x00, 0x00);
 158         if (ret < 0)
 159                 return ret;
 160
 161         return 0;
 162 }
 163
 164 static int usb6fire_control_streaming_update(struct control_runtime *rt)
 165 {
 166         struct comm_runtime *comm_rt = rt->chip->comm;
 167
 168         if (comm_rt) {
 169                 if (!rt->usb_streaming && rt->digital_thru_switch)
 170                         usb6fire_control_set_rate(rt,
 171                                 DIGITAL_THRU_ONLY_SAMPLERATE);
 172                 return comm_rt->write16(comm_rt, 0x02, 0x00, 0x00,
 173                         (rt->usb_streaming ? 0x01 : 0x00) |
 174                         (rt->digital_thru_switch ? 0x08 : 0x00));
 175         }
 176         return -EINVAL;
 177 }
 178
 179 static int usb6fire_control_output_vol_info(struct snd_kcontrol *kcontrol,
 180                 struct snd_ctl_elem_info *uinfo)
 181 {
 182         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 183         uinfo->count = 2;
 184         uinfo->value.integer.min = 0;
 185         uinfo->value.integer.max = 180;
 186         return 0;
 187 }
 188
 189 static int usb6fire_control_output_vol_put(struct snd_kcontrol *kcontrol,
 190                 struct snd_ctl_elem_value *ucontrol)
 191 {
 192         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 193         unsigned int ch = kcontrol->private_value;
 194         int changed = 0;
 195
 196         if (ch > 4) {
 197                 dev_err(&rt->chip->dev->dev,
 198                         "Invalid channel in volume control.");
 199                 return -EINVAL;
 200         }
 201
 202         if (rt->output_vol[ch] != ucontrol->value.integer.value[0]) {
 203                 rt->output_vol[ch] = ucontrol->value.integer.value[0];
 204                 rt->ovol_updated &= ~(1 << ch);
 205                 changed = 1;
 206         }
 207         if (rt->output_vol[ch + 1] != ucontrol->value.integer.value[1]) {
 208                 rt->output_vol[ch + 1] = ucontrol->value.integer.value[1];
 209                 rt->ovol_updated &= ~(2 << ch);
 210                 changed = 1;
 211         }
 212
 213         if (changed)
 214                 usb6fire_control_output_vol_update(rt);
 215
 216         return changed;
 217 }
 218
 219 static int usb6fire_control_output_vol_get(struct snd_kcontrol *kcontrol,
 220                 struct snd_ctl_elem_value *ucontrol)
 221 {
 222         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 223         unsigned int ch = kcontrol->private_value;
 224
 225         if (ch > 4) {
 226                 dev_err(&rt->chip->dev->dev,
 227                         "Invalid channel in volume control.");
 228                 return -EINVAL;
 229         }
 230
 231         ucontrol->value.integer.value[0] = rt->output_vol[ch];
 232         ucontrol->value.integer.value[1] = rt->output_vol[ch + 1];
 233         return 0;
 234 }
 235
 236 static int usb6fire_control_output_mute_put(struct snd_kcontrol *kcontrol,
 237         struct snd_ctl_elem_value *ucontrol)
 238 {
 239         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 240         unsigned int ch = kcontrol->private_value;
 241         u8 old = rt->output_mute;
 242         u8 value = 0;
 243
 244         if (ch > 4) {
 245                 dev_err(&rt->chip->dev->dev,
 246                         "Invalid channel in volume control.");
 247                 return -EINVAL;
 248         }
 249
 250         rt->output_mute &= ~(3 << ch);
 251         if (ucontrol->value.integer.value[0])
 252                 value |= 1;
 253         if (ucontrol->value.integer.value[1])
 254                 value |= 2;
 255         rt->output_mute |= value << ch;
 256
 257         if (rt->output_mute != old)
 258                 usb6fire_control_output_mute_update(rt);
 259
 260         return rt->output_mute != old;
 261 }
 262
 263 static int usb6fire_control_output_mute_get(struct snd_kcontrol *kcontrol,
 264         struct snd_ctl_elem_value *ucontrol)
 265 {
 266         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 267         unsigned int ch = kcontrol->private_value;
 268         u8 value = rt->output_mute >> ch;
 269
 270         if (ch > 4) {
 271                 dev_err(&rt->chip->dev->dev,
 272                         "Invalid channel in volume control.");
 273                 return -EINVAL;
 274         }
 275
 276         ucontrol->value.integer.value[0] = 1 & value;
 277         value >>= 1;
 278         ucontrol->value.integer.value[1] = 1 & value;
 279
 280         return 0;
 281 }
 282
 283 static int usb6fire_control_input_vol_info(struct snd_kcontrol *kcontrol,
 284                 struct snd_ctl_elem_info *uinfo)
 285 {
 286         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 287         uinfo->count = 2;
 288         uinfo->value.integer.min = 0;
 289         uinfo->value.integer.max = 30;
 290         return 0;
 291 }
 292
 293 static int usb6fire_control_input_vol_put(struct snd_kcontrol *kcontrol,
 294                 struct snd_ctl_elem_value *ucontrol)
 295 {
 296         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 297         int changed = 0;
 298
 299         if (rt->input_vol[0] != ucontrol->value.integer.value[0]) {
 300                 rt->input_vol[0] = ucontrol->value.integer.value[0] - 15;
 301                 rt->ivol_updated &= ~(1 << 0);
 302                 changed = 1;
 303         }
 304         if (rt->input_vol[1] != ucontrol->value.integer.value[1]) {
 305                 rt->input_vol[1] = ucontrol->value.integer.value[1] - 15;
 306                 rt->ivol_updated &= ~(1 << 1);
 307                 changed = 1;
 308         }
 309
 310         if (changed)
 311                 usb6fire_control_input_vol_update(rt);
 312
 313         return changed;
 314 }
 315
 316 static int usb6fire_control_input_vol_get(struct snd_kcontrol *kcontrol,
 317                 struct snd_ctl_elem_value *ucontrol)
 318 {
 319         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 320
 321         ucontrol->value.integer.value[0] = rt->input_vol[0] + 15;
 322         ucontrol->value.integer.value[1] = rt->input_vol[1] + 15;
 323
 324         return 0;
 325 }
 326
 327 static int usb6fire_control_line_phono_info(struct snd_kcontrol *kcontrol,
 328                 struct snd_ctl_elem_info *uinfo)
 329 {
 330         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 331         uinfo->count = 1;
 332         uinfo->value.enumerated.items = 2;
 333         if (uinfo->value.enumerated.item > 1)
 334                 uinfo->value.enumerated.item = 1;
 335         strcpy(uinfo->value.enumerated.name,
 336                         line_phono_texts[uinfo->value.enumerated.item]);
 337         return 0;
 338 }
 339
 340 static int usb6fire_control_line_phono_put(struct snd_kcontrol *kcontrol,
 341                 struct snd_ctl_elem_value *ucontrol)
 342 {
 343         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 344         int changed = 0;
 345         if (rt->line_phono_switch != ucontrol->value.integer.value[0]) {
 346                 rt->line_phono_switch = ucontrol->value.integer.value[0];
 347                 usb6fire_control_line_phono_update(rt);
 348                 changed = 1;
 349         }
 350         return changed;
 351 }
 352
 353 static int usb6fire_control_line_phono_get(struct snd_kcontrol *kcontrol,
 354                 struct snd_ctl_elem_value *ucontrol)
 355 {
 356         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 357         ucontrol->value.integer.value[0] = rt->line_phono_switch;
 358         return 0;
 359 }
 360
 361 static int usb6fire_control_opt_coax_info(struct snd_kcontrol *kcontrol,
 362                 struct snd_ctl_elem_info *uinfo)
 363 {
 364         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 365         uinfo->count = 1;
 366         uinfo->value.enumerated.items = 2;
 367         if (uinfo->value.enumerated.item > 1)
 368                 uinfo->value.enumerated.item = 1;
 369         strcpy(uinfo->value.enumerated.name,
 370                         opt_coax_texts[uinfo->value.enumerated.item]);
 371         return 0;
 372 }
 373
 374 static int usb6fire_control_opt_coax_put(struct snd_kcontrol *kcontrol,
 375                 struct snd_ctl_elem_value *ucontrol)
 376 {
 377         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 378         int changed = 0;
 379
 380         if (rt->opt_coax_switch != ucontrol->value.enumerated.item[0]) {
 381                 rt->opt_coax_switch = ucontrol->value.enumerated.item[0];
 382                 usb6fire_control_opt_coax_update(rt);
 383                 changed = 1;
 384         }
 385         return changed;
 386 }
 387
 388 static int usb6fire_control_opt_coax_get(struct snd_kcontrol *kcontrol,
 389                 struct snd_ctl_elem_value *ucontrol)
 390 {
 391         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 392         ucontrol->value.enumerated.item[0] = rt->opt_coax_switch;
 393         return 0;
 394 }
 395
 396 static int usb6fire_control_digital_thru_put(struct snd_kcontrol *kcontrol,
 397                 struct snd_ctl_elem_value *ucontrol)
 398 {
 399         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 400         int changed = 0;
 401
 402         if (rt->digital_thru_switch != ucontrol->value.integer.value[0]) {
 403                 rt->digital_thru_switch = ucontrol->value.integer.value[0];
 404                 usb6fire_control_streaming_update(rt);
 405                 changed = 1;
 406         }
 407         return changed;
 408 }
 409
 410 static int usb6fire_control_digital_thru_get(struct snd_kcontrol *kcontrol,
 411                 struct snd_ctl_elem_value *ucontrol)
 412 {
 413         struct control_runtime *rt = snd_kcontrol_chip(kcontrol);
 414         ucontrol->value.integer.value[0] = rt->digital_thru_switch;
 415         return 0;
 416 }
 417
 418 static struct snd_kcontrol_new vol_elements[] = {
 419         {
 420                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 421                 .name = "Analog Playback Volume",
 422                 .index = 0,
 423                 .private_value = 0,
 424                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 425                         SNDRV_CTL_ELEM_ACCESS_TLV_READ,
 426                 .info = usb6fire_control_output_vol_info,
 427                 .get = usb6fire_control_output_vol_get,
 428                 .put = usb6fire_control_output_vol_put,
 429                 .tlv = { .p = tlv_output }
 430         },
 431         {
 432                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 433                 .name = "Analog Playback Volume",
 434                 .index = 1,
 435                 .private_value = 2,
 436                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 437                         SNDRV_CTL_ELEM_ACCESS_TLV_READ,
 438                 .info = usb6fire_control_output_vol_info,
 439                 .get = usb6fire_control_output_vol_get,
 440                 .put = usb6fire_control_output_vol_put,
 441                 .tlv = { .p = tlv_output }
 442         },
 443         {
 444                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 445                 .name = "Analog Playback Volume",
 446                 .index = 2,
 447                 .private_value = 4,
 448                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 449                         SNDRV_CTL_ELEM_ACCESS_TLV_READ,
 450                 .info = usb6fire_control_output_vol_info,
 451                 .get = usb6fire_control_output_vol_get,
 452                 .put = usb6fire_control_output_vol_put,
 453                 .tlv = { .p = tlv_output }
 454         },
 455         {}
 456 };
 457
 458 static struct snd_kcontrol_new mute_elements[] = {
 459         {
 460                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 461                 .name = "Analog Playback Switch",
 462                 .index = 0,
 463                 .private_value = 0,
 464                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 465                 .info = snd_ctl_boolean_stereo_info,
 466                 .get = usb6fire_control_output_mute_get,
 467                 .put = usb6fire_control_output_mute_put,
 468         },
 469         {
 470                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 471                 .name = "Analog Playback Switch",
 472                 .index = 1,
 473                 .private_value = 2,
 474                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 475                 .info = snd_ctl_boolean_stereo_info,
 476                 .get = usb6fire_control_output_mute_get,
 477                 .put = usb6fire_control_output_mute_put,
 478         },
 479         {
 480                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 481                 .name = "Analog Playback Switch",
 482                 .index = 2,
 483                 .private_value = 4,
 484                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 485                 .info = snd_ctl_boolean_stereo_info,
 486                 .get = usb6fire_control_output_mute_get,
 487                 .put = usb6fire_control_output_mute_put,
 488         },
 489         {}
 490 };
 491
 492 static struct snd_kcontrol_new elements[] = {
 493         {
 494                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 495                 .name = "Line/Phono Capture Route",
 496                 .index = 0,
 497                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 498                 .info = usb6fire_control_line_phono_info,
 499                 .get = usb6fire_control_line_phono_get,
 500                 .put = usb6fire_control_line_phono_put
 501         },
 502         {
 503                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 504                 .name = "Opt/Coax Capture Route",
 505                 .index = 0,
 506                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 507                 .info = usb6fire_control_opt_coax_info,
 508                 .get = usb6fire_control_opt_coax_get,
 509                 .put = usb6fire_control_opt_coax_put
 510         },
 511         {
 512                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 513                 .name = "Digital Thru Playback Route",
 514                 .index = 0,
 515                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 516                 .info = snd_ctl_boolean_mono_info,
 517                 .get = usb6fire_control_digital_thru_get,
 518                 .put = usb6fire_control_digital_thru_put
 519         },
 520         {
 521                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 522                 .name = "Analog Capture Volume",
 523                 .index = 0,
 524                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 525                         SNDRV_CTL_ELEM_ACCESS_TLV_READ,
 526                 .info = usb6fire_control_input_vol_info,
 527                 .get = usb6fire_control_input_vol_get,
 528                 .put = usb6fire_control_input_vol_put,
 529                 .tlv = { .p = tlv_input }
 530         },
 531         {}
 532 };
 533
 534 static int usb6fire_control_add_virtual(
 535         struct control_runtime *rt,
 536         struct snd_card *card,
 537         char *name,
 538         struct snd_kcontrol_new *elems)
 539 {
 540         int ret;
 541         int i;
 542         struct snd_kcontrol *vmaster =
 543                 snd_ctl_make_virtual_master(name, tlv_output);
 544         struct snd_kcontrol *control;
 545
 546         if (!vmaster)
 547                 return -ENOMEM;
 548         ret = snd_ctl_add(card, vmaster);
 549         if (ret < 0)
 550                 return ret;
 551
 552         i = 0;
 553         while (elems[i].name) {
 554                 control = snd_ctl_new1(&elems[i], rt);
 555                 if (!control)
 556                         return -ENOMEM;
 557                 ret = snd_ctl_add(card, control);
 558                 if (ret < 0)
 559                         return ret;
 560                 ret = snd_ctl_add_slave(vmaster, control);
 561                 if (ret < 0)
 562                         return ret;
 563                 i++;
 564         }
 565         return 0;
 566 }
 567
 568 int usb6fire_control_init(struct sfire_chip *chip)
 569 {
 570         int i;
 571         int ret;
 572         struct control_runtime *rt = kzalloc(sizeof(struct control_runtime),
 573                         GFP_KERNEL);
 574         struct comm_runtime *comm_rt = chip->comm;
 575
 576         if (!rt)
 577                 return -ENOMEM;
 578
 579         rt->chip = chip;
 580         rt->update_streaming = usb6fire_control_streaming_update;
 581         rt->set_rate = usb6fire_control_set_rate;
 582         rt->set_channels = usb6fire_control_set_channels;
 583
 584         i = 0;
 585         while (init_data[i].type) {
 586                 comm_rt->write8(comm_rt, init_data[i].type, init_data[i].reg,
 587                                 init_data[i].value);
 588                 i++;
 589         }
 590
 591         usb6fire_control_opt_coax_update(rt);
 592         usb6fire_control_line_phono_update(rt);
 593         usb6fire_control_output_vol_update(rt);
 594         usb6fire_control_output_mute_update(rt);
 595         usb6fire_control_input_vol_update(rt);
 596         usb6fire_control_streaming_update(rt);
 597
 598         ret = usb6fire_control_add_virtual(rt, chip->card,
 599                 "Master Playback Volume", vol_elements);
 600         if (ret) {
 601                 dev_err(&chip->dev->dev, "cannot add control.\n");
 602                 kfree(rt);
 603                 return ret;
 604         }
 605         ret = usb6fire_control_add_virtual(rt, chip->card,
 606                 "Master Playback Switch", mute_elements);
 607         if (ret) {
 608                 dev_err(&chip->dev->dev, "cannot add control.\n");
 609                 kfree(rt);
 610                 return ret;
 611         }
 612
 613         i = 0;
 614         while (elements[i].name) {
 615                 ret = snd_ctl_add(chip->card, snd_ctl_new1(&elements[i], rt));
 616                 if (ret < 0) {
 617                         kfree(rt);
 618                         dev_err(&chip->dev->dev, "cannot add control.\n");
 619                         return ret;
 620                 }
 621                 i++;
 622         }
 623
 624         chip->control = rt;
 625         return 0;
 626 }
 627
 628 void usb6fire_control_abort(struct sfire_chip *chip)
 629 {}
 630
 631 void usb6fire_control_destroy(struct sfire_chip *chip)
 632 {
 633         kfree(chip->control);
 634         chip->control = NULL;
 635 }