driver.c 16.2 KB
Newer Older
M
Markus Grabner 已提交
1
/*
2
 * Line6 Linux USB driver - 0.9.1beta
M
Markus Grabner 已提交
3
 *
4
 * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
M
Markus Grabner 已提交
5 6 7 8 9 10 11 12 13
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License as
 *	published by the Free Software Foundation, version 2.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
T
Takashi Iwai 已提交
14
#include <linux/export.h>
15
#include <linux/slab.h>
M
Markus Grabner 已提交
16 17
#include <linux/usb.h>

18 19 20
#include <sound/core.h>
#include <sound/initval.h>

M
Markus Grabner 已提交
21
#include "capture.h"
22
#include "driver.h"
M
Markus Grabner 已提交
23 24 25 26 27 28 29 30 31 32 33
#include "midi.h"
#include "playback.h"
#include "revision.h"
#include "usbdefs.h"

#define DRIVER_AUTHOR  "Markus Grabner <grabner@icg.tugraz.at>"
#define DRIVER_DESC    "Line6 USB Driver"

/*
	This is Line6's MIDI manufacturer ID.
*/
34 35 36
const unsigned char line6_midi_id[] = {
	0x00, 0x01, 0x0c
};
T
Takashi Iwai 已提交
37
EXPORT_SYMBOL_GPL(line6_midi_id);
38 39 40 41 42

/*
	Code to request version of POD, Variax interface
	(and maybe other devices).
*/
43
static const char line6_request_version[] = {
44 45 46
	0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7
};

M
Markus Grabner 已提交
47 48 49
/**
	 Class for asynchronous messages.
*/
50
struct message {
M
Markus Grabner 已提交
51 52 53 54 55 56 57 58 59
	struct usb_line6 *line6;
	const char *buffer;
	int size;
	int done;
};

/*
	Forward declarations.
*/
60
static void line6_data_received(struct urb *urb);
61 62
static int line6_send_raw_message_async_part(struct message *msg,
					     struct urb *urb);
M
Markus Grabner 已提交
63 64 65 66 67 68

/*
	Start to listen on endpoint.
*/
static int line6_start_listen(struct usb_line6 *line6)
{
69
	int err;
70

71
	usb_fill_int_urb(line6->urb_listen, line6->usbdev,
72 73 74
		usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r),
		line6->buffer_listen, LINE6_BUFSIZE_LISTEN,
		line6_data_received, line6, line6->interval);
M
Markus Grabner 已提交
75
	line6->urb_listen->actual_length = 0;
76
	err = usb_submit_urb(line6->urb_listen, GFP_ATOMIC);
77 78 79 80 81 82 83 84 85
	return err;
}

/*
	Stop listening on endpoint.
*/
static void line6_stop_listen(struct usb_line6 *line6)
{
	usb_kill_urb(line6->urb_listen);
M
Markus Grabner 已提交
86 87 88
}

/*
89
	Send raw message in pieces of wMaxPacketSize bytes.
M
Markus Grabner 已提交
90
*/
91 92
int line6_send_raw_message(struct usb_line6 *line6, const char *buffer,
			   int size)
M
Markus Grabner 已提交
93 94 95
{
	int i, done = 0;

96 97
	for (i = 0; i < size; i += line6->max_packet_size) {
		int partial;
M
Markus Grabner 已提交
98 99
		const char *frag_buf = buffer + i;
		int frag_size = min(line6->max_packet_size, size - i);
100 101 102
		int retval;

		retval = usb_interrupt_msg(line6->usbdev,
D
Davide Berardi 已提交
103
					usb_sndintpipe(line6->usbdev,
104
						line6->properties->ep_ctrl_w),
D
Davide Berardi 已提交
105 106
					(char *)frag_buf, frag_size,
					&partial, LINE6_TIMEOUT * HZ);
M
Markus Grabner 已提交
107

108 109 110
		if (retval) {
			dev_err(line6->ifcdev,
				"usb_interrupt_msg failed (%d)\n", retval);
M
Markus Grabner 已提交
111 112 113
			break;
		}

114
		done += frag_size;
M
Markus Grabner 已提交
115 116 117 118 119 120 121 122
	}

	return done;
}

