Pileus Git - ~andy/linux/blob - drivers/staging/line6/pod.c

   1 /*
   2  * Line6 Linux USB driver - 0.9.1beta
   3  *
   4  * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License as
   8  *      published by the Free Software Foundation, version 2.
   9  *
  10  */
  11
  12 #include <linux/slab.h>
  13 #include <linux/wait.h>
  14 #include <sound/control.h>
  15
  16 #include "audio.h"
  17 #include "capture.h"
  18 #include "control.h"
  19 #include "driver.h"
  20 #include "playback.h"
  21 #include "pod.h"
  22
  23 #define POD_SYSEX_CODE 3
  24 #define POD_BYTES_PER_FRAME 6   /* 24bit audio (stereo) */
  25
  26 /* *INDENT-OFF* */
  27
  28 enum {
  29         POD_SYSEX_SAVE      = 0x24,
  30         POD_SYSEX_SYSTEM    = 0x56,
  31         POD_SYSEX_SYSTEMREQ = 0x57,
  32         /* POD_SYSEX_UPDATE    = 0x6c, */  /* software update! */
  33         POD_SYSEX_STORE     = 0x71,
  34         POD_SYSEX_FINISH    = 0x72,
  35         POD_SYSEX_DUMPMEM   = 0x73,
  36         POD_SYSEX_DUMP      = 0x74,
  37         POD_SYSEX_DUMPREQ   = 0x75
  38         /* POD_SYSEX_DUMPMEM2  = 0x76 */   /* dumps entire internal memory of PODxt Pro */
  39 };
  40
  41 enum {
  42         POD_monitor_level  = 0x04,
  43         POD_routing        = 0x05,
  44         POD_tuner_mute     = 0x13,
  45         POD_tuner_freq     = 0x15,
  46         POD_tuner_note     = 0x16,
  47         POD_tuner_pitch    = 0x17,
  48         POD_system_invalid = 0x10000
  49 };
  50
  51 /* *INDENT-ON* */
  52
  53 enum {
  54         POD_DUMP_MEMORY = 2
  55 };
  56
  57 enum {
  58         POD_BUSY_READ,
  59         POD_BUSY_WRITE,
  60         POD_CHANNEL_DIRTY,
  61         POD_SAVE_PRESSED,
  62         POD_BUSY_MIDISEND
  63 };
  64
  65 static struct snd_ratden pod_ratden = {
  66         .num_min = 78125,
  67         .num_max = 78125,
  68         .num_step = 1,
  69         .den = 2
  70 };
  71
  72 static struct line6_pcm_properties pod_pcm_properties = {
  73         .snd_line6_playback_hw = {
  74                                   .info = (SNDRV_PCM_INFO_MMAP |
  75                                            SNDRV_PCM_INFO_INTERLEAVED |
  76                                            SNDRV_PCM_INFO_BLOCK_TRANSFER |
  77                                            SNDRV_PCM_INFO_MMAP_VALID |
  78                                            SNDRV_PCM_INFO_PAUSE |
  79 #ifdef CONFIG_PM
  80                                            SNDRV_PCM_INFO_RESUME |
  81 #endif
  82                                            SNDRV_PCM_INFO_SYNC_START),
  83                                   .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  84                                   .rates = SNDRV_PCM_RATE_KNOT,
  85                                   .rate_min = 39062,
  86                                   .rate_max = 39063,
  87                                   .channels_min = 2,
  88                                   .channels_max = 2,
  89                                   .buffer_bytes_max = 60000,
  90                                   .period_bytes_min = 64,
  91                                   .period_bytes_max = 8192,
  92                                   .periods_min = 1,
  93                                   .periods_max = 1024},
  94         .snd_line6_capture_hw = {
  95                                  .info = (SNDRV_PCM_INFO_MMAP |
  96                                           SNDRV_PCM_INFO_INTERLEAVED |
  97                                           SNDRV_PCM_INFO_BLOCK_TRANSFER |
  98                                           SNDRV_PCM_INFO_MMAP_VALID |
  99 #ifdef CONFIG_PM
 100                                           SNDRV_PCM_INFO_RESUME |
 101 #endif
 102                                           SNDRV_PCM_INFO_SYNC_START),
 103                                  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 104                                  .rates = SNDRV_PCM_RATE_KNOT,
 105                                  .rate_min = 39062,
 106                                  .rate_max = 39063,
 107                                  .channels_min = 2,
 108                                  .channels_max = 2,
 109                                  .buffer_bytes_max = 60000,
 110                                  .period_bytes_min = 64,
 111                                  .period_bytes_max = 8192,
 112                                  .periods_min = 1,
 113                                  .periods_max = 1024},
 114         .snd_line6_rates = {
 115                             .nrats = 1,
 116                             .rats = &pod_ratden},
 117         .bytes_per_frame = POD_BYTES_PER_FRAME
 118 };
 119
 120 static const char pod_request_channel[] = {
 121         0xf0, 0x00, 0x01, 0x0c, 0x03, 0x75, 0xf7
 122 };
 123
 124 static const char pod_version_header[] = {
 125         0xf2, 0x7e, 0x7f, 0x06, 0x02
 126 };
 127
 128 /* forward declarations: */
 129 static void pod_startup2(unsigned long data);
 130 static void pod_startup3(struct usb_line6_pod *pod);
 131 static void pod_startup4(struct usb_line6_pod *pod);
 132
 133 static char *pod_alloc_sysex_buffer(struct usb_line6_pod *pod, int code,
 134                                     int size)
 135 {
 136         return line6_alloc_sysex_buffer(&pod->line6, POD_SYSEX_CODE, code,
 137                                         size);
 138 }
 139
 140 /*
 141         Store parameter value in driver memory.
 142 */
 143 static void pod_store_parameter(struct usb_line6_pod *pod, int param, int value)
 144 {
 145         pod->prog_data.control[param] = value;
 146 }
 147
 148 /*
 149         Handle SAVE button.
 150 */
 151 static void pod_save_button_pressed(struct usb_line6_pod *pod, int type,
 152                                     int index)
 153 {
 154         set_bit(POD_SAVE_PRESSED, &pod->atomic_flags);
 155 }
 156
 157 /*
 158         Process a completely received message.
 159 */
 160 void line6_pod_process_message(struct usb_line6_pod *pod)
 161 {
 162         const unsigned char *buf = pod->line6.buffer_message;
 163
 164         /* filter messages by type */
 165         switch (buf[0] & 0xf0) {
 166         case LINE6_PARAM_CHANGE:
 167         case LINE6_PROGRAM_CHANGE:
 168         case LINE6_SYSEX_BEGIN:
 169                 break;          /* handle these further down */
 170
 171         default:
 172                 return;         /* ignore all others */
 173         }
 174
 175         /* process all remaining messages */
 176         switch (buf[0]) {
 177         case LINE6_PARAM_CHANGE | LINE6_CHANNEL_DEVICE:
 178                 pod_store_parameter(pod, buf[1], buf[2]);
 179                 /* intentionally no break here! */
 180
 181         case LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST:
 182                 if ((buf[1] == POD_amp_model_setup) ||
 183                     (buf[1] == POD_effect_setup))
 184                         /* these also affect other settings */
 185                         line6_dump_request_async(&pod->dumpreq, &pod->line6, 0,
 186                                                  LINE6_DUMP_CURRENT);
 187
 188                 break;
 189
 190         case LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_DEVICE:
 191         case LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST:
 192                 set_bit(POD_CHANNEL_DIRTY, &pod->atomic_flags);
 193                 line6_dump_request_async(&pod->dumpreq, &pod->line6, 0,
 194                                          LINE6_DUMP_CURRENT);
 195                 break;
 196
 197         case LINE6_SYSEX_BEGIN | LINE6_CHANNEL_DEVICE:
 198         case LINE6_SYSEX_BEGIN | LINE6_CHANNEL_UNKNOWN:
 199                 if (memcmp(buf + 1, line6_midi_id, sizeof(line6_midi_id)) == 0) {
 200                         switch (buf[5]) {
 201                         case POD_SYSEX_DUMP:
 202                                 if (pod->line6.message_length ==
 203                                     sizeof(pod->prog_data) + 7) {
 204                                         switch (pod->dumpreq.in_progress) {
 205                                         case LINE6_DUMP_CURRENT:
 206                                                 memcpy(&pod->prog_data, buf + 7,
 207                                                        sizeof(pod->prog_data));
 208                                                 break;
 209
 210                                         case POD_DUMP_MEMORY:
 211                                                 memcpy(&pod->prog_data_buf,
 212                                                        buf + 7,
 213                                                        sizeof
 214                                                        (pod->prog_data_buf));
 215                                                 break;
 216
 217                                         default:
 218                                                 dev_dbg(pod->line6.ifcdev,
 219                                                         "unknown dump code %02X\n",
 220                                                         pod->dumpreq.in_progress);
 221                                         }
 222
 223                                         line6_dump_finished(&pod->dumpreq);
 224                                         pod_startup3(pod);
 225                                 } else
 226                                         dev_dbg(pod->line6.ifcdev,
 227                                                 "wrong size of channel dump message (%d instead of %d)\n",
 228                                                 pod->line6.message_length,
 229                                                 (int)sizeof(pod->prog_data) +
 230                                                 7);
 231
 232                                 break;
 233
 234                         case POD_SYSEX_SYSTEM:{
 235                                         short value =
 236                                             ((int)buf[7] << 12) | ((int)buf[8]
 237                                                                    << 8) |
 238                                             ((int)buf[9] << 4) | (int)buf[10];
 239
 240 #define PROCESS_SYSTEM_PARAM(x) \
 241                                         case POD_ ## x: \
 242                                                 pod->x.value = value; \
 243                                                 wake_up(&pod->x.wait); \
 244                                                 break;
 245
 246                                         switch (buf[6]) {
 247                                         case POD_monitor_level:
 248                                                 pod->monitor_level = value;
 249                                                 break;
 250
 251                                                 PROCESS_SYSTEM_PARAM(routing);
 252                                                 PROCESS_SYSTEM_PARAM
 253                                                     (tuner_mute);
 254                                                 PROCESS_SYSTEM_PARAM
 255                                                     (tuner_freq);
 256                                                 PROCESS_SYSTEM_PARAM
 257                                                     (tuner_note);
 258                                                 PROCESS_SYSTEM_PARAM
 259                                                     (tuner_pitch);
 260
 261 #undef PROCESS_SYSTEM_PARAM
 262
 263                                         default:
 264                                                 dev_dbg(pod->line6.ifcdev,
 265                                                         "unknown tuner/system response %02X\n",
 266                                                         buf[6]);
 267                                         }
 268
 269                                         break;
 270                                 }
 271
 272                         case POD_SYSEX_FINISH:
 273                                 /* do we need to respond to this? */
 274                                 break;
 275
 276                         case POD_SYSEX_SAVE:
 277                                 pod_save_button_pressed(pod, buf[6], buf[7]);
 278                                 break;
 279
 280                         case POD_SYSEX_STORE:
 281                                 dev_dbg(pod->line6.ifcdev,
 282                                         "message %02X not yet implemented\n",
 283                                         buf[5]);
 284                                 break;
 285
 286                         default:
 287                                 dev_dbg(pod->line6.ifcdev,
 288                                         "unknown sysex message %02X\n",
 289                                         buf[5]);
 290                         }
 291                 } else
 292                     if (memcmp
 293                         (buf, pod_version_header,
 294                          sizeof(pod_version_header)) == 0) {
 295                         pod->firmware_version =
 296                             buf[13] * 100 + buf[14] * 10 + buf[15];
 297                         pod->device_id =
 298                             ((int)buf[8] << 16) | ((int)buf[9] << 8) | (int)
 299                             buf[10];
 300                         pod_startup4(pod);
 301                 } else
 302                         dev_dbg(pod->line6.ifcdev, "unknown sysex header\n");
 303
 304                 break;
 305
 306         case LINE6_SYSEX_END:
 307                 break;
 308
 309         default:
 310                 dev_dbg(pod->line6.ifcdev, "POD: unknown message %02X\n",
 311                         buf[0]);
 312         }
 313 }
 314
 315 /*
 316         Detect some cases that require a channel dump after sending a command to the
 317         device. Important notes:
 318         *) The actual dump request can not be sent here since we are not allowed to
 319         wait for the completion of the first message in this context, and sending
 320         the dump request before completion of the previous message leaves the POD
 321         in an undefined state. The dump request will be sent when the echoed
 322         commands are received.
 323         *) This method fails if a param change message is "chopped" after the first
 324         byte.
 325 */
 326 void line6_pod_midi_postprocess(struct usb_line6_pod *pod, unsigned char *data,
 327                                 int length)
 328 {
 329         int i;
 330
 331         if (!pod->midi_postprocess)
 332                 return;
 333
 334         for (i = 0; i < length; ++i) {
 335                 if (data[i] == (LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST)) {
 336                         line6_invalidate_current(&pod->dumpreq);
 337                         break;
 338                 } else
 339                     if ((data[i] == (LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST))
 340                         && (i < length - 1))
 341                         if ((data[i + 1] == POD_amp_model_setup)
 342                             || (data[i + 1] == POD_effect_setup)) {
 343                                 line6_invalidate_current(&pod->dumpreq);
 344                                 break;
 345                         }
 346         }
 347 }
 348
 349 /*
 350         Transmit PODxt Pro control parameter.
 351 */
 352 void line6_pod_transmit_parameter(struct usb_line6_pod *pod, int param,
 353                                   u8 value)
 354 {
 355         if (line6_transmit_parameter(&pod->line6, param, value) == 0)
 356                 pod_store_parameter(pod, param, value);
 357
 358         if ((param == POD_amp_model_setup) || (param == POD_effect_setup))      /* these also affect other settings */
 359                 line6_invalidate_current(&pod->dumpreq);
 360 }
 361
 362 /*
 363         Resolve value to memory location.
 364 */
 365 static int pod_resolve(const char *buf, short block0, short block1,
 366                        unsigned char *location)
 367 {
 368         u8 value;
 369         short block;
 370         int ret;
 371
 372         ret = kstrtou8(buf, 10, &value);
 373         if (ret)
 374                 return ret;
 375
 376         block = (value < 0x40) ? block0 : block1;
 377         value &= 0x3f;
 378         location[0] = block >> 7;
 379         location[1] = value | (block & 0x7f);
 380         return 0;
 381 }
 382
 383 /*
 384         Send command to store channel/effects setup/amp setup to PODxt Pro.
 385 */
 386 static ssize_t pod_send_store_command(struct device *dev, const char *buf,
 387                                       size_t count, short block0, short block1)
 388 {
 389         struct usb_interface *interface = to_usb_interface(dev);
 390         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 391         int ret;
 392         int size = 3 + sizeof(pod->prog_data_buf);
 393         char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_STORE, size);
 394
 395         if (!sysex)
 396                 return 0;
 397
 398         /* Don't know what this is good for, but PODxt Pro transmits it, so we
 399          * also do... */
 400         sysex[SYSEX_DATA_OFS] = 5;
 401         ret = pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS + 1);
 402         if (ret) {
 403                 kfree(sysex);
 404                 return ret;
 405         }
 406
 407         memcpy(sysex + SYSEX_DATA_OFS + 3, &pod->prog_data_buf,
 408                sizeof(pod->prog_data_buf));
 409
 410         line6_send_sysex_message(&pod->line6, sysex, size);
 411         kfree(sysex);
 412         /* needs some delay here on AMD64 platform */
 413         return count;
 414 }
 415
 416 /*
 417         Send command to retrieve channel/effects setup/amp setup to PODxt Pro.
 418 */
 419 static ssize_t pod_send_retrieve_command(struct device *dev, const char *buf,
 420                                          size_t count, short block0,
 421                                          short block1)
 422 {
 423         struct usb_interface *interface = to_usb_interface(dev);
 424         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 425         int ret;
 426         int size = 4;
 427         char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_DUMPMEM, size);
 428
 429         if (!sysex)
 430                 return 0;
 431
 432         ret = pod_resolve(buf, block0, block1, sysex + SYSEX_DATA_OFS);
 433         if (ret) {
 434                 kfree(sysex);
 435                 return ret;
 436         }
 437         sysex[SYSEX_DATA_OFS + 2] = 0;
 438         sysex[SYSEX_DATA_OFS + 3] = 0;
 439         line6_dump_started(&pod->dumpreq, POD_DUMP_MEMORY);
 440
 441         if (line6_send_sysex_message(&pod->line6, sysex, size) < size)
 442                 line6_dump_finished(&pod->dumpreq);
 443
 444         kfree(sysex);
 445         /* needs some delay here on AMD64 platform */
 446         return count;
 447 }
 448
 449 /*
 450         Identify system parameters related to the tuner.
 451 */
 452 static bool pod_is_tuner(int code)
 453 {
 454         return
 455             (code == POD_tuner_mute) ||
 456             (code == POD_tuner_freq) ||
 457             (code == POD_tuner_note) || (code == POD_tuner_pitch);
 458 }
 459
 460 /*
 461         Get system parameter (as integer).
 462         @param tuner non-zero, if code refers to a tuner parameter
 463 */
 464 static int pod_get_system_param_int(struct usb_line6_pod *pod, int *value,
 465                                     int code, struct ValueWait *param, int sign)
 466 {
 467         char *sysex;
 468         static const int size = 1;
 469         int retval = 0;
 470
 471         if (((pod->prog_data.control[POD_tuner] & 0x40) == 0)
 472             && pod_is_tuner(code))
 473                 return -ENODEV;
 474
 475         /* send value request to device: */
 476         param->value = POD_system_invalid;
 477         sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEMREQ, size);
 478
 479         if (!sysex)
 480                 return -ENOMEM;
 481
 482         sysex[SYSEX_DATA_OFS] = code;
 483         line6_send_sysex_message(&pod->line6, sysex, size);
 484         kfree(sysex);
 485
 486         /* wait for device to respond: */
 487         retval =
 488             wait_event_interruptible(param->wait,
 489                                      param->value != POD_system_invalid);
 490
 491         if (retval < 0)
 492                 return retval;
 493
 494         *value = sign ? (int)(signed short)param->value : (int)(unsigned short)
 495             param->value;
 496
 497         if (*value == POD_system_invalid)
 498                 *value = 0;     /* don't report uninitialized values */
 499
 500         return 0;
 501 }
 502
 503 /*
 504         Get system parameter (as string).
 505         @param tuner non-zero, if code refers to a tuner parameter
 506 */
 507 static ssize_t pod_get_system_param_string(struct usb_line6_pod *pod, char *buf,
 508                                            int code, struct ValueWait *param,
 509                                            int sign)
 510 {
 511         int retval, value = 0;
 512         retval = pod_get_system_param_int(pod, &value, code, param, sign);
 513
 514         if (retval < 0)
 515                 return retval;
 516
 517         return sprintf(buf, "%d\n", value);
 518 }
 519
 520 /*
 521         Send system parameter (from integer).
 522         @param tuner non-zero, if code refers to a tuner parameter
 523 */
 524 static int pod_set_system_param_int(struct usb_line6_pod *pod, int value,
 525                                     int code)
 526 {
 527         char *sysex;
 528         static const int size = 5;
 529
 530         if (((pod->prog_data.control[POD_tuner] & 0x40) == 0)
 531             && pod_is_tuner(code))
 532                 return -EINVAL;
 533
 534         /* send value to tuner: */
 535         sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size);
 536         if (!sysex)
 537                 return -ENOMEM;
 538         sysex[SYSEX_DATA_OFS] = code;
 539         sysex[SYSEX_DATA_OFS + 1] = (value >> 12) & 0x0f;
 540         sysex[SYSEX_DATA_OFS + 2] = (value >> 8) & 0x0f;
 541         sysex[SYSEX_DATA_OFS + 3] = (value >> 4) & 0x0f;
 542         sysex[SYSEX_DATA_OFS + 4] = (value) & 0x0f;
 543         line6_send_sysex_message(&pod->line6, sysex, size);
 544         kfree(sysex);
 545         return 0;
 546 }
 547
 548 /*
 549         Send system parameter (from string).
 550         @param tuner non-zero, if code refers to a tuner parameter
 551 */
 552 static ssize_t pod_set_system_param_string(struct usb_line6_pod *pod,
 553                                            const char *buf, int count, int code,
 554                                            unsigned short mask)
 555 {
 556         int retval;
 557         unsigned short value = simple_strtoul(buf, NULL, 10) & mask;
 558         retval = pod_set_system_param_int(pod, value, code);
 559         return (retval < 0) ? retval : count;
 560 }
 561
 562 /*
 563         "write" request on "finish" special file.
 564 */
 565 static ssize_t pod_set_finish(struct device *dev,
 566                               struct device_attribute *attr,
 567                               const char *buf, size_t count)
 568 {
 569         struct usb_interface *interface = to_usb_interface(dev);
 570         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 571         int size = 0;
 572         char *sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_FINISH, size);
 573         if (!sysex)
 574                 return 0;
 575         line6_send_sysex_message(&pod->line6, sysex, size);
 576         kfree(sysex);
 577         return count;
 578 }
 579
 580 /*
 581         "write" request on "store_channel" special file.
 582 */
 583 static ssize_t pod_set_store_channel(struct device *dev,
 584                                      struct device_attribute *attr,
 585                                      const char *buf, size_t count)
 586 {
 587         return pod_send_store_command(dev, buf, count, 0x0000, 0x00c0);
 588 }
 589
 590 /*
 591         "write" request on "store_effects_setup" special file.
 592 */
 593 static ssize_t pod_set_store_effects_setup(struct device *dev,
 594                                            struct device_attribute *attr,
 595                                            const char *buf, size_t count)
 596 {
 597         return pod_send_store_command(dev, buf, count, 0x0080, 0x0080);
 598 }
 599
 600 /*
 601         "write" request on "store_amp_setup" special file.
 602 */
 603 static ssize_t pod_set_store_amp_setup(struct device *dev,
 604                                        struct device_attribute *attr,
 605                                        const char *buf, size_t count)
 606 {
 607         return pod_send_store_command(dev, buf, count, 0x0040, 0x0100);
 608 }
 609
 610 /*
 611         "write" request on "retrieve_effects_setup" special file.
 612 */
 613 static ssize_t pod_set_retrieve_effects_setup(struct device *dev,
 614                                               struct device_attribute *attr,
 615                                               const char *buf, size_t count)
 616 {
 617         return pod_send_retrieve_command(dev, buf, count, 0x0080, 0x0080);
 618 }
 619
 620 /*
 621         "read" request on "midi_postprocess" special file.
 622 */
 623 static ssize_t pod_get_midi_postprocess(struct device *dev,
 624                                         struct device_attribute *attr,
 625                                         char *buf)
 626 {
 627         struct usb_interface *interface = to_usb_interface(dev);
 628         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 629         return sprintf(buf, "%d\n", pod->midi_postprocess);
 630 }
 631
 632 /*
 633         "write" request on "midi_postprocess" special file.
 634 */
 635 static ssize_t pod_set_midi_postprocess(struct device *dev,
 636                                         struct device_attribute *attr,
 637                                         const char *buf, size_t count)
 638 {
 639         struct usb_interface *interface = to_usb_interface(dev);
 640         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 641         u8 value;
 642         int ret;
 643
 644         ret = kstrtou8(buf, 10, &value);
 645         if (ret)
 646                 return ret;
 647
 648         pod->midi_postprocess = value ? 1 : 0;
 649         return count;
 650 }
 651
 652 /*
 653         "read" request on "serial_number" special file.
 654 */
 655 static ssize_t pod_get_serial_number(struct device *dev,
 656                                      struct device_attribute *attr, char *buf)
 657 {
 658         struct usb_interface *interface = to_usb_interface(dev);
 659         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 660         return sprintf(buf, "%d\n", pod->serial_number);
 661 }
 662
 663 /*
 664         "read" request on "firmware_version" special file.
 665 */
 666 static ssize_t pod_get_firmware_version(struct device *dev,
 667                                         struct device_attribute *attr,
 668                                         char *buf)
 669 {
 670         struct usb_interface *interface = to_usb_interface(dev);
 671         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 672         return sprintf(buf, "%d.%02d\n", pod->firmware_version / 100,
 673                        pod->firmware_version % 100);
 674 }
 675
 676 /*
 677         "read" request on "device_id" special file.
 678 */
 679 static ssize_t pod_get_device_id(struct device *dev,
 680                                  struct device_attribute *attr, char *buf)
 681 {
 682         struct usb_interface *interface = to_usb_interface(dev);
 683         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 684         return sprintf(buf, "%d\n", pod->device_id);
 685 }
 686
 687 /*
 688         POD startup procedure.
 689         This is a sequence of functions with special requirements (e.g., must
 690         not run immediately after initialization, must not run in interrupt
 691         context). After the last one has finished, the device is ready to use.
 692 */
 693
 694 static void pod_startup1(struct usb_line6_pod *pod)
 695 {
 696         CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_INIT);
 697
 698         /* delay startup procedure: */
 699         line6_start_timer(&pod->startup_timer, POD_STARTUP_DELAY, pod_startup2,
 700                           (unsigned long)pod);
 701 }
 702
 703 static void pod_startup2(unsigned long data)
 704 {
 705         struct usb_line6_pod *pod = (struct usb_line6_pod *)data;
 706
 707         /* schedule another startup procedure until startup is complete: */
 708         if (pod->startup_progress >= POD_STARTUP_LAST)
 709                 return;
 710
 711         pod->startup_progress = POD_STARTUP_DUMPREQ;
 712         line6_start_timer(&pod->startup_timer, POD_STARTUP_DELAY, pod_startup2,
 713                           (unsigned long)pod);
 714
 715         /* current channel dump: */
 716         line6_dump_request_async(&pod->dumpreq, &pod->line6, 0,
 717                                  LINE6_DUMP_CURRENT);
 718 }
 719
 720 static void pod_startup3(struct usb_line6_pod *pod)
 721 {
 722         struct usb_line6 *line6 = &pod->line6;
 723         CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_VERSIONREQ);
 724
 725         /* request firmware version: */
 726         line6_version_request_async(line6);
 727 }
 728
 729 static void pod_startup4(struct usb_line6_pod *pod)
 730 {
 731         CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_WORKQUEUE);
 732
 733         /* schedule work for global work queue: */
 734         schedule_work(&pod->startup_work);
 735 }
 736
 737 static void pod_startup5(struct work_struct *work)
 738 {
 739         struct usb_line6_pod *pod =
 740             container_of(work, struct usb_line6_pod, startup_work);
 741         struct usb_line6 *line6 = &pod->line6;
 742
 743         CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_SETUP);
 744
 745         /* serial number: */
 746         line6_read_serial_number(&pod->line6, &pod->serial_number);
 747
 748         /* ALSA audio interface: */
 749         line6_register_audio(line6);
 750
 751         /* device files: */
 752         line6_pod_create_files(pod->firmware_version,
 753                                line6->properties->device_bit, line6->ifcdev);
 754 }
 755
 756 #define POD_GET_SYSTEM_PARAM(code, sign) \
 757 static ssize_t pod_get_ ## code(struct device *dev, \
 758                                 struct device_attribute *attr, char *buf) \
 759 { \
 760         struct usb_interface *interface = to_usb_interface(dev); \
 761         struct usb_line6_pod *pod = usb_get_intfdata(interface); \
 762         return pod_get_system_param_string(pod, buf, POD_ ## code,      \
 763                                            &pod->code, sign);           \
 764 }
 765
 766 #define POD_GET_SET_SYSTEM_PARAM(code, mask, sign) \
 767 POD_GET_SYSTEM_PARAM(code, sign) \
 768 static ssize_t pod_set_ ## code(struct device *dev, \
 769                                 struct device_attribute *attr, \
 770                                 const char *buf, size_t count) \
 771 { \
 772         struct usb_interface *interface = to_usb_interface(dev); \
 773         struct usb_line6_pod *pod = usb_get_intfdata(interface); \
 774         return pod_set_system_param_string(pod, buf, count, POD_ ## code, mask); \
 775 }
 776
 777 POD_GET_SET_SYSTEM_PARAM(routing, 0x0003, 0);
 778 POD_GET_SET_SYSTEM_PARAM(tuner_mute, 0x0001, 0);
 779 POD_GET_SET_SYSTEM_PARAM(tuner_freq, 0xffff, 0);
 780 POD_GET_SYSTEM_PARAM(tuner_note, 1);
 781 POD_GET_SYSTEM_PARAM(tuner_pitch, 1);
 782
 783 #undef GET_SET_SYSTEM_PARAM
 784 #undef GET_SYSTEM_PARAM
 785
 786 /* POD special files: */
 787 static DEVICE_ATTR(device_id, S_IRUGO, pod_get_device_id, line6_nop_write);
 788 static DEVICE_ATTR(finish, S_IWUSR, line6_nop_read, pod_set_finish);
 789 static DEVICE_ATTR(firmware_version, S_IRUGO, pod_get_firmware_version,
 790                    line6_nop_write);
 791 static DEVICE_ATTR(midi_postprocess, S_IWUSR | S_IRUGO,
 792                    pod_get_midi_postprocess, pod_set_midi_postprocess);
 793 static DEVICE_ATTR(retrieve_effects_setup, S_IWUSR, line6_nop_read,
 794                    pod_set_retrieve_effects_setup);
 795 static DEVICE_ATTR(routing, S_IWUSR | S_IRUGO, pod_get_routing,
 796                    pod_set_routing);
 797 static DEVICE_ATTR(serial_number, S_IRUGO, pod_get_serial_number,
 798                    line6_nop_write);
 799 static DEVICE_ATTR(store_amp_setup, S_IWUSR, line6_nop_read,
 800                    pod_set_store_amp_setup);
 801 static DEVICE_ATTR(store_channel, S_IWUSR, line6_nop_read,
 802                    pod_set_store_channel);
 803 static DEVICE_ATTR(store_effects_setup, S_IWUSR, line6_nop_read,
 804                    pod_set_store_effects_setup);
 805 static DEVICE_ATTR(tuner_freq, S_IWUSR | S_IRUGO, pod_get_tuner_freq,
 806                    pod_set_tuner_freq);
 807 static DEVICE_ATTR(tuner_mute, S_IWUSR | S_IRUGO, pod_get_tuner_mute,
 808                    pod_set_tuner_mute);
 809 static DEVICE_ATTR(tuner_note, S_IRUGO, pod_get_tuner_note, line6_nop_write);
 810 static DEVICE_ATTR(tuner_pitch, S_IRUGO, pod_get_tuner_pitch, line6_nop_write);
 811
 812 #ifdef CONFIG_LINE6_USB_RAW
 813 static DEVICE_ATTR(raw, S_IWUSR, line6_nop_read, line6_set_raw);
 814 #endif
 815
 816 /* control info callback */
 817 static int snd_pod_control_monitor_info(struct snd_kcontrol *kcontrol,
 818                                         struct snd_ctl_elem_info *uinfo)
 819 {
 820         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 821         uinfo->count = 1;
 822         uinfo->value.integer.min = 0;
 823         uinfo->value.integer.max = 65535;
 824         return 0;
 825 }
 826
 827 /* control get callback */
 828 static int snd_pod_control_monitor_get(struct snd_kcontrol *kcontrol,
 829                                        struct snd_ctl_elem_value *ucontrol)
 830 {
 831         struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
 832         struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;
 833         ucontrol->value.integer.value[0] = pod->monitor_level;
 834         return 0;
 835 }
 836
 837 /* control put callback */
 838 static int snd_pod_control_monitor_put(struct snd_kcontrol *kcontrol,
 839                                        struct snd_ctl_elem_value *ucontrol)
 840 {
 841         struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
 842         struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;
 843
 844         if (ucontrol->value.integer.value[0] == pod->monitor_level)
 845                 return 0;
 846
 847         pod->monitor_level = ucontrol->value.integer.value[0];
 848         pod_set_system_param_int(pod, ucontrol->value.integer.value[0],
 849                                  POD_monitor_level);
 850         return 1;
 851 }
 852
 853 /* control definition */
 854 static struct snd_kcontrol_new pod_control_monitor = {
 855         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 856         .name = "Monitor Playback Volume",
 857         .index = 0,
 858         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 859         .info = snd_pod_control_monitor_info,
 860         .get = snd_pod_control_monitor_get,
 861         .put = snd_pod_control_monitor_put
 862 };
 863
 864 /*
 865         POD destructor.
 866 */
 867 static void pod_destruct(struct usb_interface *interface)
 868 {
 869         struct usb_line6_pod *pod = usb_get_intfdata(interface);
 870
 871         if (pod == NULL)
 872                 return;
 873         line6_cleanup_audio(&pod->line6);
 874
 875         del_timer(&pod->startup_timer);
 876         cancel_work_sync(&pod->startup_work);
 877
 878         /* free dump request data: */
 879         line6_dumpreq_destruct(&pod->dumpreq);
 880 }
 881
 882 /*
 883         Create sysfs entries.
 884 */
 885 static int pod_create_files2(struct device *dev)
 886 {
 887         int err;
 888
 889         CHECK_RETURN(device_create_file(dev, &dev_attr_device_id));
 890         CHECK_RETURN(device_create_file(dev, &dev_attr_finish));
 891         CHECK_RETURN(device_create_file(dev, &dev_attr_firmware_version));
 892         CHECK_RETURN(device_create_file(dev, &dev_attr_midi_postprocess));
 893         CHECK_RETURN(device_create_file(dev, &dev_attr_retrieve_effects_setup));
 894         CHECK_RETURN(device_create_file(dev, &dev_attr_routing));
 895         CHECK_RETURN(device_create_file(dev, &dev_attr_serial_number));
 896         CHECK_RETURN(device_create_file(dev, &dev_attr_store_amp_setup));
 897         CHECK_RETURN(device_create_file(dev, &dev_attr_store_channel));
 898         CHECK_RETURN(device_create_file(dev, &dev_attr_store_effects_setup));
 899         CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_freq));
 900         CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_mute));
 901         CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_note));
 902         CHECK_RETURN(device_create_file(dev, &dev_attr_tuner_pitch));
 903
 904 #ifdef CONFIG_LINE6_USB_RAW
 905         CHECK_RETURN(device_create_file(dev, &dev_attr_raw));
 906 #endif
 907
 908         return 0;
 909 }
 910
 911 /*
 912          Try to init POD device.
 913 */
 914 static int pod_try_init(struct usb_interface *interface,
 915                         struct usb_line6_pod *pod)
 916 {
 917         int err;
 918         struct usb_line6 *line6 = &pod->line6;
 919
 920         init_timer(&pod->startup_timer);
 921         INIT_WORK(&pod->startup_work, pod_startup5);
 922
 923         if ((interface == NULL) || (pod == NULL))
 924                 return -ENODEV;
 925
 926         /* initialize wait queues: */
 927         init_waitqueue_head(&pod->routing.wait);
 928         init_waitqueue_head(&pod->tuner_mute.wait);
 929         init_waitqueue_head(&pod->tuner_freq.wait);
 930         init_waitqueue_head(&pod->tuner_note.wait);
 931         init_waitqueue_head(&pod->tuner_pitch.wait);
 932
 933         /* initialize USB buffers: */
 934         err = line6_dumpreq_init(&pod->dumpreq, pod_request_channel,
 935                                  sizeof(pod_request_channel));
 936         if (err < 0) {
 937                 dev_err(&interface->dev, "Out of memory\n");
 938                 return -ENOMEM;
 939         }
 940
 941         /* create sysfs entries: */
 942         err = pod_create_files2(&interface->dev);
 943         if (err < 0)
 944                 return err;
 945
 946         /* initialize audio system: */
 947         err = line6_init_audio(line6);
 948         if (err < 0)
 949                 return err;
 950
 951         /* initialize MIDI subsystem: */
 952         err = line6_init_midi(line6);
 953         if (err < 0)
 954                 return err;
 955
 956         /* initialize PCM subsystem: */
 957         err = line6_init_pcm(line6, &pod_pcm_properties);
 958         if (err < 0)
 959                 return err;
 960
 961         /* register monitor control: */
 962         err = snd_ctl_add(line6->card,
 963                           snd_ctl_new1(&pod_control_monitor, line6->line6pcm));
 964         if (err < 0)
 965                 return err;
 966
 967         /*
 968            When the sound card is registered at this point, the PODxt Live
 969            displays "Invalid Code Error 07", so we do it later in the event
 970            handler.
 971          */
 972
 973         if (pod->line6.properties->capabilities & LINE6_BIT_CONTROL) {
 974                 pod->monitor_level = POD_system_invalid;
 975
 976                 /* initiate startup procedure: */
 977                 pod_startup1(pod);
 978         }
 979
 980         return 0;
 981 }
 982
 983 /*
 984          Init POD device (and clean up in case of failure).
 985 */
 986 int line6_pod_init(struct usb_interface *interface, struct usb_line6_pod *pod)
 987 {
 988         int err = pod_try_init(interface, pod);
 989
 990         if (err < 0)
 991                 pod_destruct(interface);
 992
 993         return err;
 994 }
 995
 996 /*
 997         POD device disconnected.
 998 */
 999 void line6_pod_disconnect(struct usb_interface *interface)
