sound/usb/caiaq/control.c

   1 /*
   2  *   Copyright (c) 2007 Daniel Mack
   3  *   friendly supported by NI.
   4  *
   5  *   This program is free software; you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation; either version 2 of the License, or
   8  *   (at your option) any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  */
  19
  20 #include <linux/init.h>
  21 #include <linux/usb.h>
  22 #include <sound/control.h>
  23 #include <sound/core.h>
  24 #include <sound/pcm.h>
  25
  26 #include "device.h"
  27 #include "control.h"
  28
  29 #define CNT_INTVAL 0x10000
  30
  31 static int control_info(struct snd_kcontrol *kcontrol,
  32                         struct snd_ctl_elem_info *uinfo)
  33 {
  34         struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol);
  35         struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
  36         int pos = kcontrol->private_value;
  37         int is_intval = pos & CNT_INTVAL;
  38         int maxval = 63;
  39
  40         uinfo->count = 1;
  41         pos &= ~CNT_INTVAL;
  42
  43         switch (dev->chip.usb_id) {
  44         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
  45                 if (pos == 0) {
  46                         /* current input mode of A8DJ */
  47                         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  48                         uinfo->value.integer.min = 0;
  49                         uinfo->value.integer.max = 2;
  50                         return 0;
  51                 }
  52                 break;
  53
  54         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
  55                 if (pos == 0) {
  56                         /* current input mode of A4DJ */
  57                         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  58                         uinfo->value.integer.min = 0;
  59                         uinfo->value.integer.max = 1;
  60                         return 0;
  61                 }
  62                 break;
  63
  64         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
  65                 maxval = 127;
  66                 break;
  67         }
  68
  69         if (is_intval) {
  70                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  71                 uinfo->value.integer.min = 0;
  72                 uinfo->value.integer.max = maxval;
  73         } else {
  74                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
  75                 uinfo->value.integer.min = 0;
  76                 uinfo->value.integer.max = 1;
  77         }
  78
  79         return 0;
  80 }
  81
  82 static int control_get(struct snd_kcontrol *kcontrol,
  83                        struct snd_ctl_elem_value *ucontrol)
  84 {
  85         struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol);
  86         struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
  87         int pos = kcontrol->private_value;
  88
  89         if (dev->chip.usb_id ==
  90                 USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ)) {
  91                 /* A4DJ has only one control */
  92                 /* do not expose hardware input mode 0 */
  93                 ucontrol->value.integer.value[0] = dev->control_state[0] - 1;
  94                 return 0;
  95         }
  96
  97         if (pos & CNT_INTVAL)
  98                 ucontrol->value.integer.value[0]
  99                         = dev->control_state[pos & ~CNT_INTVAL];
 100         else
 101                 ucontrol->value.integer.value[0]
 102                         = !!(dev->control_state[pos / 8] & (1 << pos % 8));
 103
 104         return 0;
 105 }
 106
 107 static int control_put(struct snd_kcontrol *kcontrol,
 108                        struct snd_ctl_elem_value *ucontrol)
 109 {
 110         struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol);
 111         struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
 112         int pos = kcontrol->private_value;
 113         unsigned char cmd = EP1_CMD_WRITE_IO;
 114
 115         switch (dev->chip.usb_id) {
 116         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ): {
 117                 /* A4DJ has only one control */
 118                 /* do not expose hardware input mode 0 */
 119                 dev->control_state[0] = ucontrol->value.integer.value[0] + 1;
 120                 snd_usb_caiaq_send_command(dev, EP1_CMD_WRITE_IO,
 121                                 dev->control_state, sizeof(dev->control_state));
 122                 return 1;
 123         }
 124
 125         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
 126                 cmd = EP1_CMD_DIMM_LEDS;
 127                 break;
 128         }
 129
 130         if (pos & CNT_INTVAL) {
 131                 dev->control_state[pos & ~CNT_INTVAL]
 132                         = ucontrol->value.integer.value[0];
 133                 snd_usb_caiaq_send_command(dev, cmd,
 134                                 dev->control_state, sizeof(dev->control_state));
 135         } else {
 136                 if (ucontrol->value.integer.value[0])
 137                         dev->control_state[pos / 8] |= 1 << (pos % 8);
 138                 else
 139                         dev->control_state[pos / 8] &= ~(1 << (pos % 8));
 140
 141                 snd_usb_caiaq_send_command(dev, cmd,
 142                                 dev->control_state, sizeof(dev->control_state));
 143         }
 144
 145         return 1;
 146 }
 147
 148 static struct snd_kcontrol_new kcontrol_template __devinitdata = {
 149         .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
 150         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 151         .index = 0,
 152         .info = control_info,
 153         .get  = control_get,
 154         .put  = control_put,
 155         /* name and private_value filled later */
 156 };
 157
 158 struct caiaq_controller {
 159         char *name;
 160         int index;
 161 };
 162
 163 static struct caiaq_controller ak1_controller[] = {
 164         { "LED left",   2 },
 165         { "LED middle", 1 },
 166         { "LED right",  0 },
 167         { "LED ring",   3 }
 168 };
 169
 170 static struct caiaq_controller rk2_controller[] = {
 171         { "LED 1",              5  },
 172         { "LED 2",              4  },
 173         { "LED 3",              3  },
 174         { "LED 4",              2  },
 175         { "LED 5",              1  },
 176         { "LED 6",              0  },
 177         { "LED pedal",          6  },
 178         { "LED 7seg_1b",        8  },
 179         { "LED 7seg_1c",        9  },
 180         { "LED 7seg_2a",        10 },
 181         { "LED 7seg_2b",        11 },
 182         { "LED 7seg_2c",        12 },
 183         { "LED 7seg_2d",        13 },
 184         { "LED 7seg_2e",        14 },
 185         { "LED 7seg_2f",        15 },
 186         { "LED 7seg_2g",        16 },
 187         { "LED 7seg_3a",        17 },
 188         { "LED 7seg_3b",        18 },
 189         { "LED 7seg_3c",        19 },
 190         { "LED 7seg_3d",        20 },
 191         { "LED 7seg_3e",        21 },
 192         { "LED 7seg_3f",        22 },
 193         { "LED 7seg_3g",        23 }
 194 };
 195
 196 static struct caiaq_controller rk3_controller[] = {
 197         { "LED 7seg_1a",        0 + 0 },
 198         { "LED 7seg_1b",        0 + 1 },
 199         { "LED 7seg_1c",        0 + 2 },
 200         { "LED 7seg_1d",        0 + 3 },
 201         { "LED 7seg_1e",        0 + 4 },
 202         { "LED 7seg_1f",        0 + 5 },
 203         { "LED 7seg_1g",        0 + 6 },
 204         { "LED 7seg_1p",        0 + 7 },
 205
 206         { "LED 7seg_2a",        8 + 0 },
 207         { "LED 7seg_2b",        8 + 1 },
 208         { "LED 7seg_2c",        8 + 2 },
 209         { "LED 7seg_2d",        8 + 3 },
 210         { "LED 7seg_2e",        8 + 4 },
 211         { "LED 7seg_2f",        8 + 5 },
 212         { "LED 7seg_2g",        8 + 6 },
 213         { "LED 7seg_2p",        8 + 7 },
 214
 215         { "LED 7seg_3a",        16 + 0 },
 216         { "LED 7seg_3b",        16 + 1 },
 217         { "LED 7seg_3c",        16 + 2 },
 218         { "LED 7seg_3d",        16 + 3 },
 219         { "LED 7seg_3e",        16 + 4 },
 220         { "LED 7seg_3f",        16 + 5 },
 221         { "LED 7seg_3g",        16 + 6 },
 222         { "LED 7seg_3p",        16 + 7 },
 223
 224         { "LED 7seg_4a",        24 + 0 },
 225         { "LED 7seg_4b",        24 + 1 },
 226         { "LED 7seg_4c",        24 + 2 },
 227         { "LED 7seg_4d",        24 + 3 },
 228         { "LED 7seg_4e",        24 + 4 },
 229         { "LED 7seg_4f",        24 + 5 },
 230         { "LED 7seg_4g",        24 + 6 },
 231         { "LED 7seg_4p",        24 + 7 },
 232
 233         { "LED 1",              32 + 0 },
 234         { "LED 2",              32 + 1 },
 235         { "LED 3",              32 + 2 },
 236         { "LED 4",              32 + 3 },
 237         { "LED 5",              32 + 4 },
 238         { "LED 6",              32 + 5 },
 239         { "LED 7",              32 + 6 },
 240         { "LED 8",              32 + 7 },
 241         { "LED pedal",          32 + 8 }
 242 };
 243
 244 static struct caiaq_controller kore_controller[] = {
 245         { "LED F1",             8   | CNT_INTVAL },
 246         { "LED F2",             12  | CNT_INTVAL },
 247         { "LED F3",             0   | CNT_INTVAL },
 248         { "LED F4",             4   | CNT_INTVAL },
 249         { "LED F5",             11  | CNT_INTVAL },
 250         { "LED F6",             15  | CNT_INTVAL },
 251         { "LED F7",             3   | CNT_INTVAL },
 252         { "LED F8",             7   | CNT_INTVAL },
 253         { "LED touch1",         10  | CNT_INTVAL },
 254         { "LED touch2",         14  | CNT_INTVAL },
 255         { "LED touch3",         2   | CNT_INTVAL },
 256         { "LED touch4",         6   | CNT_INTVAL },
 257         { "LED touch5",         9   | CNT_INTVAL },
 258         { "LED touch6",         13  | CNT_INTVAL },
 259         { "LED touch7",         1   | CNT_INTVAL },
 260         { "LED touch8",         5   | CNT_INTVAL },
 261         { "LED left",           18  | CNT_INTVAL },
 262         { "LED right",          22  | CNT_INTVAL },
 263         { "LED up",             16  | CNT_INTVAL },
 264         { "LED down",           20  | CNT_INTVAL },
 265         { "LED stop",           23  | CNT_INTVAL },
 266         { "LED play",           21  | CNT_INTVAL },
 267         { "LED record",         19  | CNT_INTVAL },
 268         { "LED listen",         17  | CNT_INTVAL },
 269         { "LED lcd",            30  | CNT_INTVAL },
 270         { "LED menu",           28  | CNT_INTVAL },
 271         { "LED sound",          31  | CNT_INTVAL },
 272         { "LED esc",            29  | CNT_INTVAL },
 273         { "LED view",           27  | CNT_INTVAL },
 274         { "LED enter",          24  | CNT_INTVAL },
 275         { "LED control",        26  | CNT_INTVAL }
 276 };
 277
 278 static struct caiaq_controller a8dj_controller[] = {
 279         { "Current input mode",                 0 | CNT_INTVAL  },
 280         { "GND lift for TC Vinyl mode",         24 + 0          },
 281         { "GND lift for TC CD/Line mode",       24 + 1          },
 282         { "GND lift for phono mode",            24 + 2          },
 283         { "Software lock",                      40              }
 284 };
 285
 286 static struct caiaq_controller a4dj_controller[] = {
 287         { "Current input mode", 0 | CNT_INTVAL  }
 288 };
 289
 290 static struct caiaq_controller kontrolx1_controller[] = {
 291         { "LED FX A: ON",               7 | CNT_INTVAL  },
 292         { "LED FX A: 1",                6 | CNT_INTVAL  },
 293         { "LED FX A: 2",                5 | CNT_INTVAL  },
 294         { "LED FX A: 3",                4 | CNT_INTVAL  },
 295         { "LED FX B: ON",               3 | CNT_INTVAL  },
 296         { "LED FX B: 1",                2 | CNT_INTVAL  },
 297         { "LED FX B: 2",                1 | CNT_INTVAL  },
 298         { "LED FX B: 3",                0 | CNT_INTVAL  },
 299
 300         { "LED Hotcue",                 28 | CNT_INTVAL },
 301         { "LED Shift (white)",          29 | CNT_INTVAL },
 302         { "LED Shift (green)",          30 | CNT_INTVAL },
 303
 304         { "LED Deck A: FX1",            24 | CNT_INTVAL },
 305         { "LED Deck A: FX2",            25 | CNT_INTVAL },
 306         { "LED Deck A: IN",             17 | CNT_INTVAL },
 307         { "LED Deck A: OUT",            16 | CNT_INTVAL },
 308         { "LED Deck A: < BEAT",         19 | CNT_INTVAL },
 309         { "LED Deck A: BEAT >",         18 | CNT_INTVAL },
 310         { "LED Deck A: CUE/ABS",        21 | CNT_INTVAL },
 311         { "LED Deck A: CUP/REL",        20 | CNT_INTVAL },
 312         { "LED Deck A: PLAY",           23 | CNT_INTVAL },
 313         { "LED Deck A: SYNC",           22 | CNT_INTVAL },
 314
 315         { "LED Deck B: FX1",            26 | CNT_INTVAL },
 316         { "LED Deck B: FX2",            27 | CNT_INTVAL },
 317         { "LED Deck B: IN",             15 | CNT_INTVAL },
 318         { "LED Deck B: OUT",            14 | CNT_INTVAL },
 319         { "LED Deck B: < BEAT",         13 | CNT_INTVAL },
 320         { "LED Deck B: BEAT >",         12 | CNT_INTVAL },
 321         { "LED Deck B: CUE/ABS",        11 | CNT_INTVAL },
 322         { "LED Deck B: CUP/REL",        10 | CNT_INTVAL },
 323         { "LED Deck B: PLAY",           9  | CNT_INTVAL },
 324         { "LED Deck B: SYNC",           8  | CNT_INTVAL },
 325 };
 326
 327 static int __devinit add_controls(struct caiaq_controller *c, int num,
 328                                   struct snd_usb_caiaqdev *dev)
 329 {
 330         int i, ret;
 331         struct snd_kcontrol *kc;
 332
 333         for (i = 0; i < num; i++, c++) {
 334                 kcontrol_template.name = c->name;
 335                 kcontrol_template.private_value = c->index;
 336                 kc = snd_ctl_new1(&kcontrol_template, dev);
 337                 ret = snd_ctl_add(dev->chip.card, kc);
 338                 if (ret < 0)
 339                         return ret;
 340         }
 341
 342         return 0;
 343 }
 344
 345 int __devinit snd_usb_caiaq_control_init(struct snd_usb_caiaqdev *dev)
 346 {
 347         int ret = 0;
 348
 349         switch (dev->chip.usb_id) {
 350         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
 351                 ret = add_controls(ak1_controller,
 352                         ARRAY_SIZE(ak1_controller), dev);
 353                 break;
 354
 355         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
 356                 ret = add_controls(rk2_controller,
 357                         ARRAY_SIZE(rk2_controller), dev);
 358                 break;
 359
 360         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
 361                 ret = add_controls(rk3_controller,
 362                         ARRAY_SIZE(rk3_controller), dev);
 363                 break;
 364
 365         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
 366         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
 367                 ret = add_controls(kore_controller,
 368                         ARRAY_SIZE(kore_controller), dev);
 369                 break;
 370
 371         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
 372                 ret = add_controls(a8dj_controller,
 373                         ARRAY_SIZE(a8dj_controller), dev);
 374                 break;
 375
 376         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
 377                 ret = add_controls(a4dj_controller,
 378                         ARRAY_SIZE(a4dj_controller), dev);
 379                 break;
 380
 381         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
 382                 ret = add_controls(kontrolx1_controller,
 383                         ARRAY_SIZE(kontrolx1_controller), dev);
 384                 break;
 385         }
 386
 387         return ret;
 388 }
 389