/*
	Notification of completion of asynchronous request transmission.
*/
123
static void line6_async_request_sent(struct urb *urb)
M
Markus Grabner 已提交
124 125 126
{
	struct message *msg = (struct message *)urb->context;

127
	if (msg->done >= msg->size) {
M
Markus Grabner 已提交
128 129
		usb_free_urb(urb);
		kfree(msg);
130
	} else
M
Markus Grabner 已提交
131 132 133 134 135 136
		line6_send_raw_message_async_part(msg, urb);
}

/*
	Asynchronously send part of a raw message.
*/
137 138
static int line6_send_raw_message_async_part(struct message *msg,
					     struct urb *urb)
M
Markus Grabner 已提交
139 140 141 142 143 144
{
	int retval;
	struct usb_line6 *line6 = msg->line6;
	int done = msg->done;
	int bytes = min(msg->size - done, line6->max_packet_size);

145
	usb_fill_int_urb(urb, line6->usbdev,
146 147 148
		usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w),
		(char *)msg->buffer + done, bytes,
		line6_async_request_sent, msg, line6->interval);
M
Markus Grabner 已提交
149 150 151 152

	msg->done += bytes;
	retval = usb_submit_urb(urb, GFP_ATOMIC);

153 154 155
	if (retval < 0) {
		dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)\n",
			__func__, retval);
M
Markus Grabner 已提交
156 157
		usb_free_urb(urb);
		kfree(msg);
158
		return retval;
M
Markus Grabner 已提交
159 160 161 162 163
	}

	return 0;
}

164 165 166 167
/*
	Setup and start timer.
*/
void line6_start_timer(struct timer_list *timer, unsigned int msecs,
168
		       void (*function)(unsigned long), unsigned long data)
169 170
{
	setup_timer(timer, function, data);
171
	mod_timer(timer, jiffies + msecs * HZ / 1000);
172
}
T
Takashi Iwai 已提交
173
EXPORT_SYMBOL_GPL(line6_start_timer);
174

M
Markus Grabner 已提交
175 176 177
/*
	Asynchronously send raw message.
*/
178 179
int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer,
				 int size)
M
Markus Grabner 已提交
180 181 182 183 184 185
{
	struct message *msg;
	struct urb *urb;

	/* create message: */
	msg = kmalloc(sizeof(struct message), GFP_ATOMIC);
186
	if (msg == NULL)
M
Markus Grabner 已提交
187 188 189 190 191
		return -ENOMEM;

	/* create URB: */
	urb = usb_alloc_urb(0, GFP_ATOMIC);

192
	if (urb == NULL) {
M
Markus Grabner 已提交
193 194 195 196 197 198 199 200 201 202 203 204 205
		kfree(msg);
		return -ENOMEM;
	}

	/* set message data: */
	msg->line6 = line6;
	msg->buffer = buffer;
	msg->size = size;
	msg->done = 0;

	/* start sending: */
	return line6_send_raw_message_async_part(msg, urb);
}
T
Takashi Iwai 已提交
206
EXPORT_SYMBOL_GPL(line6_send_raw_message_async);
M
Markus Grabner 已提交
207

208 209 210 211 212
/*
	Send asynchronous device version request.
*/
int line6_version_request_async(struct usb_line6 *line6)
{
213 214 215
	char *buffer;
	int retval;

216 217
	buffer = kmemdup(line6_request_version,
			sizeof(line6_request_version), GFP_ATOMIC);
218
	if (buffer == NULL)
219 220 221 222 223 224
		return -ENOMEM;

	retval = line6_send_raw_message_async(line6, buffer,
					      sizeof(line6_request_version));
	kfree(buffer);
	return retval;
225
}
T
Takashi Iwai 已提交
226
EXPORT_SYMBOL_GPL(line6_version_request_async);
227

