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