906 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Line 6 Linux USB driver4 *5 * Copyright (C) 2004-2010 Markus Grabner (line6@grabner-graz.at)6 */7 8#include <linux/kernel.h>9#include <linux/module.h>10#include <linux/export.h>11#include <linux/slab.h>12#include <linux/usb.h>13 14#include <sound/core.h>15#include <sound/initval.h>16#include <sound/hwdep.h>17 18#include "capture.h"19#include "driver.h"20#include "midi.h"21#include "playback.h"22 23#define DRIVER_AUTHOR "Markus Grabner <line6@grabner-graz.at>"24#define DRIVER_DESC "Line 6 USB Driver"25 26/*27 This is Line 6's MIDI manufacturer ID.28*/29const unsigned char line6_midi_id[3] = {30 0x00, 0x01, 0x0c31};32EXPORT_SYMBOL_GPL(line6_midi_id);33 34/*35 Code to request version of POD, Variax interface36 (and maybe other devices).37*/38static const char line6_request_version[] = {39 0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf740};41 42/*43 Class for asynchronous messages.44*/45struct message {46 struct usb_line6 *line6;47 const char *buffer;48 int size;49 int done;50};51 52/*53 Forward declarations.54*/55static void line6_data_received(struct urb *urb);56static int line6_send_raw_message_async_part(struct message *msg,57 struct urb *urb);58 59/*60 Start to listen on endpoint.61*/62static int line6_start_listen(struct usb_line6 *line6)63{64 int err;65 66 if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) {67 usb_fill_int_urb(line6->urb_listen, line6->usbdev,68 usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r),69 line6->buffer_listen, LINE6_BUFSIZE_LISTEN,70 line6_data_received, line6, line6->interval);71 } else {72 usb_fill_bulk_urb(line6->urb_listen, line6->usbdev,73 usb_rcvbulkpipe(line6->usbdev, line6->properties->ep_ctrl_r),74 line6->buffer_listen, LINE6_BUFSIZE_LISTEN,75 line6_data_received, line6);76 }77 78 /* sanity checks of EP before actually submitting */79 if (usb_urb_ep_type_check(line6->urb_listen)) {80 dev_err(line6->ifcdev, "invalid control EP\n");81 return -EINVAL;82 }83 84 line6->urb_listen->actual_length = 0;85 err = usb_submit_urb(line6->urb_listen, GFP_ATOMIC);86 return err;87}88 89/*90 Stop listening on endpoint.91*/92static void line6_stop_listen(struct usb_line6 *line6)93{94 usb_kill_urb(line6->urb_listen);95}96 97/*98 Send raw message in pieces of wMaxPacketSize bytes.99*/100int line6_send_raw_message(struct usb_line6 *line6, const char *buffer,101 int size)102{103 int i, done = 0;104 const struct line6_properties *properties = line6->properties;105 106 for (i = 0; i < size; i += line6->max_packet_size) {107 int partial;108 const char *frag_buf = buffer + i;109 int frag_size = min(line6->max_packet_size, size - i);110 int retval;111 112 if (properties->capabilities & LINE6_CAP_CONTROL_MIDI) {113 retval = usb_interrupt_msg(line6->usbdev,114 usb_sndintpipe(line6->usbdev, properties->ep_ctrl_w),115 (char *)frag_buf, frag_size,116 &partial, LINE6_TIMEOUT);117 } else {118 retval = usb_bulk_msg(line6->usbdev,119 usb_sndbulkpipe(line6->usbdev, properties->ep_ctrl_w),120 (char *)frag_buf, frag_size,121 &partial, LINE6_TIMEOUT);122 }123 124 if (retval) {125 dev_err(line6->ifcdev,126 "usb_bulk_msg failed (%d)\n", retval);127 break;128 }129 130 done += frag_size;131 }132 133 return done;134}135EXPORT_SYMBOL_GPL(line6_send_raw_message);136 137/*138 Notification of completion of asynchronous request transmission.139*/140static void line6_async_request_sent(struct urb *urb)141{142 struct message *msg = (struct message *)urb->context;143 144 if (msg->done >= msg->size) {145 usb_free_urb(urb);146 kfree(msg);147 } else148 line6_send_raw_message_async_part(msg, urb);149}150 151/*152 Asynchronously send part of a raw message.153*/154static int line6_send_raw_message_async_part(struct message *msg,155 struct urb *urb)156{157 int retval;158 struct usb_line6 *line6 = msg->line6;159 int done = msg->done;160 int bytes = min(msg->size - done, line6->max_packet_size);161 162 if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) {163 usb_fill_int_urb(urb, line6->usbdev,164 usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w),165 (char *)msg->buffer + done, bytes,166 line6_async_request_sent, msg, line6->interval);167 } else {168 usb_fill_bulk_urb(urb, line6->usbdev,169 usb_sndbulkpipe(line6->usbdev, line6->properties->ep_ctrl_w),170 (char *)msg->buffer + done, bytes,171 line6_async_request_sent, msg);172 }173 174 msg->done += bytes;175 176 /* sanity checks of EP before actually submitting */177 retval = usb_urb_ep_type_check(urb);178 if (retval < 0)179 goto error;180 181 retval = usb_submit_urb(urb, GFP_ATOMIC);182 if (retval < 0)183 goto error;184 185 return 0;186 187 error:188 dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)\n",189 __func__, retval);190 usb_free_urb(urb);191 kfree(msg);192 return retval;193}194 195/*196 Asynchronously send raw message.197*/198int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer,199 int size)200{201 struct message *msg;202 struct urb *urb;203 204 /* create message: */205 msg = kzalloc(sizeof(struct message), GFP_ATOMIC);206 if (msg == NULL)207 return -ENOMEM;208 209 /* create URB: */210 urb = usb_alloc_urb(0, GFP_ATOMIC);211 212 if (urb == NULL) {213 kfree(msg);214 return -ENOMEM;215 }216 217 /* set message data: */218 msg->line6 = line6;219 msg->buffer = buffer;220 msg->size = size;221 msg->done = 0;222 223 /* start sending: */224 return line6_send_raw_message_async_part(msg, urb);225}226EXPORT_SYMBOL_GPL(line6_send_raw_message_async);227 228/*229 Send asynchronous device version request.230*/231int line6_version_request_async(struct usb_line6 *line6)232{233 char *buffer;234 int retval;235 236 buffer = kmemdup(line6_request_version,237 sizeof(line6_request_version), GFP_ATOMIC);238 if (buffer == NULL)239 return -ENOMEM;240 241 retval = line6_send_raw_message_async(line6, buffer,242 sizeof(line6_request_version));243 kfree(buffer);244 return retval;245}246EXPORT_SYMBOL_GPL(line6_version_request_async);247 248/*249 Send sysex message in pieces of wMaxPacketSize bytes.250*/251int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer,252 int size)253{254 return line6_send_raw_message(line6, buffer,255 size + SYSEX_EXTRA_SIZE) -256 SYSEX_EXTRA_SIZE;257}258EXPORT_SYMBOL_GPL(line6_send_sysex_message);259 260/*261 Allocate buffer for sysex message and prepare header.262 @param code sysex message code263 @param size number of bytes between code and sysex end264*/265char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2,266 int size)267{268 char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC);269 270 if (!buffer)271 return NULL;272 273 buffer[0] = LINE6_SYSEX_BEGIN;274 memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id));275 buffer[sizeof(line6_midi_id) + 1] = code1;276 buffer[sizeof(line6_midi_id) + 2] = code2;277 buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END;278 return buffer;279}280EXPORT_SYMBOL_GPL(line6_alloc_sysex_buffer);281 282/*283 Notification of data received from the Line 6 device.284*/285static void line6_data_received(struct urb *urb)286{287 struct usb_line6 *line6 = (struct usb_line6 *)urb->context;288 struct midi_buffer *mb = &line6->line6midi->midibuf_in;289 unsigned long flags;290 int done;291 292 if (urb->status == -ESHUTDOWN)293 return;294 295 if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) {296 spin_lock_irqsave(&line6->line6midi->lock, flags);297 done =298 line6_midibuf_write(mb, urb->transfer_buffer, urb->actual_length);299 300 if (done < urb->actual_length) {301 line6_midibuf_ignore(mb, done);302 dev_dbg(line6->ifcdev, "%d %d buffer overflow - message skipped\n",303 done, urb->actual_length);304 }305 spin_unlock_irqrestore(&line6->line6midi->lock, flags);306 307 for (;;) {308 spin_lock_irqsave(&line6->line6midi->lock, flags);309 done =310 line6_midibuf_read(mb, line6->buffer_message,311 LINE6_MIDI_MESSAGE_MAXLEN,312 LINE6_MIDIBUF_READ_RX);313 spin_unlock_irqrestore(&line6->line6midi->lock, flags);314 315 if (done <= 0)316 break;317 318 line6->message_length = done;319 line6_midi_receive(line6, line6->buffer_message, done);320 321 if (line6->process_message)322 line6->process_message(line6);323 }324 } else {325 line6->buffer_message = urb->transfer_buffer;326 line6->message_length = urb->actual_length;327 if (line6->process_message)328 line6->process_message(line6);329 line6->buffer_message = NULL;330 }331 332 line6_start_listen(line6);333}334 335#define LINE6_READ_WRITE_STATUS_DELAY 2 /* milliseconds */336#define LINE6_READ_WRITE_MAX_RETRIES 50337 338/*339 Read data from device.340*/341int line6_read_data(struct usb_line6 *line6, unsigned address, void *data,342 unsigned datalen)343{344 struct usb_device *usbdev = line6->usbdev;345 int ret;346 u8 len;347 unsigned count;348 349 if (address > 0xffff || datalen > 0xff)350 return -EINVAL;351 352 /* query the serial number: */353 ret = usb_control_msg_send(usbdev, 0, 0x67,354 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,355 (datalen << 8) | 0x21, address, NULL, 0,356 LINE6_TIMEOUT, GFP_KERNEL);357 if (ret) {358 dev_err(line6->ifcdev, "read request failed (error %d)\n", ret);359 goto exit;360 }361 362 /* Wait for data length. We'll get 0xff until length arrives. */363 for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) {364 mdelay(LINE6_READ_WRITE_STATUS_DELAY);365 366 ret = usb_control_msg_recv(usbdev, 0, 0x67,367 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,368 0x0012, 0x0000, &len, 1,369 LINE6_TIMEOUT, GFP_KERNEL);370 if (ret) {371 dev_err(line6->ifcdev,372 "receive length failed (error %d)\n", ret);373 goto exit;374 }375 376 if (len != 0xff)377 break;378 }379 380 ret = -EIO;381 if (len == 0xff) {382 dev_err(line6->ifcdev, "read failed after %d retries\n",383 count);384 goto exit;385 } else if (len != datalen) {386 /* should be equal or something went wrong */387 dev_err(line6->ifcdev,388 "length mismatch (expected %d, got %d)\n",389 (int)datalen, len);390 goto exit;391 }392 393 /* receive the result: */394 ret = usb_control_msg_recv(usbdev, 0, 0x67,395 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,396 0x0013, 0x0000, data, datalen, LINE6_TIMEOUT,397 GFP_KERNEL);398 if (ret)399 dev_err(line6->ifcdev, "read failed (error %d)\n", ret);400 401exit:402 return ret;403}404EXPORT_SYMBOL_GPL(line6_read_data);405 406/*407 Write data to device.408*/409int line6_write_data(struct usb_line6 *line6, unsigned address, void *data,410 unsigned datalen)411{412 struct usb_device *usbdev = line6->usbdev;413 int ret;414 unsigned char *status;415 int count;416 417 if (address > 0xffff || datalen > 0xffff)418 return -EINVAL;419 420 status = kmalloc(1, GFP_KERNEL);421 if (!status)422 return -ENOMEM;423 424 ret = usb_control_msg_send(usbdev, 0, 0x67,425 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,426 0x0022, address, data, datalen, LINE6_TIMEOUT,427 GFP_KERNEL);428 if (ret) {429 dev_err(line6->ifcdev,430 "write request failed (error %d)\n", ret);431 goto exit;432 }433 434 for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) {435 mdelay(LINE6_READ_WRITE_STATUS_DELAY);436 437 ret = usb_control_msg_recv(usbdev, 0, 0x67,438 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,439 0x0012, 0x0000, status, 1, LINE6_TIMEOUT,440 GFP_KERNEL);441 if (ret) {442 dev_err(line6->ifcdev,443 "receiving status failed (error %d)\n", ret);444 goto exit;445 }446 447 if (*status != 0xff)448 break;449 }450 451 if (*status == 0xff) {452 dev_err(line6->ifcdev, "write failed after %d retries\n",453 count);454 ret = -EIO;455 } else if (*status != 0) {456 dev_err(line6->ifcdev, "write failed (error %d)\n", ret);457 ret = -EIO;458 }459exit:460 kfree(status);461 return ret;462}463EXPORT_SYMBOL_GPL(line6_write_data);464 465/*466 Read Line 6 device serial number.467 (POD, TonePort, GuitarPort)468*/469int line6_read_serial_number(struct usb_line6 *line6, u32 *serial_number)470{471 return line6_read_data(line6, 0x80d0, serial_number,472 sizeof(*serial_number));473}474EXPORT_SYMBOL_GPL(line6_read_serial_number);475 476/*477 Card destructor.478*/479static void line6_destruct(struct snd_card *card)480{481 struct usb_line6 *line6 = card->private_data;482 struct usb_device *usbdev = line6->usbdev;483 484 /* Free buffer memory first. We cannot depend on the existence of private485 * data from the (podhd) module, it may be gone already during this call486 */487 kfree(line6->buffer_message);488 489 kfree(line6->buffer_listen);490 491 /* then free URBs: */492 usb_free_urb(line6->urb_listen);493 line6->urb_listen = NULL;494 495 /* decrement reference counters: */496 usb_put_dev(usbdev);497}498 499static void line6_get_usb_properties(struct usb_line6 *line6)500{501 struct usb_device *usbdev = line6->usbdev;502 const struct line6_properties *properties = line6->properties;503 int pipe;504 struct usb_host_endpoint *ep = NULL;505 506 if (properties->capabilities & LINE6_CAP_CONTROL) {507 if (properties->capabilities & LINE6_CAP_CONTROL_MIDI) {508 pipe = usb_rcvintpipe(line6->usbdev,509 line6->properties->ep_ctrl_r);510 } else {511 pipe = usb_rcvbulkpipe(line6->usbdev,512 line6->properties->ep_ctrl_r);513 }514 ep = usbdev->ep_in[usb_pipeendpoint(pipe)];515 }516 517 /* Control data transfer properties */518 if (ep) {519 line6->interval = ep->desc.bInterval;520 line6->max_packet_size = le16_to_cpu(ep->desc.wMaxPacketSize);521 } else {522 if (properties->capabilities & LINE6_CAP_CONTROL) {523 dev_err(line6->ifcdev,524 "endpoint not available, using fallback values");525 }526 line6->interval = LINE6_FALLBACK_INTERVAL;527 line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE;528 }529 530 /* Isochronous transfer properties */531 if (usbdev->speed == USB_SPEED_LOW) {532 line6->intervals_per_second = USB_LOW_INTERVALS_PER_SECOND;533 line6->iso_buffers = USB_LOW_ISO_BUFFERS;534 } else {535 line6->intervals_per_second = USB_HIGH_INTERVALS_PER_SECOND;536 line6->iso_buffers = USB_HIGH_ISO_BUFFERS;537 }538}539 540/* Enable buffering of incoming messages, flush the buffer */541static int line6_hwdep_open(struct snd_hwdep *hw, struct file *file)542{543 struct usb_line6 *line6 = hw->private_data;544 545 /* NOTE: hwdep layer provides atomicity here */546 547 line6->messages.active = 1;548 line6->messages.nonblock = file->f_flags & O_NONBLOCK ? 1 : 0;549 550 return 0;551}552 553/* Stop buffering */554static int line6_hwdep_release(struct snd_hwdep *hw, struct file *file)555{556 struct usb_line6 *line6 = hw->private_data;557 558 line6->messages.active = 0;559 560 return 0;561}562 563/* Read from circular buffer, return to user */564static long565line6_hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count,566 loff_t *offset)567{568 struct usb_line6 *line6 = hwdep->private_data;569 long rv = 0;570 unsigned int out_count;571 572 if (mutex_lock_interruptible(&line6->messages.read_lock))573 return -ERESTARTSYS;574 575 while (kfifo_len(&line6->messages.fifo) == 0) {576 mutex_unlock(&line6->messages.read_lock);577 578 if (line6->messages.nonblock)579 return -EAGAIN;580 581 rv = wait_event_interruptible(582 line6->messages.wait_queue,583 kfifo_len(&line6->messages.fifo) != 0);584 if (rv < 0)585 return rv;586 587 if (mutex_lock_interruptible(&line6->messages.read_lock))588 return -ERESTARTSYS;589 }590 591 if (kfifo_peek_len(&line6->messages.fifo) > count) {592 /* Buffer too small; allow re-read of the current item... */593 rv = -EINVAL;594 } else {595 rv = kfifo_to_user(&line6->messages.fifo, buf, count, &out_count);596 if (rv == 0)597 rv = out_count;598 }599 600 mutex_unlock(&line6->messages.read_lock);601 return rv;602}603 604/* Write directly (no buffering) to device by user*/605static long606line6_hwdep_write(struct snd_hwdep *hwdep, const char __user *data, long count,607 loff_t *offset)608{609 struct usb_line6 *line6 = hwdep->private_data;610 int rv;611 char *data_copy;612 613 if (count > line6->max_packet_size * LINE6_RAW_MESSAGES_MAXCOUNT) {614 /* This is an arbitrary limit - still better than nothing... */615 return -EINVAL;616 }617 618 data_copy = memdup_user(data, count);619 if (IS_ERR(data_copy))620 return PTR_ERR(data_copy);621 622 rv = line6_send_raw_message(line6, data_copy, count);623 624 kfree(data_copy);625 return rv;626}627 628static __poll_t629line6_hwdep_poll(struct snd_hwdep *hwdep, struct file *file, poll_table *wait)630{631 __poll_t rv;632 struct usb_line6 *line6 = hwdep->private_data;633 634 poll_wait(file, &line6->messages.wait_queue, wait);635 636 mutex_lock(&line6->messages.read_lock);637 rv = kfifo_len(&line6->messages.fifo) == 0 ? 0 : EPOLLIN | EPOLLRDNORM;638 mutex_unlock(&line6->messages.read_lock);639 640 return rv;641}642 643static const struct snd_hwdep_ops hwdep_ops = {644 .open = line6_hwdep_open,645 .release = line6_hwdep_release,646 .read = line6_hwdep_read,647 .write = line6_hwdep_write,648 .poll = line6_hwdep_poll,649};650 651/* Insert into circular buffer */652static void line6_hwdep_push_message(struct usb_line6 *line6)653{654 if (!line6->messages.active)655 return;656 657 if (kfifo_avail(&line6->messages.fifo) >= line6->message_length) {658 /* No race condition here, there's only one writer */659 kfifo_in(&line6->messages.fifo,660 line6->buffer_message, line6->message_length);661 } /* else TODO: signal overflow */662 663 wake_up_interruptible(&line6->messages.wait_queue);664}665 666static int line6_hwdep_init(struct usb_line6 *line6)667{668 int err;669 struct snd_hwdep *hwdep;670 671 /* TODO: usb_driver_claim_interface(); */672 line6->process_message = line6_hwdep_push_message;673 line6->messages.active = 0;674 init_waitqueue_head(&line6->messages.wait_queue);675 mutex_init(&line6->messages.read_lock);676 INIT_KFIFO(line6->messages.fifo);677 678 err = snd_hwdep_new(line6->card, "config", 0, &hwdep);679 if (err < 0)680 goto end;681 strcpy(hwdep->name, "config");682 hwdep->iface = SNDRV_HWDEP_IFACE_LINE6;683 hwdep->ops = hwdep_ops;684 hwdep->private_data = line6;685 hwdep->exclusive = true;686 687end:688 return err;689}690 691static int line6_init_cap_control(struct usb_line6 *line6)692{693 int ret;694 695 /* initialize USB buffers: */696 line6->buffer_listen = kzalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL);697 if (!line6->buffer_listen)698 return -ENOMEM;699 700 line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL);701 if (!line6->urb_listen)702 return -ENOMEM;703 704 if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) {705 line6->buffer_message = kzalloc(LINE6_MIDI_MESSAGE_MAXLEN, GFP_KERNEL);706 if (!line6->buffer_message)707 return -ENOMEM;708 709 ret = line6_init_midi(line6);710 if (ret < 0)711 return ret;712 } else {713 ret = line6_hwdep_init(line6);714 if (ret < 0)715 return ret;716 }717 718 ret = line6_start_listen(line6);719 if (ret < 0) {720 dev_err(line6->ifcdev, "cannot start listening: %d\n", ret);721 return ret;722 }723 724 return 0;725}726 727static void line6_startup_work(struct work_struct *work)728{729 struct usb_line6 *line6 =730 container_of(work, struct usb_line6, startup_work.work);731 732 if (line6->startup)733 line6->startup(line6);734}735 736/*737 Probe USB device.738*/739int line6_probe(struct usb_interface *interface,740 const struct usb_device_id *id,741 const char *driver_name,742 const struct line6_properties *properties,743 int (*private_init)(struct usb_line6 *, const struct usb_device_id *id),744 size_t data_size)745{746 struct usb_device *usbdev = interface_to_usbdev(interface);747 struct snd_card *card;748 struct usb_line6 *line6;749 int interface_number;750 int ret;751 752 if (WARN_ON(data_size < sizeof(*line6)))753 return -EINVAL;754 755 /* we don't handle multiple configurations */756 if (usbdev->descriptor.bNumConfigurations != 1)757 return -ENODEV;758 759 ret = snd_card_new(&interface->dev,760 SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,761 THIS_MODULE, data_size, &card);762 if (ret < 0)763 return ret;764 765 /* store basic data: */766 line6 = card->private_data;767 line6->card = card;768 line6->properties = properties;769 line6->usbdev = usbdev;770 line6->ifcdev = &interface->dev;771 INIT_DELAYED_WORK(&line6->startup_work, line6_startup_work);772 773 strcpy(card->id, properties->id);774 strcpy(card->driver, driver_name);775 strcpy(card->shortname, properties->name);776 sprintf(card->longname, "Line 6 %s at USB %s", properties->name,777 dev_name(line6->ifcdev));778 card->private_free = line6_destruct;779 780 usb_set_intfdata(interface, line6);781 782 /* increment reference counters: */783 usb_get_dev(usbdev);784 785 /* initialize device info: */786 dev_info(&interface->dev, "Line 6 %s found\n", properties->name);787 788 /* query interface number */789 interface_number = interface->cur_altsetting->desc.bInterfaceNumber;790 791 /* TODO reserves the bus bandwidth even without actual transfer */792 ret = usb_set_interface(usbdev, interface_number,793 properties->altsetting);794 if (ret < 0) {795 dev_err(&interface->dev, "set_interface failed\n");796 goto error;797 }798 799 line6_get_usb_properties(line6);800 801 if (properties->capabilities & LINE6_CAP_CONTROL) {802 ret = line6_init_cap_control(line6);803 if (ret < 0)804 goto error;805 }806 807 /* initialize device data based on device: */808 ret = private_init(line6, id);809 if (ret < 0)810 goto error;811 812 /* creation of additional special files should go here */813 814 dev_info(&interface->dev, "Line 6 %s now attached\n",815 properties->name);816 817 return 0;818 819 error:820 /* we can call disconnect callback here because no close-sync is821 * needed yet at this point822 */823 line6_disconnect(interface);824 return ret;825}826EXPORT_SYMBOL_GPL(line6_probe);827 828/*829 Line 6 device disconnected.830*/831void line6_disconnect(struct usb_interface *interface)832{833 struct usb_line6 *line6 = usb_get_intfdata(interface);834 struct usb_device *usbdev = interface_to_usbdev(interface);835 836 if (!line6)837 return;838 839 if (WARN_ON(usbdev != line6->usbdev))840 return;841 842 cancel_delayed_work_sync(&line6->startup_work);843 844 if (line6->urb_listen != NULL)845 line6_stop_listen(line6);846 847 snd_card_disconnect(line6->card);848 if (line6->line6pcm)849 line6_pcm_disconnect(line6->line6pcm);850 if (line6->disconnect)851 line6->disconnect(line6);852 853 dev_info(&interface->dev, "Line 6 %s now disconnected\n",854 line6->properties->name);855 856 /* make sure the device isn't destructed twice: */857 usb_set_intfdata(interface, NULL);858 859 snd_card_free_when_closed(line6->card);860}861EXPORT_SYMBOL_GPL(line6_disconnect);862 863#ifdef CONFIG_PM864 865/*866 Suspend Line 6 device.867*/868int line6_suspend(struct usb_interface *interface, pm_message_t message)869{870 struct usb_line6 *line6 = usb_get_intfdata(interface);871 struct snd_line6_pcm *line6pcm = line6->line6pcm;872 873 snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot);874 875 if (line6->properties->capabilities & LINE6_CAP_CONTROL)876 line6_stop_listen(line6);877 878 if (line6pcm != NULL)879 line6pcm->flags = 0;880 881 return 0;882}883EXPORT_SYMBOL_GPL(line6_suspend);884 885/*886 Resume Line 6 device.887*/888int line6_resume(struct usb_interface *interface)889{890 struct usb_line6 *line6 = usb_get_intfdata(interface);891 892 if (line6->properties->capabilities & LINE6_CAP_CONTROL)893 line6_start_listen(line6);894 895 snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0);896 return 0;897}898EXPORT_SYMBOL_GPL(line6_resume);899 900#endif /* CONFIG_PM */901 902MODULE_AUTHOR(DRIVER_AUTHOR);903MODULE_DESCRIPTION(DRIVER_DESC);904MODULE_LICENSE("GPL");905 906