M
Markus Grabner 已提交
228 229 230
/*
	Send sysex message in pieces of wMaxPacketSize bytes.
*/
231 232
int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer,
			     int size)
M
Markus Grabner 已提交
233
{
234 235 236
	return line6_send_raw_message(line6, buffer,
				      size + SYSEX_EXTRA_SIZE) -
	    SYSEX_EXTRA_SIZE;
M
Markus Grabner 已提交
237
}
T
Takashi Iwai 已提交
238
EXPORT_SYMBOL_GPL(line6_send_sysex_message);
M
Markus Grabner 已提交
239 240 241 242 243 244

/*
	Allocate buffer for sysex message and prepare header.
	@param code sysex message code
	@param size number of bytes between code and sysex end
*/
245 246
char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2,
			       int size)
M
Markus Grabner 已提交
247
{
248
	char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC);
M
Markus Grabner 已提交
249

250
	if (!buffer)
251
		return NULL;
M
Markus Grabner 已提交
252 253 254 255 256 257 258 259

	buffer[0] = LINE6_SYSEX_BEGIN;
	memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id));
	buffer[sizeof(line6_midi_id) + 1] = code1;
	buffer[sizeof(line6_midi_id) + 2] = code2;
	buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END;
	return buffer;
}
T
Takashi Iwai 已提交
260
EXPORT_SYMBOL_GPL(line6_alloc_sysex_buffer);
M
Markus Grabner 已提交
261 262 263 264

/*
	Notification of data received from the Line6 device.
*/
265
static void line6_data_received(struct urb *urb)
M
Markus Grabner 已提交
266 267
{
	struct usb_line6 *line6 = (struct usb_line6 *)urb->context;
268
	struct midi_buffer *mb = &line6->line6midi->midibuf_in;
M
Markus Grabner 已提交
269 270
	int done;

271
	if (urb->status == -ESHUTDOWN)
M
Markus Grabner 已提交
272 273
		return;

274 275
	done =
	    line6_midibuf_write(mb, urb->transfer_buffer, urb->actual_length);
M
Markus Grabner 已提交
276

277
	if (done < urb->actual_length) {
278
		line6_midibuf_ignore(mb, done);
279 280
		dev_dbg(line6->ifcdev, "%d %d buffer overflow - message skipped\n",
			done, urb->actual_length);
M
Markus Grabner 已提交
281 282
	}

283
	for (;;) {
284 285 286
		done =
		    line6_midibuf_read(mb, line6->buffer_message,
				       LINE6_MESSAGE_MAXLEN);
M
Markus Grabner 已提交
287

288
		if (done == 0)
M
Markus Grabner 已提交
289 290 291 292 293
			break;

		line6->message_length = done;
		line6_midi_receive(line6, line6->buffer_message, done);

294 295
		if (line6->process_message)
			line6->process_message(line6);
M
Markus Grabner 已提交
296 297 298 299 300 301 302 303
	}

	line6_start_listen(line6);
}

/*
	Send channel number (i.e., switch to a different sound).
*/
304
int line6_send_program(struct usb_line6 *line6, u8 value)
M
Markus Grabner 已提交
305
{
306
	int retval;
M
Markus Grabner 已提交
307
	unsigned char *buffer;
308 309 310
	int partial;

	buffer = kmalloc(2, GFP_KERNEL);
311
	if (!buffer)
M
Markus Grabner 已提交
312 313 314 315 316
		return -ENOMEM;

	buffer[0] = LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST;
	buffer[1] = value;

317 318
	retval = usb_interrupt_msg(line6->usbdev,
				   usb_sndintpipe(line6->usbdev,
319
						  line6->properties->ep_ctrl_w),
320 321 322
				   buffer, 2, &partial, LINE6_TIMEOUT * HZ);

	if (retval)
323 324
		dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n",
			retval);
