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