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 <sound/core.h> 14#include <sound/control.h> 15#include <sound/pcm.h> 16#include <sound/pcm_params.h> 17 18#include "audio.h" 19#include "capture.h" 20#include "driver.h" 21#include "playback.h" 22#include "pod.h" 23 24#ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 25 26static struct snd_line6_pcm *dev2pcm(struct device *dev) 27{ 28 struct usb_interface *interface = to_usb_interface(dev); 29 struct usb_line6 *line6 = usb_get_intfdata(interface); 30 struct snd_line6_pcm *line6pcm = line6->line6pcm; 31 return line6pcm; 32} 33 34/* 35 "read" request on "impulse_volume" special file. 36*/ 37static ssize_t pcm_get_impulse_volume(struct device *dev, 38 struct device_attribute *attr, char *buf) 39{ 40 return sprintf(buf, "%d\n", dev2pcm(dev)->impulse_volume); 41} 42 43/* 44 "write" request on "impulse_volume" special file. 45*/ 46static ssize_t pcm_set_impulse_volume(struct device *dev, 47 struct device_attribute *attr, 48 const char *buf, size_t count) 49{ 50 struct snd_line6_pcm *line6pcm = dev2pcm(dev); 51 int value = simple_strtoul(buf, NULL, 10); 52 line6pcm->impulse_volume = value; 53 54 if (value > 0) 55 line6_pcm_acquire(line6pcm, LINE6_BITS_PCM_IMPULSE); 56 else 57 line6_pcm_release(line6pcm, LINE6_BITS_PCM_IMPULSE); 58 59 return count; 60} 61 62/* 63 "read" request on "impulse_period" special file. 64*/ 65static ssize_t pcm_get_impulse_period(struct device *dev, 66 struct device_attribute *attr, char *buf) 67{ 68 return sprintf(buf, "%d\n", dev2pcm(dev)->impulse_period); 69} 70 71/* 72 "write" request on "impulse_period" special file. 73*/ 74static ssize_t pcm_set_impulse_period(struct device *dev, 75 struct device_attribute *attr, 76 const char *buf, size_t count) 77{ 78 dev2pcm(dev)->impulse_period = simple_strtoul(buf, NULL, 10); 79 return count; 80} 81 82static DEVICE_ATTR(impulse_volume, S_IWUSR | S_IRUGO, pcm_get_impulse_volume, 83 pcm_set_impulse_volume); 84static DEVICE_ATTR(impulse_period, S_IWUSR | S_IRUGO, pcm_get_impulse_period, 85 pcm_set_impulse_period); 86 87#endif 88 89static bool test_flags(unsigned long flags0, unsigned long flags1, 90 unsigned long mask) 91{ 92 return ((flags0 & mask) == 0) && ((flags1 & mask) != 0); 93} 94 95int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int channels) 96{ 97 unsigned long flags_old = 98 __sync_fetch_and_or(&line6pcm->flags, channels); 99 unsigned long flags_new = flags_old | channels; 100 unsigned long flags_final = flags_old; 101 int err = 0; 102 103 line6pcm->prev_fbuf = NULL; 104 105 if (test_flags(flags_old, flags_new, LINE6_BITS_CAPTURE_BUFFER)) { 106 /* We may be invoked multiple times in a row so allocate once only */ 107 if (!line6pcm->buffer_in) { 108 line6pcm->buffer_in = 109 kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS * 110 line6pcm->max_packet_size, GFP_KERNEL); 111 112 if (!line6pcm->buffer_in) { 113 dev_err(line6pcm->line6->ifcdev, 114 "cannot malloc capture buffer\n"); 115 err = -ENOMEM; 116 goto pcm_acquire_error; 117 } 118 119 flags_final |= channels & LINE6_BITS_CAPTURE_BUFFER; 120 } 121 } 122 123 if (test_flags(flags_old, flags_new, LINE6_BITS_CAPTURE_STREAM)) { 124 /* 125 Waiting for completion of active URBs in the stop handler is 126 a bug, we therefore report an error if capturing is restarted 127 too soon. 128 */ 129 if (line6pcm->active_urb_in | line6pcm->unlink_urb_in) { 130 dev_err(line6pcm->line6->ifcdev, "Device not yet ready\n"); 131 return -EBUSY; 132 } 133 134 line6pcm->count_in = 0; 135 line6pcm->prev_fsize = 0; 136 err = line6_submit_audio_in_all_urbs(line6pcm); 137 138 if (err < 0) 139 goto pcm_acquire_error; 140 141 flags_final |= channels & LINE6_BITS_CAPTURE_STREAM; 142 } 143 144 if (test_flags(flags_old, flags_new, LINE6_BITS_PLAYBACK_BUFFER)) { 145 /* We may be invoked multiple times in a row so allocate once only */ 146 if (!line6pcm->buffer_out) { 147 line6pcm->buffer_out = 148 kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS * 149 line6pcm->max_packet_size, GFP_KERNEL); 150 151 if (!line6pcm->buffer_out) { 152 dev_err(line6pcm->line6->ifcdev, 153 "cannot malloc playback buffer\n"); 154 err = -ENOMEM; 155 goto pcm_acquire_error; 156 } 157 158 flags_final |= channels & LINE6_BITS_PLAYBACK_BUFFER; 159 } 160 } 161 162 if (test_flags(flags_old, flags_new, LINE6_BITS_PLAYBACK_STREAM)) { 163 /* 164 See comment above regarding PCM restart. 165 */ 166 if (line6pcm->active_urb_out | line6pcm->unlink_urb_out) { 167 dev_err(line6pcm->line6->ifcdev, "Device not yet ready\n"); 168 return -EBUSY; 169 } 170 171 line6pcm->count_out = 0; 172 err = line6_submit_audio_out_all_urbs(line6pcm); 173 174 if (err < 0) 175 goto pcm_acquire_error; 176 177 flags_final |= channels & LINE6_BITS_PLAYBACK_STREAM; 178 } 179 180 return 0; 181 182pcm_acquire_error: 183 /* 184 If not all requested resources/streams could be obtained, release 185 those which were successfully obtained (if any). 186 */ 187 line6_pcm_release(line6pcm, flags_final & channels); 188 return err; 189} 190 191int line6_pcm_release(struct snd_line6_pcm *line6pcm, int channels) 192{ 193 unsigned long flags_old = 194 __sync_fetch_and_and(&line6pcm->flags, ~channels); 195 unsigned long flags_new = flags_old & ~channels; 196 197 if (test_flags(flags_new, flags_old, LINE6_BITS_CAPTURE_STREAM)) 198 line6_unlink_audio_in_urbs(line6pcm); 199 200 if (test_flags(flags_new, flags_old, LINE6_BITS_CAPTURE_BUFFER)) { 201 line6_wait_clear_audio_in_urbs(line6pcm); 202 line6_free_capture_buffer(line6pcm); 203 } 204 205 if (test_flags(flags_new, flags_old, LINE6_BITS_PLAYBACK_STREAM)) 206 line6_unlink_audio_out_urbs(line6pcm); 207 208 if (test_flags(flags_new, flags_old, LINE6_BITS_PLAYBACK_BUFFER)) { 209 line6_wait_clear_audio_out_urbs(line6pcm); 210 line6_free_playback_buffer(line6pcm); 211 } 212 213 return 0; 214} 215 216/* trigger callback */ 217int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd) 218{ 219 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); 220 struct snd_pcm_substream *s; 221 int err; 222 unsigned long flags; 223 224 spin_lock_irqsave(&line6pcm->lock_trigger, flags); 225 clear_bit(LINE6_INDEX_PREPARED, &line6pcm->flags); 226 227 snd_pcm_group_for_each_entry(s, substream) { 228 switch (s->stream) { 229 case SNDRV_PCM_STREAM_PLAYBACK: 230 err = snd_line6_playback_trigger(line6pcm, cmd); 231 232 if (err < 0) { 233 spin_unlock_irqrestore(&line6pcm->lock_trigger, 234 flags); 235 return err; 236 } 237 238 break; 239 240 case SNDRV_PCM_STREAM_CAPTURE: 241 err = snd_line6_capture_trigger(line6pcm, cmd); 242 243 if (err < 0) { 244 spin_unlock_irqrestore(&line6pcm->lock_trigger, 245 flags); 246 return err; 247 } 248 249 break; 250 251 default: 252 dev_err(line6pcm->line6->ifcdev, 253 "Unknown stream direction %d\n", s->stream); 254 } 255 } 256 257 spin_unlock_irqrestore(&line6pcm->lock_trigger, flags); 258 return 0; 259} 260 261/* control info callback */ 262static int snd_line6_control_playback_info(struct snd_kcontrol *kcontrol, 263 struct snd_ctl_elem_info *uinfo) 264{ 265 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 266 uinfo->count = 2; 267 uinfo->value.integer.min = 0; 268 uinfo->value.integer.max = 256; 269 return 0; 270} 271 272/* control get callback */ 273static int snd_line6_control_playback_get(struct snd_kcontrol *kcontrol, 274 struct snd_ctl_elem_value *ucontrol) 275{ 276 int i; 277 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 278 279 for (i = 2; i--;) 280 ucontrol->value.integer.value[i] = line6pcm->volume_playback[i]; 281 282 return 0; 283} 284 285/* control put callback */ 286static int snd_line6_control_playback_put(struct snd_kcontrol *kcontrol, 287 struct snd_ctl_elem_value *ucontrol) 288{ 289 int i, changed = 0; 290 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 291 292 for (i = 2; i--;) 293 if (line6pcm->volume_playback[i] != 294 ucontrol->value.integer.value[i]) { 295 line6pcm->volume_playback[i] = 296 ucontrol->value.integer.value[i]; 297 changed = 1; 298 } 299 300 return changed; 301} 302 303/* control definition */ 304static struct snd_kcontrol_new line6_control_playback = { 305 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 306 .name = "PCM Playback Volume", 307 .index = 0, 308 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 309 .info = snd_line6_control_playback_info, 310 .get = snd_line6_control_playback_get, 311 .put = snd_line6_control_playback_put 312}; 313 314/* 315 Cleanup the PCM device. 316*/ 317static void line6_cleanup_pcm(struct snd_pcm *pcm) 318{ 319 int i; 320 struct snd_line6_pcm *line6pcm = snd_pcm_chip(pcm); 321 322#ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 323 device_remove_file(line6pcm->line6->ifcdev, &dev_attr_impulse_volume); 324 device_remove_file(line6pcm->line6->ifcdev, &dev_attr_impulse_period); 325#endif 326 327 for (i = LINE6_ISO_BUFFERS; i--;) { 328 if (line6pcm->urb_audio_out[i]) { 329 usb_kill_urb(line6pcm->urb_audio_out[i]); 330 usb_free_urb(line6pcm->urb_audio_out[i]); 331 } 332 if (line6pcm->urb_audio_in[i]) { 333 usb_kill_urb(line6pcm->urb_audio_in[i]); 334 usb_free_urb(line6pcm->urb_audio_in[i]); 335 } 336 } 337} 338 339/* create a PCM device */ 340static int snd_line6_new_pcm(struct snd_line6_pcm *line6pcm) 341{ 342 struct snd_pcm *pcm; 343 int err; 344 345 err = snd_pcm_new(line6pcm->line6->card, 346 (char *)line6pcm->line6->properties->name, 347 0, 1, 1, &pcm); 348 if (err < 0) 349 return err; 350 351 pcm->private_data = line6pcm; 352 pcm->private_free = line6_cleanup_pcm; 353 line6pcm->pcm = pcm; 354 strcpy(pcm->name, line6pcm->line6->properties->name); 355 356 /* set operators */ 357 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 358 &snd_line6_playback_ops); 359 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_line6_capture_ops); 360 361 /* pre-allocation of buffers */ 362 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, 363 snd_dma_continuous_data 364 (GFP_KERNEL), 64 * 1024, 365 128 * 1024); 366 367 return 0; 368} 369 370/* PCM device destructor */ 371static int snd_line6_pcm_free(struct snd_device *device) 372{ 373 return 0; 374} 375 376/* 377 Stop substream if still running. 378*/ 379static void pcm_disconnect_substream(struct snd_pcm_substream *substream) 380{ 381 if (substream->runtime && snd_pcm_running(substream)) 382 snd_pcm_stop(substream, SNDRV_PCM_STATE_DISCONNECTED); 383} 384 385/* 386 Stop PCM stream. 387*/ 388void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm) 389{ 390 pcm_disconnect_substream(get_substream 391 (line6pcm, SNDRV_PCM_STREAM_CAPTURE)); 392 pcm_disconnect_substream(get_substream 393 (line6pcm, SNDRV_PCM_STREAM_PLAYBACK)); 394 line6_unlink_wait_clear_audio_out_urbs(line6pcm); 395 line6_unlink_wait_clear_audio_in_urbs(line6pcm); 396} 397 398/* 399 Create and register the PCM device and mixer entries. 400 Create URBs for playback and capture. 401*/ 402int line6_init_pcm(struct usb_line6 *line6, 403 struct line6_pcm_properties *properties) 404{ 405 static struct snd_device_ops pcm_ops = { 406 .dev_free = snd_line6_pcm_free, 407 }; 408 409 int err; 410 int ep_read = 0, ep_write = 0; 411 struct snd_line6_pcm *line6pcm; 412 413 if (!(line6->properties->capabilities & LINE6_BIT_PCM)) 414 return 0; /* skip PCM initialization and report success */ 415 416 /* initialize PCM subsystem based on product id: */ 417 switch (line6->product) { 418 case LINE6_DEVID_BASSPODXT: 419 case LINE6_DEVID_BASSPODXTLIVE: 420 case LINE6_DEVID_BASSPODXTPRO: 421 case LINE6_DEVID_PODXT: 422 case LINE6_DEVID_PODXTLIVE: 423 case LINE6_DEVID_PODXTPRO: 424 case LINE6_DEVID_PODHD300: 425 ep_read = 0x82; 426 ep_write = 0x01; 427 break; 428 429 case LINE6_DEVID_PODHD500: 430 case LINE6_DEVID_PODX3: 431 case LINE6_DEVID_PODX3LIVE: 432 ep_read = 0x86; 433 ep_write = 0x02; 434 break; 435 436 case LINE6_DEVID_POCKETPOD: 437 ep_read = 0x82; 438 ep_write = 0x02; 439 break; 440 441 case LINE6_DEVID_GUITARPORT: 442 case LINE6_DEVID_PODSTUDIO_GX: 443 case LINE6_DEVID_PODSTUDIO_UX1: 444 case LINE6_DEVID_PODSTUDIO_UX2: 445 case LINE6_DEVID_TONEPORT_GX: 446 case LINE6_DEVID_TONEPORT_UX1: 447 case LINE6_DEVID_TONEPORT_UX2: 448 ep_read = 0x82; 449 ep_write = 0x01; 450 break; 451 452 /* this is for interface_number == 1: 453 case LINE6_DEVID_TONEPORT_UX2: 454 case LINE6_DEVID_PODSTUDIO_UX2: 455 ep_read = 0x87; 456 ep_write = 0x00; 457 break; 458 */ 459 460 default: 461 MISSING_CASE; 462 } 463 464 line6pcm = kzalloc(sizeof(struct snd_line6_pcm), GFP_KERNEL); 465 466 if (line6pcm == NULL) 467 return -ENOMEM; 468 469 line6pcm->volume_playback[0] = line6pcm->volume_playback[1] = 255; 470 line6pcm->volume_monitor = 255; 471 line6pcm->line6 = line6; 472 line6pcm->ep_audio_read = ep_read; 473 line6pcm->ep_audio_write = ep_write; 474 475 /* Read and write buffers are sized identically, so choose minimum */ 476 line6pcm->max_packet_size = min( 477 usb_maxpacket(line6->usbdev, 478 usb_rcvisocpipe(line6->usbdev, ep_read), 0), 479 usb_maxpacket(line6->usbdev, 480 usb_sndisocpipe(line6->usbdev, ep_write), 1)); 481 482 line6pcm->properties = properties; 483 line6->line6pcm = line6pcm; 484 485 /* PCM device: */ 486 err = snd_device_new(line6->card, SNDRV_DEV_PCM, line6, &pcm_ops); 487 if (err < 0) 488 return err; 489 490 snd_card_set_dev(line6->card, line6->ifcdev); 491 492 err = snd_line6_new_pcm(line6pcm); 493 if (err < 0) 494 return err; 495 496 spin_lock_init(&line6pcm->lock_audio_out); 497 spin_lock_init(&line6pcm->lock_audio_in); 498 spin_lock_init(&line6pcm->lock_trigger); 499 500 err = line6_create_audio_out_urbs(line6pcm); 501 if (err < 0) 502 return err; 503 504 err = line6_create_audio_in_urbs(line6pcm); 505 if (err < 0) 506 return err; 507 508 /* mixer: */ 509 err = 510 snd_ctl_add(line6->card, 511 snd_ctl_new1(&line6_control_playback, line6pcm)); 512 if (err < 0) 513 return err; 514 515#ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE 516 /* impulse response test: */ 517 err = device_create_file(line6->ifcdev, &dev_attr_impulse_volume); 518 if (err < 0) 519 return err; 520 521 err = device_create_file(line6->ifcdev, &dev_attr_impulse_period); 522 if (err < 0) 523 return err; 524 525 line6pcm->impulse_period = LINE6_IMPULSE_DEFAULT_PERIOD; 526#endif 527 528 return 0; 529} 530 531/* prepare pcm callback */ 532int snd_line6_prepare(struct snd_pcm_substream *substream) 533{ 534 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); 535 536 switch (substream->stream) { 537 case SNDRV_PCM_STREAM_PLAYBACK: 538 if ((line6pcm->flags & LINE6_BITS_PLAYBACK_STREAM) == 0) 539 line6_unlink_wait_clear_audio_out_urbs(line6pcm); 540 541 break; 542 543 case SNDRV_PCM_STREAM_CAPTURE: 544 if ((line6pcm->flags & LINE6_BITS_CAPTURE_STREAM) == 0) 545 line6_unlink_wait_clear_audio_in_urbs(line6pcm); 546 547 break; 548 549 default: 550 MISSING_CASE; 551 } 552 553 if (!test_and_set_bit(LINE6_INDEX_PREPARED, &line6pcm->flags)) { 554 line6pcm->count_out = 0; 555 line6pcm->pos_out = 0; 556 line6pcm->pos_out_done = 0; 557 line6pcm->bytes_out = 0; 558 line6pcm->count_in = 0; 559 line6pcm->pos_in_done = 0; 560 line6pcm->bytes_in = 0; 561 } 562 563 return 0; 564} 565