325 326 327

	kfree(buffer);
	return retval;
M
Markus Grabner 已提交
328 329 330 331 332
}

/*
	Transmit Line6 control parameter.
*/
333
int line6_transmit_parameter(struct usb_line6 *line6, int param, u8 value)
M
Markus Grabner 已提交
334
{
335
	int retval;
M
Markus Grabner 已提交
336
	unsigned char *buffer;
337 338 339
	int partial;

	buffer = kmalloc(3, GFP_KERNEL);
340
	if (!buffer)
M
Markus Grabner 已提交
341 342 343 344 345 346
		return -ENOMEM;

	buffer[0] = LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST;
	buffer[1] = param;
	buffer[2] = value;

347
	retval = usb_interrupt_msg(line6->usbdev,
348
				   usb_sndintpipe(line6->usbdev,
349
						  line6->properties->ep_ctrl_w),
350 351 352
				   buffer, 3, &partial, LINE6_TIMEOUT * HZ);

	if (retval)
353 354
		dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)\n",
			retval);
355 356 357

	kfree(buffer);
	return retval;
M
Markus Grabner 已提交
358 359 360 361 362
}

/*
	Read data from device.
*/
363 364
int line6_read_data(struct usb_line6 *line6, int address, void *data,
		    size_t datalen)
M
Markus Grabner 已提交
365 366 367 368 369 370 371
{
	struct usb_device *usbdev = line6->usbdev;
	int ret;
	unsigned char len;

	/* query the serial number: */
	ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
372 373 374
			      USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
			      (datalen << 8) | 0x21, address,
			      NULL, 0, LINE6_TIMEOUT * HZ);
M
Markus Grabner 已提交
375

376
	if (ret < 0) {
M
Markus Grabner 已提交
377 378 379 380
		dev_err(line6->ifcdev, "read request failed (error %d)\n", ret);
		return ret;
	}

381
	/* Wait for data length. We'll get 0xff until length arrives. */
M
Markus Grabner 已提交
382 383
	do {
		ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
384 385 386 387 388 389 390
				      USB_TYPE_VENDOR | USB_RECIP_DEVICE |
				      USB_DIR_IN,
				      0x0012, 0x0000, &len, 1,
				      LINE6_TIMEOUT * HZ);
		if (ret < 0) {
			dev_err(line6->ifcdev,
				"receive length failed (error %d)\n", ret);
M
Markus Grabner 已提交
391 392
			return ret;
		}
393
	} while (len == 0xff);
394 395 396 397 398 399

	if (len != datalen) {
		/* should be equal or something went wrong */
		dev_err(line6->ifcdev,
			"length mismatch (expected %d, got %d)\n",
			(int)datalen, (int)len);
M
Markus Grabner 已提交
400 401 402 403 404
		return -EINVAL;
	}

	/* receive the result: */
	ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
405 406 407
			      USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
			      0x0013, 0x0000, data, datalen,
			      LINE6_TIMEOUT * HZ);
M
Markus Grabner 已提交
408

409
	if (ret < 0) {
M
Markus Grabner 已提交
410 411 412 413 414 415
		dev_err(line6->ifcdev, "read failed (error %d)\n", ret);
		return ret;
	}

	return 0;
}
T
Takashi Iwai 已提交
416
EXPORT_SYMBOL_GPL(line6_read_data);
M
Markus Grabner 已提交
417 418 419 420

/*
	Write data to device.
*/
421 422
int line6_write_data(struct usb_line6 *line6, int address, void *data,
		     size_t datalen)
M
Markus Grabner 已提交
423 424 425 426 427
{
	struct usb_device *usbdev = line6->usbdev;
	int ret;
	unsigned char status;

428 429 430 431
	ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
			      USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
			      0x0022, address, data, datalen,
			      LINE6_TIMEOUT * HZ);
