1 /* 2 * Line 6 Linux USB driver 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/export.h> 14 #include <sound/core.h> 15 #include <sound/control.h> 16 #include <sound/pcm.h> 17 #include <sound/pcm_params.h> 18 19 #include "capture.h" 20 #include "driver.h" 21 #include "playback.h" 22 23 /* impulse response volume controls */ 24 static int snd_line6_impulse_volume_info(struct snd_kcontrol *kcontrol, 25 struct snd_ctl_elem_info *uinfo) 26 { 27 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 28 uinfo->count = 1; 29 uinfo->value.integer.min = 0; 30 uinfo->value.integer.max = 255; 31 return 0; 32 } 33 34 static int snd_line6_impulse_volume_get(struct snd_kcontrol *kcontrol, 35 struct snd_ctl_elem_value *ucontrol) 36 { 37 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 38 39 ucontrol->value.integer.value[0] = line6pcm->impulse_volume; 40 return 0; 41 } 42 43 static int snd_line6_impulse_volume_put(struct snd_kcontrol *kcontrol, 44 struct snd_ctl_elem_value *ucontrol) 45 { 46 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 47 int value = ucontrol->value.integer.value[0]; 48 int err; 49 50 if (line6pcm->impulse_volume == value) 51 return 0; 52 53 line6pcm->impulse_volume = value; 54 if (value > 0) { 55 err = line6_pcm_acquire(line6pcm, LINE6_STREAM_IMPULSE); 56 if (err < 0) { 57 line6pcm->impulse_volume = 0; 58 line6_pcm_release(line6pcm, LINE6_STREAM_IMPULSE); 59 return err; 60 } 61 } else { 62 line6_pcm_release(line6pcm, LINE6_STREAM_IMPULSE); 63 } 64 return 1; 65 } 66 67 /* impulse response period controls */ 68 static int snd_line6_impulse_period_info(struct snd_kcontrol *kcontrol, 69 struct snd_ctl_elem_info *uinfo) 70 { 71 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 72 uinfo->count = 1; 73 uinfo->value.integer.min = 0; 74 uinfo->value.integer.max = 2000; 75 return 0; 76 } 77 78 static int snd_line6_impulse_period_get(struct snd_kcontrol *kcontrol, 79 struct snd_ctl_elem_value *ucontrol) 80 { 81 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 82 83 ucontrol->value.integer.value[0] = line6pcm->impulse_period; 84 return 0; 85 } 86 87 static int snd_line6_impulse_period_put(struct snd_kcontrol *kcontrol, 88 struct snd_ctl_elem_value *ucontrol) 89 { 90 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 91 int value = ucontrol->value.integer.value[0]; 92 93 if (line6pcm->impulse_period == value) 94 return 0; 95 96 line6pcm->impulse_period = value; 97 return 1; 98 } 99 100 /* 101 Unlink all currently active URBs. 102 */ 103 static void line6_unlink_audio_urbs(struct snd_line6_pcm *line6pcm, 104 struct line6_pcm_stream *pcms) 105 { 106 int i; 107 108 for (i = 0; i < LINE6_ISO_BUFFERS; i++) { 109 if (test_bit(i, &pcms->active_urbs)) { 110 if (!test_and_set_bit(i, &pcms->unlink_urbs)) 111 usb_unlink_urb(pcms->urbs[i]); 112 } 113 } 114 } 115 116 /* 117 Wait until unlinking of all currently active URBs has been finished. 118 */ 119 static void line6_wait_clear_audio_urbs(struct snd_line6_pcm *line6pcm, 120 struct line6_pcm_stream *pcms) 121 { 122 int timeout = HZ; 123 int i; 124 int alive; 125 126 do { 127 alive = 0; 128 for (i = 0; i < LINE6_ISO_BUFFERS; i++) { 129 if (test_bit(i, &pcms->active_urbs)) 130 alive++; 131 } 132 if (!alive) 133 break; 134 set_current_state(TASK_UNINTERRUPTIBLE); 135 schedule_timeout(1); 136 } while (--timeout > 0); 137 if (alive) 138 dev_err(line6pcm->line6->ifcdev, 139 "timeout: still %d active urbs..\n", alive); 140 } 141 142 static inline struct line6_pcm_stream * 143 get_stream(struct snd_line6_pcm *line6pcm, int direction) 144 { 145 return (direction == SNDRV_PCM_STREAM_PLAYBACK) ? 146 &line6pcm->out : &line6pcm->in; 147 } 148 149 /* allocate a buffer if not opened yet; 150 * call this in line6pcm.state_change mutex 151 */ 152 static int line6_buffer_acquire(struct snd_line6_pcm *line6pcm, 153 struct line6_pcm_stream *pstr, int type) 154 { 155 /* Invoked multiple times in a row so allocate once only */ 156 if (!test_and_set_bit(type, &pstr->opened) && !pstr->buffer) { 157 pstr->buffer = kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS * 158 line6pcm->max_packet_size, GFP_KERNEL); 159 if (!pstr->buffer) 160 return -ENOMEM; 161 } 162 return 0; 163 } 164 165 /* free a buffer if all streams are closed; 166 * call this in line6pcm.state_change mutex 167 */ 168 static void line6_buffer_release(struct snd_line6_pcm *line6pcm, 169 struct line6_pcm_stream *pstr, int type) 170 { 171 172 clear_bit(type, &pstr->opened); 173 if (!pstr->opened) { 174 line6_wait_clear_audio_urbs(line6pcm, pstr); 175 kfree(pstr->buffer); 176 pstr->buffer = NULL; 177 } 178 } 179 180 /* start a PCM stream */ 181 static int line6_stream_start(struct snd_line6_pcm *line6pcm, int direction, 182 int type) 183 { 184 unsigned long flags; 185 struct line6_pcm_stream *pstr = get_stream(line6pcm, direction); 186 int ret = 0; 187 188 spin_lock_irqsave(&pstr->lock, flags); 189 if (!test_and_set_bit(type, &pstr->running) && 190 !(pstr->active_urbs || pstr->unlink_urbs)) { 191 pstr->count = 0; 192 /* Submit all currently available URBs */ 193 if (direction == SNDRV_PCM_STREAM_PLAYBACK) 194 ret = line6_submit_audio_out_all_urbs(line6pcm); 195 else 196 ret = line6_submit_audio_in_all_urbs(line6pcm); 197 } 198 if (ret < 0) 199 clear_bit(type, &pstr->running); 200 spin_unlock_irqrestore(&pstr->lock, flags); 201 return ret; 202 } 203 204 /* stop a PCM stream; this doesn't sync with the unlinked URBs */ 205 static void line6_stream_stop(struct snd_line6_pcm *line6pcm, int direction, 206 int type) 207 { 208 unsigned long flags; 209 struct line6_pcm_stream *pstr = get_stream(line6pcm, direction); 210 211 spin_lock_irqsave(&pstr->lock, flags); 212 clear_bit(type, &pstr->running); 213 if (!pstr->running) { 214 line6_unlink_audio_urbs(line6pcm, pstr); 215 if (direction == SNDRV_PCM_STREAM_CAPTURE) { 216 line6pcm->prev_fbuf = NULL; 217 line6pcm->prev_fsize = 0; 218 } 219 } 220 spin_unlock_irqrestore(&pstr->lock, flags); 221 } 222 223 /* common PCM trigger callback */ 224 int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd) 225 { 226 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); 227 struct snd_pcm_substream *s; 228 int err; 229 230 clear_bit(LINE6_FLAG_PREPARED, &line6pcm->flags); 231 232 snd_pcm_group_for_each_entry(s, substream) { 233 if (s->pcm->card != substream->pcm->card) 234 continue; 235 236 switch (cmd) { 237 case SNDRV_PCM_TRIGGER_START: 238 case SNDRV_PCM_TRIGGER_RESUME: 239 err = line6_stream_start(line6pcm, s->stream, 240 LINE6_STREAM_PCM); 241 if (err < 0) 242 return err; 243 break; 244 245 case SNDRV_PCM_TRIGGER_STOP: 246 case SNDRV_PCM_TRIGGER_SUSPEND: 247 line6_stream_stop(line6pcm, s->stream, 248 LINE6_STREAM_PCM); 249 break; 250 251 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 252 if (s->stream != SNDRV_PCM_STREAM_PLAYBACK) 253 return -EINVAL; 254 set_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags); 255 break; 256 257 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 258 if (s->stream != SNDRV_PCM_STREAM_PLAYBACK) 259 return -EINVAL; 260 clear_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags); 261 break; 262 263 default: 264 return -EINVAL; 265 } 266 } 267 268 return 0; 269 } 270 271 /* common PCM pointer callback */ 272 snd_pcm_uframes_t snd_line6_pointer(struct snd_pcm_substream *substream) 273 { 274 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); 275 struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); 276 277 return pstr->pos_done; 278 } 279 280 /* Acquire and start duplex streams: 281 * type is either LINE6_STREAM_IMPULSE or LINE6_STREAM_MONITOR 282 */ 283 int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int type) 284 { 285 struct line6_pcm_stream *pstr; 286 int ret = 0, dir; 287 288 mutex_lock(&line6pcm->state_mutex); 289 for (dir = 0; dir < 2; dir++) { 290 pstr = get_stream(line6pcm, dir); 291 ret = line6_buffer_acquire(line6pcm, pstr, type); 292 if (ret < 0) 293 goto error; 294 if (!pstr->running) 295 line6_wait_clear_audio_urbs(line6pcm, pstr); 296 } 297 for (dir = 0; dir < 2; dir++) { 298 ret = line6_stream_start(line6pcm, dir, type); 299 if (ret < 0) 300 goto error; 301 } 302 error: 303 mutex_unlock(&line6pcm->state_mutex); 304 if (ret < 0) 305 line6_pcm_release(line6pcm, type); 306 return ret; 307 } 308 EXPORT_SYMBOL_GPL(line6_pcm_acquire); 309 310 /* Stop and release duplex streams */ 311 void line6_pcm_release(struct snd_line6_pcm *line6pcm, int type) 312 { 313 struct line6_pcm_stream *pstr; 314 int dir; 315 316 mutex_lock(&line6pcm->state_mutex); 317 for (dir = 0; dir < 2; dir++) 318 line6_stream_stop(line6pcm, dir, type); 319 for (dir = 0; dir < 2; dir++) { 320 pstr = get_stream(line6pcm, dir); 321 line6_buffer_release(line6pcm, pstr, type); 322 } 323 mutex_unlock(&line6pcm->state_mutex); 324 } 325 EXPORT_SYMBOL_GPL(line6_pcm_release); 326 327 /* common PCM hw_params callback */ 328 int snd_line6_hw_params(struct snd_pcm_substream *substream, 329 struct snd_pcm_hw_params *hw_params) 330 { 331 int ret; 332 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); 333 struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); 334 335 mutex_lock(&line6pcm->state_mutex); 336 ret = line6_buffer_acquire(line6pcm, pstr, LINE6_STREAM_PCM); 337 if (ret < 0) 338 goto error; 339 340 ret = snd_pcm_lib_malloc_pages(substream, 341 params_buffer_bytes(hw_params)); 342 if (ret < 0) { 343 line6_buffer_release(line6pcm, pstr, LINE6_STREAM_PCM); 344 goto error; 345 } 346 347 pstr->period = params_period_bytes(hw_params); 348 error: 349 mutex_unlock(&line6pcm->state_mutex); 350 return ret; 351 } 352 353 /* common PCM hw_free callback */ 354 int snd_line6_hw_free(struct snd_pcm_substream *substream) 355 { 356 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); 357 struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); 358 359 mutex_lock(&line6pcm->state_mutex); 360 line6_buffer_release(line6pcm, pstr, LINE6_STREAM_PCM); 361 mutex_unlock(&line6pcm->state_mutex); 362 return snd_pcm_lib_free_pages(substream); 363 } 364 365 366 /* control info callback */ 367 static int snd_line6_control_playback_info(struct snd_kcontrol *kcontrol, 368 struct snd_ctl_elem_info *uinfo) 369 { 370 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 371 uinfo->count = 2; 372 uinfo->value.integer.min = 0; 373 uinfo->value.integer.max = 256; 374 return 0; 375 } 376 377 /* control get callback */ 378 static int snd_line6_control_playback_get(struct snd_kcontrol *kcontrol, 379 struct snd_ctl_elem_value *ucontrol) 380 { 381 int i; 382 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 383 384 for (i = 0; i < 2; i++) 385 ucontrol->value.integer.value[i] = line6pcm->volume_playback[i]; 386 387 return 0; 388 } 389 390 /* control put callback */ 391 static int snd_line6_control_playback_put(struct snd_kcontrol *kcontrol, 392 struct snd_ctl_elem_value *ucontrol) 393 { 394 int i, changed = 0; 395 struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); 396 397 for (i = 0; i < 2; i++) 398 if (line6pcm->volume_playback[i] != 399 ucontrol->value.integer.value[i]) { 400 line6pcm->volume_playback[i] = 401 ucontrol->value.integer.value[i]; 402 changed = 1; 403 } 404 405 return changed; 406 } 407 408 /* control definition */ 409 static struct snd_kcontrol_new line6_controls[] = { 410 { 411 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 412 .name = "PCM Playback Volume", 413 .info = snd_line6_control_playback_info, 414 .get = snd_line6_control_playback_get, 415 .put = snd_line6_control_playback_put 416 }, 417 { 418 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 419 .name = "Impulse Response Volume", 420 .info = snd_line6_impulse_volume_info, 421 .get = snd_line6_impulse_volume_get, 422 .put = snd_line6_impulse_volume_put 423 }, 424 { 425 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 426 .name = "Impulse Response Period", 427 .info = snd_line6_impulse_period_info, 428 .get = snd_line6_impulse_period_get, 429 .put = snd_line6_impulse_period_put 430 }, 431 }; 432 433 /* 434 Cleanup the PCM device. 435 */ 436 static void cleanup_urbs(struct line6_pcm_stream *pcms) 437 { 438 int i; 439 440 for (i = 0; i < LINE6_ISO_BUFFERS; i++) { 441 if (pcms->urbs[i]) { 442 usb_kill_urb(pcms->urbs[i]); 443 usb_free_urb(pcms->urbs[i]); 444 } 445 } 446 } 447 448 static void line6_cleanup_pcm(struct snd_pcm *pcm) 449 { 450 struct snd_line6_pcm *line6pcm = snd_pcm_chip(pcm); 451 452 cleanup_urbs(&line6pcm->out); 453 cleanup_urbs(&line6pcm->in); 454 kfree(line6pcm); 455 } 456 457 /* create a PCM device */ 458 static int snd_line6_new_pcm(struct usb_line6 *line6, struct snd_pcm **pcm_ret) 459 { 460 struct snd_pcm *pcm; 461 int err; 462 463 err = snd_pcm_new(line6->card, (char *)line6->properties->name, 464 0, 1, 1, pcm_ret); 465 if (err < 0) 466 return err; 467 pcm = *pcm_ret; 468 strcpy(pcm->name, line6->properties->name); 469 470 /* set operators */ 471 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 472 &snd_line6_playback_ops); 473 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_line6_capture_ops); 474 475 /* pre-allocation of buffers */ 476 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, 477 snd_dma_continuous_data 478 (GFP_KERNEL), 64 * 1024, 479 128 * 1024); 480 return 0; 481 } 482 483 /* 484 Sync with PCM stream stops. 485 */ 486 void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm) 487 { 488 line6_unlink_audio_urbs(line6pcm, &line6pcm->out); 489 line6_unlink_audio_urbs(line6pcm, &line6pcm->in); 490 line6_wait_clear_audio_urbs(line6pcm, &line6pcm->out); 491 line6_wait_clear_audio_urbs(line6pcm, &line6pcm->in); 492 } 493 494 /* 495 Create and register the PCM device and mixer entries. 496 Create URBs for playback and capture. 497 */ 498 int line6_init_pcm(struct usb_line6 *line6, 499 struct line6_pcm_properties *properties) 500 { 501 int i, err; 502 unsigned ep_read = line6->properties->ep_audio_r; 503 unsigned ep_write = line6->properties->ep_audio_w; 504 struct snd_pcm *pcm; 505 struct snd_line6_pcm *line6pcm; 506 507 if (!(line6->properties->capabilities & LINE6_CAP_PCM)) 508 return 0; /* skip PCM initialization and report success */ 509 510 err = snd_line6_new_pcm(line6, &pcm); 511 if (err < 0) 512 return err; 513 514 line6pcm = kzalloc(sizeof(*line6pcm), GFP_KERNEL); 515 if (!line6pcm) 516 return -ENOMEM; 517 518 mutex_init(&line6pcm->state_mutex); 519 line6pcm->pcm = pcm; 520 line6pcm->properties = properties; 521 line6pcm->volume_playback[0] = line6pcm->volume_playback[1] = 255; 522 line6pcm->volume_monitor = 255; 523 line6pcm->line6 = line6; 524 525 /* Read and write buffers are sized identically, so choose minimum */ 526 line6pcm->max_packet_size = min( 527 usb_maxpacket(line6->usbdev, 528 usb_rcvisocpipe(line6->usbdev, ep_read), 0), 529 usb_maxpacket(line6->usbdev, 530 usb_sndisocpipe(line6->usbdev, ep_write), 1)); 531 532 spin_lock_init(&line6pcm->out.lock); 533 spin_lock_init(&line6pcm->in.lock); 534 line6pcm->impulse_period = LINE6_IMPULSE_DEFAULT_PERIOD; 535 536 line6->line6pcm = line6pcm; 537 538 pcm->private_data = line6pcm; 539 pcm->private_free = line6_cleanup_pcm; 540 541 err = line6_create_audio_out_urbs(line6pcm); 542 if (err < 0) 543 return err; 544 545 err = line6_create_audio_in_urbs(line6pcm); 546 if (err < 0) 547 return err; 548 549 /* mixer: */ 550 for (i = 0; i < ARRAY_SIZE(line6_controls); i++) { 551 err = snd_ctl_add(line6->card, 552 snd_ctl_new1(&line6_controls[i], line6pcm)); 553 if (err < 0) 554 return err; 555 } 556 557 return 0; 558 } 559 EXPORT_SYMBOL_GPL(line6_init_pcm); 560 561 /* prepare pcm callback */ 562 int snd_line6_prepare(struct snd_pcm_substream *substream) 563 { 564 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); 565 struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); 566 567 mutex_lock(&line6pcm->state_mutex); 568 if (!pstr->running) 569 line6_wait_clear_audio_urbs(line6pcm, pstr); 570 571 if (!test_and_set_bit(LINE6_FLAG_PREPARED, &line6pcm->flags)) { 572 line6pcm->out.count = 0; 573 line6pcm->out.pos = 0; 574 line6pcm->out.pos_done = 0; 575 line6pcm->out.bytes = 0; 576 line6pcm->in.count = 0; 577 line6pcm->in.pos_done = 0; 578 line6pcm->in.bytes = 0; 579 } 580 581 mutex_unlock(&line6pcm->state_mutex); 582 return 0; 583 } 584