1000 {
1001         struct usb_line6_pod *pod;
1002
1003         if (interface == NULL)
1004                 return;
1005         pod = usb_get_intfdata(interface);
1006
1007         if (pod != NULL) {
1008                 struct snd_line6_pcm *line6pcm = pod->line6.line6pcm;
1009                 struct device *dev = &interface->dev;
1010
1011                 if (line6pcm != NULL)
1012                         line6_pcm_disconnect(line6pcm);
1013
1014                 if (dev != NULL) {
1015                         /* remove sysfs entries: */
1016                         line6_pod_remove_files(pod->firmware_version,
1017                                                pod->line6.
1018                                                properties->device_bit, dev);
1019
1020                         device_remove_file(dev, &dev_attr_device_id);
1021                         device_remove_file(dev, &dev_attr_finish);
1022                         device_remove_file(dev, &dev_attr_firmware_version);
1023                         device_remove_file(dev, &dev_attr_midi_postprocess);
1024                         device_remove_file(dev,
1025                                            &dev_attr_retrieve_effects_setup);
1026                         device_remove_file(dev, &dev_attr_routing);
1027                         device_remove_file(dev, &dev_attr_serial_number);
1028                         device_remove_file(dev, &dev_attr_store_amp_setup);
1029                         device_remove_file(dev, &dev_attr_store_channel);
1030                         device_remove_file(dev, &dev_attr_store_effects_setup);
1031                         device_remove_file(dev, &dev_attr_tuner_freq);
1032                         device_remove_file(dev, &dev_attr_tuner_mute);
1033                         device_remove_file(dev, &dev_attr_tuner_note);
1034                         device_remove_file(dev, &dev_attr_tuner_pitch);
1035
1036 #ifdef CONFIG_LINE6_USB_RAW
1037                         device_remove_file(dev, &dev_attr_raw);
1038 #endif
1039                 }
1040         }
1041
1042         pod_destruct(interface);
1043 }