M
Markus Grabner 已提交
432

433 434 435
	if (ret < 0) {
		dev_err(line6->ifcdev,
			"write request failed (error %d)\n", ret);
M
Markus Grabner 已提交
436 437 438 439
		return ret;
	}

	do {
440 441 442 443 444 445 446 447 448 449
		ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
				      0x67,
				      USB_TYPE_VENDOR | USB_RECIP_DEVICE |
				      USB_DIR_IN,
				      0x0012, 0x0000,
				      &status, 1, LINE6_TIMEOUT * HZ);

		if (ret < 0) {
			dev_err(line6->ifcdev,
				"receiving status failed (error %d)\n", ret);
M
Markus Grabner 已提交
450 451
			return ret;
		}
452
	} while (status == 0xff);
M
Markus Grabner 已提交
453

454
	if (status != 0) {
M
Markus Grabner 已提交
455 456 457 458 459 460
		dev_err(line6->ifcdev, "write failed (error %d)\n", ret);
		return -EINVAL;
	}

	return 0;
}
T
Takashi Iwai 已提交
461
EXPORT_SYMBOL_GPL(line6_write_data);
M
Markus Grabner 已提交
462 463 464 465 466 467 468

/*
	Read Line6 device serial number.
	(POD, TonePort, GuitarPort)
*/
int line6_read_serial_number(struct usb_line6 *line6, int *serial_number)
{
469 470
	return line6_read_data(line6, 0x80d0, serial_number,
			       sizeof(*serial_number));
M
Markus Grabner 已提交
471
}
T
Takashi Iwai 已提交
472
EXPORT_SYMBOL_GPL(line6_read_serial_number);
M
Markus Grabner 已提交
473 474 475 476

/*
	No operation (i.e., unsupported).
*/
477 478
ssize_t line6_nop_read(struct device *dev, struct device_attribute *attr,
		       char *buf)
M
Markus Grabner 已提交
479 480 481
{
	return 0;
}
T
Takashi Iwai 已提交
482
EXPORT_SYMBOL_GPL(line6_nop_read);
M
Markus Grabner 已提交
483 484

/*
485
	Card destructor.
M
Markus Grabner 已提交
486
*/
487
static void line6_destruct(struct snd_card *card)
M
Markus Grabner 已提交
488
{
489 490
	struct usb_line6 *line6 = card->private_data;
	struct usb_device *usbdev;
491

492
	if (!line6)
493
		return;
494
	usbdev = line6->usbdev;
M
Markus Grabner 已提交
495 496

	/* free buffer memory first: */
497 498
	kfree(line6->buffer_message);
	kfree(line6->buffer_listen);
M
Markus Grabner 已提交
499 500

	/* then free URBs: */
501
	usb_free_urb(line6->urb_listen);
M
Markus Grabner 已提交
502

503 504 505 506 507
	/* free interface data: */
	kfree(line6);

	/* decrement reference counters: */
	usb_put_dev(usbdev);
M
Markus Grabner 已提交
508 509 510 511 512
}

/*
	Probe USB device.
*/
T
Takashi Iwai 已提交
513 514 515 516
int line6_probe(struct usb_interface *interface,
		struct usb_line6 *line6,
		const struct line6_properties *properties,
		int (*private_init)(struct usb_interface *, struct usb_line6 *))
M
Markus Grabner 已提交
517
{
518
	struct usb_device *usbdev;
519
	struct snd_card *card;
520
	int interface_number;
M
Markus Grabner 已提交
521 522
	int ret;

T
Takashi Iwai 已提交
523 524 525 526
	if (!interface) {
		ret = -ENODEV;
		goto err_put;
	}
M
Markus Grabner 已提交
527
	usbdev = interface_to_usbdev(interface);
T
Takashi Iwai 已提交
528 529 530 531
	if (!usbdev) {
		ret = -ENODEV;
		goto err_put;
	}
M
Markus Grabner 已提交
532 533

	/* we don't handle multiple configurations */
534 535 536 537
	if (usbdev->descriptor.bNumConfigurations != 1) {
		ret = -ENODEV;
		goto err_put;
	}
M
Markus Grabner 已提交
538 539 540 541 542 543 544

	/* initialize device info: */
	dev_info(&interface->dev, "Line6 %s found\n", properties->name);

	/* query interface number */
	interface_number = interface->cur_altsetting->desc.bInterfaceNumber;

545 546
	ret = usb_set_interface(usbdev, interface_number,
			properties->altsetting);
547
	if (ret < 0) {
M
Markus Grabner 已提交
548
		dev_err(&interface->dev, "set_interface failed\n");
549
		goto err_put;
M
Markus Grabner 已提交
550 551 552 553 554 555 556 557 558 559
	}

	/* store basic data: */
	line6->properties = properties;
	line6->usbdev = usbdev;
	line6->ifcdev = &interface->dev;

	/* get data from endpoint descriptor (see usb_maxpacket): */
	{
		struct usb_host_endpoint *ep;
560 561
		unsigned pipe = usb_rcvintpipe(usbdev, properties->ep_ctrl_r);
		unsigned epnum = usb_pipeendpoint(pipe);
M
Markus Grabner 已提交
562 563
		ep = usbdev->ep_in[epnum];

564
		if (ep != NULL) {
M
Markus Grabner 已提交
565
			line6->interval = ep->desc.bInterval;
566 567
			line6->max_packet_size =
			    le16_to_cpu(ep->desc.wMaxPacketSize);
568
		} else {
M
Markus Grabner 已提交
569 570
			line6->interval = LINE6_FALLBACK_INTERVAL;
			line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE;
571 572
			dev_err(line6->ifcdev,
				"endpoint not available, using fallback values");
M
Markus Grabner 已提交
573 574 575
		}
	}

576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
	ret = snd_card_new(line6->ifcdev,
			   SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
			   THIS_MODULE, 0, &card);
	if (ret < 0)
		goto err_put;

	line6->card = card;
	strcpy(card->id, line6->properties->id);
	strcpy(card->driver, DRIVER_NAME);
	strcpy(card->shortname, line6->properties->name);
	sprintf(card->longname, "Line6 %s at USB %s", line6->properties->name,
		dev_name(line6->ifcdev));
	card->private_data = line6;
	card->private_free = line6_destruct;

M
Markus Grabner 已提交
591 592
	usb_set_intfdata(interface, line6);

593 594 595
	/* increment reference counters: */
	usb_get_dev(usbdev);

596
	if (properties->capabilities & LINE6_CAP_CONTROL) {
M
Markus Grabner 已提交
597
		/* initialize USB buffers: */
598 599
		line6->buffer_listen =
		    kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL);
600
		if (line6->buffer_listen == NULL) {
601 602
			ret = -ENOMEM;
			goto err_destruct;
M
Markus Grabner 已提交
603 604
		}

605 606
		line6->buffer_message =
		    kmalloc(LINE6_MESSAGE_MAXLEN, GFP_KERNEL);
607
		if (line6->buffer_message == NULL) {
608 609
			ret = -ENOMEM;
			goto err_destruct;
M
Markus Grabner 已提交
610 611 612 613
		}

		line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL);

614
		if (line6->urb_listen == NULL) {
615 616
			ret = -ENOMEM;
			goto err_destruct;
M
Markus Grabner 已提交
617 618
		}

619 620 621 622
		ret = line6_start_listen(line6);
		if (ret < 0) {
			dev_err(&interface->dev, "%s: usb_submit_urb failed\n",
				__func__);
623
			goto err_destruct;
M
Markus Grabner 已提交
624 625 626
		}
	}

627
	/* initialize device data based on device: */
T
Takashi Iwai 已提交
628
	ret = private_init(interface, line6);
629 630
	if (ret < 0)
		goto err_destruct;
M
Markus Grabner 已提交
631

632 633
	/* creation of additional special files should go here */

634 635
	dev_info(&interface->dev, "Line6 %s now attached\n",
		 line6->properties->name);
636

637 638
	return 0;

639 640 641
 err_destruct:
	snd_card_free(card);
 err_put:
M
Markus Grabner 已提交
642 643
	return ret;
}
T
Takashi Iwai 已提交
644
EXPORT_SYMBOL_GPL(line6_probe);
M
Markus Grabner 已提交
645 646 647 648

/*
	Line6 device disconnected.
*/
T
Takashi Iwai 已提交
649
void line6_disconnect(struct usb_interface *interface)
M
Markus Grabner 已提交
650 651 652
{
	struct usb_line6 *line6;
	struct usb_device *usbdev;
653
	int interface_number;
M
Markus Grabner 已提交
654

655 656
	if (interface == NULL)
		return;
M
Markus Grabner 已提交
657
	usbdev = interface_to_usbdev(interface);
658 659
	if (usbdev == NULL)
		return;
M
Markus Grabner 已提交
660 661 662

	interface_number = interface->cur_altsetting->desc.bInterfaceNumber;
	line6 = usb_get_intfdata(interface);
663 664
	if (!line6)
		return;
M
Markus Grabner 已提交
665

666 667
	if (line6->urb_listen != NULL)
		line6_stop_listen(line6);
M
Markus Grabner 已提交
668

669 670
	if (usbdev != line6->usbdev)
		dev_err(line6->ifcdev, "driver bug: inconsistent usb device\n");
M
Markus Grabner 已提交
671

672 673
	snd_card_disconnect(line6->card);
	if (line6->disconnect)
674
		line6->disconnect(interface);
M
Markus Grabner 已提交
675

676 677
	dev_info(&interface->dev, "Line6 %s now disconnected\n",
		 line6->properties->name);
M
Markus Grabner 已提交
678

679 680
	/* make sure the device isn't destructed twice: */
	usb_set_intfdata(interface, NULL);
T
Takashi Iwai 已提交
681

682
	snd_card_free_when_closed(line6->card);
683
}
T
Takashi Iwai 已提交
684
EXPORT_SYMBOL_GPL(line6_disconnect);
685 686 687 688 689 690

#ifdef CONFIG_PM

/*
	Suspend Line6 device.
*/
T
Takashi Iwai 已提交
691
int line6_suspend(struct usb_interface *interface, pm_message_t message)
692 693 694 695 696 697
{
	struct usb_line6 *line6 = usb_get_intfdata(interface);
	struct snd_line6_pcm *line6pcm = line6->line6pcm;

	snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot);

698
	if (line6->properties->capabilities & LINE6_CAP_CONTROL)
699 700 701 702 703 704 705 706 707
		line6_stop_listen(line6);

	if (line6pcm != NULL) {
		snd_pcm_suspend_all(line6pcm->pcm);
		line6pcm->flags = 0;
	}

	return 0;
}
T
Takashi Iwai 已提交
708
EXPORT_SYMBOL_GPL(line6_suspend);
709 710 711 712

/*
	Resume Line6 device.
*/
T
Takashi Iwai 已提交
713
int line6_resume(struct usb_interface *interface)
714 715 716
{
	struct usb_line6 *line6 = usb_get_intfdata(interface);

717
	if (line6->properties->capabilities & LINE6_CAP_CONTROL)
718 719 720 721 722
		line6_start_listen(line6);

	snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0);
	return 0;
}
T
Takashi Iwai 已提交
723
EXPORT_SYMBOL_GPL(line6_resume);
M
Markus Grabner 已提交
724

725
#endif /* CONFIG_PM */
726

M
Markus Grabner 已提交
727 728 729
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");