1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Loopback soundcard 4 * 5 * Original code: 6 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 7 * 8 * More accurate positioning and full-duplex support: 9 * Copyright (c) Ahmet İnan <ainan at mathematik.uni-freiburg.de> 10 * 11 * Major (almost complete) rewrite: 12 * Copyright (c) by Takashi Iwai <tiwai@suse.de> 13 * 14 * A next major update in 2010 (separate timers for playback and capture): 15 * Copyright (c) Jaroslav Kysela <perex@perex.cz> 16 */ 17 18#include <linux/init.h> 19#include <linux/jiffies.h> 20#include <linux/slab.h> 21#include <linux/time.h> 22#include <linux/wait.h> 23#include <linux/module.h> 24#include <linux/platform_device.h> 25#include <sound/core.h> 26#include <sound/control.h> 27#include <sound/pcm.h> 28#include <sound/pcm_params.h> 29#include <sound/info.h> 30#include <sound/initval.h> 31#include <sound/timer.h> 32 33MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 34MODULE_DESCRIPTION("A loopback soundcard"); 35MODULE_LICENSE("GPL"); 36MODULE_SUPPORTED_DEVICE("{{ALSA,Loopback soundcard}}"); 37 38#define MAX_PCM_SUBSTREAMS 8 39 40static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 41static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 42static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0}; 43static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8}; 44static int pcm_notify[SNDRV_CARDS]; 45static char *timer_source[SNDRV_CARDS]; 46 47module_param_array(index, int, NULL, 0444); 48MODULE_PARM_DESC(index, "Index value for loopback soundcard."); 49module_param_array(id, charp, NULL, 0444); 50MODULE_PARM_DESC(id, "ID string for loopback soundcard."); 51module_param_array(enable, bool, NULL, 0444); 52MODULE_PARM_DESC(enable, "Enable this loopback soundcard."); 53module_param_array(pcm_substreams, int, NULL, 0444); 54MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-8) for loopback driver."); 55module_param_array(pcm_notify, int, NULL, 0444); 56MODULE_PARM_DESC(pcm_notify, "Break capture when PCM format/rate/channels changes."); 57module_param_array(timer_source, charp, NULL, 0444); 58MODULE_PARM_DESC(timer_source, "Sound card name or number and device/subdevice number of timer to be used. Empty string for jiffies timer [default]."); 59 60#define NO_PITCH 100000 61 62#define CABLE_VALID_PLAYBACK BIT(SNDRV_PCM_STREAM_PLAYBACK) 63#define CABLE_VALID_CAPTURE BIT(SNDRV_PCM_STREAM_CAPTURE) 64#define CABLE_VALID_BOTH (CABLE_VALID_PLAYBACK | CABLE_VALID_CAPTURE) 65 66struct loopback_cable; 67struct loopback_pcm; 68 69struct loopback_ops { 70 /* optional 71 * call in loopback->cable_lock 72 */ 73 int (*open)(struct loopback_pcm *dpcm); 74 /* required 75 * call in cable->lock 76 */ 77 int (*start)(struct loopback_pcm *dpcm); 78 /* required 79 * call in cable->lock 80 */ 81 int (*stop)(struct loopback_pcm *dpcm); 82 /* optional */ 83 int (*stop_sync)(struct loopback_pcm *dpcm); 84 /* optional */ 85 int (*close_substream)(struct loopback_pcm *dpcm); 86 /* optional 87 * call in loopback->cable_lock 88 */ 89 int (*close_cable)(struct loopback_pcm *dpcm); 90 /* optional 91 * call in cable->lock 92 */ 93 unsigned int (*pos_update)(struct loopback_cable *cable); 94 /* optional */ 95 void (*dpcm_info)(struct loopback_pcm *dpcm, 96 struct snd_info_buffer *buffer); 97}; 98 99struct loopback_cable { 100 spinlock_t lock; 101 struct loopback_pcm *streams[2]; 102 struct snd_pcm_hardware hw; 103 /* flags */ 104 unsigned int valid; 105 unsigned int running; 106 unsigned int pause; 107 /* timer specific */ 108 struct loopback_ops *ops; 109 /* If sound timer is used */ 110 struct { 111 int stream; 112 struct snd_timer_id id; 113 struct work_struct event_work; 114 struct snd_timer_instance *instance; 115 } snd_timer; 116}; 117 118struct loopback_setup { 119 unsigned int notify: 1; 120 unsigned int rate_shift; 121 snd_pcm_format_t format; 122 unsigned int rate; 123 unsigned int channels; 124 struct snd_ctl_elem_id active_id; 125 struct snd_ctl_elem_id format_id; 126 struct snd_ctl_elem_id rate_id; 127 struct snd_ctl_elem_id channels_id; 128}; 129 130struct loopback { 131 struct snd_card *card; 132 struct mutex cable_lock; 133 struct loopback_cable *cables[MAX_PCM_SUBSTREAMS][2]; 134 struct snd_pcm *pcm[2]; 135 struct loopback_setup setup[MAX_PCM_SUBSTREAMS][2]; 136 const char *timer_source; 137}; 138 139struct loopback_pcm { 140 struct loopback *loopback; 141 struct snd_pcm_substream *substream; 142 struct loopback_cable *cable; 143 unsigned int pcm_buffer_size; 144 unsigned int buf_pos; /* position in buffer */ 145 unsigned int silent_size; 146 /* PCM parameters */ 147 unsigned int pcm_period_size; 148 unsigned int pcm_bps; /* bytes per second */ 149 unsigned int pcm_salign; /* bytes per sample * channels */ 150 unsigned int pcm_rate_shift; /* rate shift value */ 151 /* flags */ 152 unsigned int period_update_pending :1; 153 /* timer stuff */ 154 unsigned int irq_pos; /* fractional IRQ position in jiffies 155 * ticks 156 */ 157 unsigned int period_size_frac; /* period size in jiffies ticks */ 158 unsigned int last_drift; 159 unsigned long last_jiffies; 160 /* If jiffies timer is used */ 161 struct timer_list timer; 162}; 163 164static struct platform_device *devices[SNDRV_CARDS]; 165 166static inline unsigned int byte_pos(struct loopback_pcm *dpcm, unsigned int x) 167{ 168 if (dpcm->pcm_rate_shift == NO_PITCH) { 169 x /= HZ; 170 } else { 171 x = div_u64(NO_PITCH * (unsigned long long)x, 172 HZ * (unsigned long long)dpcm->pcm_rate_shift); 173 } 174 return x - (x % dpcm->pcm_salign); 175} 176 177static inline unsigned int frac_pos(struct loopback_pcm *dpcm, unsigned int x) 178{ 179 if (dpcm->pcm_rate_shift == NO_PITCH) { /* no pitch */ 180 return x * HZ; 181 } else { 182 x = div_u64(dpcm->pcm_rate_shift * (unsigned long long)x * HZ, 183 NO_PITCH); 184 } 185 return x; 186} 187 188static inline struct loopback_setup *get_setup(struct loopback_pcm *dpcm) 189{ 190 int device = dpcm->substream->pstr->pcm->device; 191 192 if (dpcm->substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 193 device ^= 1; 194 return &dpcm->loopback->setup[dpcm->substream->number][device]; 195} 196 197static inline unsigned int get_notify(struct loopback_pcm *dpcm) 198{ 199 return get_setup(dpcm)->notify; 200} 201 202static inline unsigned int get_rate_shift(struct loopback_pcm *dpcm) 203{ 204 return get_setup(dpcm)->rate_shift; 205} 206 207/* call in cable->lock */ 208static int loopback_jiffies_timer_start(struct loopback_pcm *dpcm) 209{ 210 unsigned long tick; 211 unsigned int rate_shift = get_rate_shift(dpcm); 212 213 if (rate_shift != dpcm->pcm_rate_shift) { 214 dpcm->pcm_rate_shift = rate_shift; 215 dpcm->period_size_frac = frac_pos(dpcm, dpcm->pcm_period_size); 216 } 217 if (dpcm->period_size_frac <= dpcm->irq_pos) { 218 dpcm->irq_pos %= dpcm->period_size_frac; 219 dpcm->period_update_pending = 1; 220 } 221 tick = dpcm->period_size_frac - dpcm->irq_pos; 222 tick = (tick + dpcm->pcm_bps - 1) / dpcm->pcm_bps; 223 mod_timer(&dpcm->timer, jiffies + tick); 224 225 return 0; 226} 227 228/* call in cable->lock */ 229static int loopback_snd_timer_start(struct loopback_pcm *dpcm) 230{ 231 struct loopback_cable *cable = dpcm->cable; 232 int err; 233 234 /* Loopback device has to use same period as timer card. Therefore 235 * wake up for each snd_pcm_period_elapsed() call of timer card. 236 */ 237 err = snd_timer_start(cable->snd_timer.instance, 1); 238 if (err < 0) { 239 /* do not report error if trying to start but already 240 * running. For example called by opposite substream 241 * of the same cable 242 */ 243 if (err == -EBUSY) 244 return 0; 245 246 pcm_err(dpcm->substream->pcm, 247 "snd_timer_start(%d,%d,%d) failed with %d", 248 cable->snd_timer.id.card, 249 cable->snd_timer.id.device, 250 cable->snd_timer.id.subdevice, 251 err); 252 } 253 254 return err; 255} 256 257/* call in cable->lock */ 258static inline int loopback_jiffies_timer_stop(struct loopback_pcm *dpcm) 259{ 260 del_timer(&dpcm->timer); 261 dpcm->timer.expires = 0; 262 263 return 0; 264} 265 266/* call in cable->lock */ 267static int loopback_snd_timer_stop(struct loopback_pcm *dpcm) 268{ 269 struct loopback_cable *cable = dpcm->cable; 270 int err; 271 272 /* only stop if both devices (playback and capture) are not running */ 273 if (cable->running ^ cable->pause) 274 return 0; 275 276 err = snd_timer_stop(cable->snd_timer.instance); 277 if (err < 0) { 278 pcm_err(dpcm->substream->pcm, 279 "snd_timer_stop(%d,%d,%d) failed with %d", 280 cable->snd_timer.id.card, 281 cable->snd_timer.id.device, 282 cable->snd_timer.id.subdevice, 283 err); 284 } 285 286 return err; 287} 288 289static inline int loopback_jiffies_timer_stop_sync(struct loopback_pcm *dpcm) 290{ 291 del_timer_sync(&dpcm->timer); 292 293 return 0; 294} 295 296/* call in loopback->cable_lock */ 297static int loopback_snd_timer_close_cable(struct loopback_pcm *dpcm) 298{ 299 struct loopback_cable *cable = dpcm->cable; 300 301 /* snd_timer was not opened */ 302 if (!cable->snd_timer.instance) 303 return 0; 304 305 /* will only be called from free_cable() when other stream was 306 * already closed. Other stream cannot be reopened as long as 307 * loopback->cable_lock is locked. Therefore no need to lock 308 * cable->lock; 309 */ 310 snd_timer_close(cable->snd_timer.instance); 311 312 /* wait till drain work has finished if requested */ 313 cancel_work_sync(&cable->snd_timer.event_work); 314 315 snd_timer_instance_free(cable->snd_timer.instance); 316 memset(&cable->snd_timer, 0, sizeof(cable->snd_timer)); 317 318 return 0; 319} 320 321static int loopback_check_format(struct loopback_cable *cable, int stream) 322{ 323 struct snd_pcm_runtime *runtime, *cruntime; 324 struct loopback_setup *setup; 325 struct snd_card *card; 326 int check; 327 328 if (cable->valid != CABLE_VALID_BOTH) { 329 if (stream == SNDRV_PCM_STREAM_PLAYBACK) 330 goto __notify; 331 return 0; 332 } 333 runtime = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]-> 334 substream->runtime; 335 cruntime = cable->streams[SNDRV_PCM_STREAM_CAPTURE]-> 336 substream->runtime; 337 check = runtime->format != cruntime->format || 338 runtime->rate != cruntime->rate || 339 runtime->channels != cruntime->channels; 340 if (!check) 341 return 0; 342 if (stream == SNDRV_PCM_STREAM_CAPTURE) { 343 return -EIO; 344 } else { 345 snd_pcm_stop(cable->streams[SNDRV_PCM_STREAM_CAPTURE]-> 346 substream, SNDRV_PCM_STATE_DRAINING); 347 __notify: 348 runtime = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]-> 349 substream->runtime; 350 setup = get_setup(cable->streams[SNDRV_PCM_STREAM_PLAYBACK]); 351 card = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]->loopback->card; 352 if (setup->format != runtime->format) { 353 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 354 &setup->format_id); 355 setup->format = runtime->format; 356 } 357 if (setup->rate != runtime->rate) { 358 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 359 &setup->rate_id); 360 setup->rate = runtime->rate; 361 } 362 if (setup->channels != runtime->channels) { 363 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 364 &setup->channels_id); 365 setup->channels = runtime->channels; 366 } 367 } 368 return 0; 369} 370 371static void loopback_active_notify(struct loopback_pcm *dpcm) 372{ 373 snd_ctl_notify(dpcm->loopback->card, 374 SNDRV_CTL_EVENT_MASK_VALUE, 375 &get_setup(dpcm)->active_id); 376} 377 378static int loopback_trigger(struct snd_pcm_substream *substream, int cmd) 379{ 380 struct snd_pcm_runtime *runtime = substream->runtime; 381 struct loopback_pcm *dpcm = runtime->private_data; 382 struct loopback_cable *cable = dpcm->cable; 383 int err = 0, stream = 1 << substream->stream; 384 385 switch (cmd) { 386 case SNDRV_PCM_TRIGGER_START: 387 err = loopback_check_format(cable, substream->stream); 388 if (err < 0) 389 return err; 390 dpcm->last_jiffies = jiffies; 391 dpcm->pcm_rate_shift = 0; 392 dpcm->last_drift = 0; 393 spin_lock(&cable->lock); 394 cable->running |= stream; 395 cable->pause &= ~stream; 396 err = cable->ops->start(dpcm); 397 spin_unlock(&cable->lock); 398 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 399 loopback_active_notify(dpcm); 400 break; 401 case SNDRV_PCM_TRIGGER_STOP: 402 spin_lock(&cable->lock); 403 cable->running &= ~stream; 404 cable->pause &= ~stream; 405 err = cable->ops->stop(dpcm); 406 spin_unlock(&cable->lock); 407 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 408 loopback_active_notify(dpcm); 409 break; 410 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 411 case SNDRV_PCM_TRIGGER_SUSPEND: 412 spin_lock(&cable->lock); 413 cable->pause |= stream; 414 err = cable->ops->stop(dpcm); 415 spin_unlock(&cable->lock); 416 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 417 loopback_active_notify(dpcm); 418 break; 419 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 420 case SNDRV_PCM_TRIGGER_RESUME: 421 spin_lock(&cable->lock); 422 dpcm->last_jiffies = jiffies; 423 cable->pause &= ~stream; 424 err = cable->ops->start(dpcm); 425 spin_unlock(&cable->lock); 426 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 427 loopback_active_notify(dpcm); 428 break; 429 default: 430 return -EINVAL; 431 } 432 return err; 433} 434 435static void params_change(struct snd_pcm_substream *substream) 436{ 437 struct snd_pcm_runtime *runtime = substream->runtime; 438 struct loopback_pcm *dpcm = runtime->private_data; 439 struct loopback_cable *cable = dpcm->cable; 440 441 cable->hw.formats = pcm_format_to_bits(runtime->format); 442 cable->hw.rate_min = runtime->rate; 443 cable->hw.rate_max = runtime->rate; 444 cable->hw.channels_min = runtime->channels; 445 cable->hw.channels_max = runtime->channels; 446 447 if (cable->snd_timer.instance) { 448 cable->hw.period_bytes_min = 449 frames_to_bytes(runtime, runtime->period_size); 450 cable->hw.period_bytes_max = cable->hw.period_bytes_min; 451 } 452 453} 454 455static int loopback_prepare(struct snd_pcm_substream *substream) 456{ 457 struct snd_pcm_runtime *runtime = substream->runtime; 458 struct loopback_pcm *dpcm = runtime->private_data; 459 struct loopback_cable *cable = dpcm->cable; 460 int err, bps, salign; 461 462 if (cable->ops->stop_sync) { 463 err = cable->ops->stop_sync(dpcm); 464 if (err < 0) 465 return err; 466 } 467 468 salign = (snd_pcm_format_physical_width(runtime->format) * 469 runtime->channels) / 8; 470 bps = salign * runtime->rate; 471 if (bps <= 0 || salign <= 0) 472 return -EINVAL; 473 474 dpcm->buf_pos = 0; 475 dpcm->pcm_buffer_size = frames_to_bytes(runtime, runtime->buffer_size); 476 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { 477 /* clear capture buffer */ 478 dpcm->silent_size = dpcm->pcm_buffer_size; 479 snd_pcm_format_set_silence(runtime->format, runtime->dma_area, 480 runtime->buffer_size * runtime->channels); 481 } 482 483 dpcm->irq_pos = 0; 484 dpcm->period_update_pending = 0; 485 dpcm->pcm_bps = bps; 486 dpcm->pcm_salign = salign; 487 dpcm->pcm_period_size = frames_to_bytes(runtime, runtime->period_size); 488 489 mutex_lock(&dpcm->loopback->cable_lock); 490 if (!(cable->valid & ~(1 << substream->stream)) || 491 (get_setup(dpcm)->notify && 492 substream->stream == SNDRV_PCM_STREAM_PLAYBACK)) 493 params_change(substream); 494 cable->valid |= 1 << substream->stream; 495 mutex_unlock(&dpcm->loopback->cable_lock); 496 497 return 0; 498} 499 500static void clear_capture_buf(struct loopback_pcm *dpcm, unsigned int bytes) 501{ 502 struct snd_pcm_runtime *runtime = dpcm->substream->runtime; 503 char *dst = runtime->dma_area; 504 unsigned int dst_off = dpcm->buf_pos; 505 506 if (dpcm->silent_size >= dpcm->pcm_buffer_size) 507 return; 508 if (dpcm->silent_size + bytes > dpcm->pcm_buffer_size) 509 bytes = dpcm->pcm_buffer_size - dpcm->silent_size; 510 511 for (;;) { 512 unsigned int size = bytes; 513 if (dst_off + size > dpcm->pcm_buffer_size) 514 size = dpcm->pcm_buffer_size - dst_off; 515 snd_pcm_format_set_silence(runtime->format, dst + dst_off, 516 bytes_to_frames(runtime, size) * 517 runtime->channels); 518 dpcm->silent_size += size; 519 bytes -= size; 520 if (!bytes) 521 break; 522 dst_off = 0; 523 } 524} 525 526static void copy_play_buf(struct loopback_pcm *play, 527 struct loopback_pcm *capt, 528 unsigned int bytes) 529{ 530 struct snd_pcm_runtime *runtime = play->substream->runtime; 531 char *src = runtime->dma_area; 532 char *dst = capt->substream->runtime->dma_area; 533 unsigned int src_off = play->buf_pos; 534 unsigned int dst_off = capt->buf_pos; 535 unsigned int clear_bytes = 0; 536 537 /* check if playback is draining, trim the capture copy size 538 * when our pointer is at the end of playback ring buffer */ 539 if (runtime->status->state == SNDRV_PCM_STATE_DRAINING && 540 snd_pcm_playback_hw_avail(runtime) < runtime->buffer_size) { 541 snd_pcm_uframes_t appl_ptr, appl_ptr1, diff; 542 appl_ptr = appl_ptr1 = runtime->control->appl_ptr; 543 appl_ptr1 -= appl_ptr1 % runtime->buffer_size; 544 appl_ptr1 += play->buf_pos / play->pcm_salign; 545 if (appl_ptr < appl_ptr1) 546 appl_ptr1 -= runtime->buffer_size; 547 diff = (appl_ptr - appl_ptr1) * play->pcm_salign; 548 if (diff < bytes) { 549 clear_bytes = bytes - diff; 550 bytes = diff; 551 } 552 } 553 554 for (;;) { 555 unsigned int size = bytes; 556 if (src_off + size > play->pcm_buffer_size) 557 size = play->pcm_buffer_size - src_off; 558 if (dst_off + size > capt->pcm_buffer_size) 559 size = capt->pcm_buffer_size - dst_off; 560 memcpy(dst + dst_off, src + src_off, size); 561 capt->silent_size = 0; 562 bytes -= size; 563 if (!bytes) 564 break; 565 src_off = (src_off + size) % play->pcm_buffer_size; 566 dst_off = (dst_off + size) % capt->pcm_buffer_size; 567 } 568 569 if (clear_bytes > 0) { 570 clear_capture_buf(capt, clear_bytes); 571 capt->silent_size = 0; 572 } 573} 574 575static inline unsigned int bytepos_delta(struct loopback_pcm *dpcm, 576 unsigned int jiffies_delta) 577{ 578 unsigned long last_pos; 579 unsigned int delta; 580 581 last_pos = byte_pos(dpcm, dpcm->irq_pos); 582 dpcm->irq_pos += jiffies_delta * dpcm->pcm_bps; 583 delta = byte_pos(dpcm, dpcm->irq_pos) - last_pos; 584 if (delta >= dpcm->last_drift) 585 delta -= dpcm->last_drift; 586 dpcm->last_drift = 0; 587 if (dpcm->irq_pos >= dpcm->period_size_frac) { 588 dpcm->irq_pos %= dpcm->period_size_frac; 589 dpcm->period_update_pending = 1; 590 } 591 return delta; 592} 593 594static inline void bytepos_finish(struct loopback_pcm *dpcm, 595 unsigned int delta) 596{ 597 dpcm->buf_pos += delta; 598 dpcm->buf_pos %= dpcm->pcm_buffer_size; 599} 600 601/* call in cable->lock */ 602static unsigned int loopback_jiffies_timer_pos_update 603 (struct loopback_cable *cable) 604{ 605 struct loopback_pcm *dpcm_play = 606 cable->streams[SNDRV_PCM_STREAM_PLAYBACK]; 607 struct loopback_pcm *dpcm_capt = 608 cable->streams[SNDRV_PCM_STREAM_CAPTURE]; 609 unsigned long delta_play = 0, delta_capt = 0, cur_jiffies; 610 unsigned int running, count1, count2; 611 612 cur_jiffies = jiffies; 613 running = cable->running ^ cable->pause; 614 if (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) { 615 delta_play = cur_jiffies - dpcm_play->last_jiffies; 616 dpcm_play->last_jiffies += delta_play; 617 } 618 619 if (running & (1 << SNDRV_PCM_STREAM_CAPTURE)) { 620 delta_capt = cur_jiffies - dpcm_capt->last_jiffies; 621 dpcm_capt->last_jiffies += delta_capt; 622 } 623 624 if (delta_play == 0 && delta_capt == 0) 625 goto unlock; 626 627 if (delta_play > delta_capt) { 628 count1 = bytepos_delta(dpcm_play, delta_play - delta_capt); 629 bytepos_finish(dpcm_play, count1); 630 delta_play = delta_capt; 631 } else if (delta_play < delta_capt) { 632 count1 = bytepos_delta(dpcm_capt, delta_capt - delta_play); 633 clear_capture_buf(dpcm_capt, count1); 634 bytepos_finish(dpcm_capt, count1); 635 delta_capt = delta_play; 636 } 637 638 if (delta_play == 0 && delta_capt == 0) 639 goto unlock; 640 641 /* note delta_capt == delta_play at this moment */ 642 count1 = bytepos_delta(dpcm_play, delta_play); 643 count2 = bytepos_delta(dpcm_capt, delta_capt); 644 if (count1 < count2) { 645 dpcm_capt->last_drift = count2 - count1; 646 count1 = count2; 647 } else if (count1 > count2) { 648 dpcm_play->last_drift = count1 - count2; 649 } 650 copy_play_buf(dpcm_play, dpcm_capt, count1); 651 bytepos_finish(dpcm_play, count1); 652 bytepos_finish(dpcm_capt, count1); 653 unlock: 654 return running; 655} 656 657static void loopback_jiffies_timer_function(struct timer_list *t) 658{ 659 struct loopback_pcm *dpcm = from_timer(dpcm, t, timer); 660 unsigned long flags; 661 662 spin_lock_irqsave(&dpcm->cable->lock, flags); 663 if (loopback_jiffies_timer_pos_update(dpcm->cable) & 664 (1 << dpcm->substream->stream)) { 665 loopback_jiffies_timer_start(dpcm); 666 if (dpcm->period_update_pending) { 667 dpcm->period_update_pending = 0; 668 spin_unlock_irqrestore(&dpcm->cable->lock, flags); 669 /* need to unlock before calling below */ 670 snd_pcm_period_elapsed(dpcm->substream); 671 return; 672 } 673 } 674 spin_unlock_irqrestore(&dpcm->cable->lock, flags); 675} 676 677/* call in cable->lock */ 678static int loopback_snd_timer_check_resolution(struct snd_pcm_runtime *runtime, 679 unsigned long resolution) 680{ 681 if (resolution != runtime->timer_resolution) { 682 struct loopback_pcm *dpcm = runtime->private_data; 683 struct loopback_cable *cable = dpcm->cable; 684 /* Worst case estimation of possible values for resolution 685 * resolution <= (512 * 1024) frames / 8kHz in nsec 686 * resolution <= 65.536.000.000 nsec 687 * 688 * period_size <= 65.536.000.000 nsec / 1000nsec/usec * 192kHz + 689 * 500.000 690 * period_size <= 12.582.912.000.000 <64bit 691 * / 1.000.000 usec/sec 692 */ 693 snd_pcm_uframes_t period_size_usec = 694 resolution / 1000 * runtime->rate; 695 /* round to nearest sample rate */ 696 snd_pcm_uframes_t period_size = 697 (period_size_usec + 500 * 1000) / (1000 * 1000); 698 699 pcm_err(dpcm->substream->pcm, 700 "Period size (%lu frames) of loopback device is not corresponding to timer resolution (%lu nsec = %lu frames) of card timer %d,%d,%d. Use period size of %lu frames for loopback device.", 701 runtime->period_size, resolution, period_size, 702 cable->snd_timer.id.card, 703 cable->snd_timer.id.device, 704 cable->snd_timer.id.subdevice, 705 period_size); 706 return -EINVAL; 707 } 708 return 0; 709} 710 711static void loopback_snd_timer_period_elapsed(struct loopback_cable *cable, 712 int event, 713 unsigned long resolution) 714{ 715 struct loopback_pcm *dpcm_play, *dpcm_capt; 716 struct snd_pcm_substream *substream_play, *substream_capt; 717 struct snd_pcm_runtime *valid_runtime; 718 unsigned int running, elapsed_bytes; 719 unsigned long flags; 720 721 spin_lock_irqsave(&cable->lock, flags); 722 running = cable->running ^ cable->pause; 723 /* no need to do anything if no stream is running */ 724 if (!running) { 725 spin_unlock_irqrestore(&cable->lock, flags); 726 return; 727 } 728 729 dpcm_play = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]; 730 dpcm_capt = cable->streams[SNDRV_PCM_STREAM_CAPTURE]; 731 732 if (event == SNDRV_TIMER_EVENT_MSTOP) { 733 if (!dpcm_play || 734 dpcm_play->substream->runtime->status->state != 735 SNDRV_PCM_STATE_DRAINING) { 736 spin_unlock_irqrestore(&cable->lock, flags); 737 return; 738 } 739 } 740 741 substream_play = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ? 742 dpcm_play->substream : NULL; 743 substream_capt = (running & (1 << SNDRV_PCM_STREAM_CAPTURE)) ? 744 dpcm_capt->substream : NULL; 745 valid_runtime = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ? 746 dpcm_play->substream->runtime : 747 dpcm_capt->substream->runtime; 748 749 /* resolution is only valid for SNDRV_TIMER_EVENT_TICK events */ 750 if (event == SNDRV_TIMER_EVENT_TICK) { 751 /* The hardware rules guarantee that playback and capture period 752 * are the same. Therefore only one device has to be checked 753 * here. 754 */ 755 if (loopback_snd_timer_check_resolution(valid_runtime, 756 resolution) < 0) { 757 spin_unlock_irqrestore(&cable->lock, flags); 758 if (substream_play) 759 snd_pcm_stop_xrun(substream_play); 760 if (substream_capt) 761 snd_pcm_stop_xrun(substream_capt); 762 return; 763 } 764 } 765 766 elapsed_bytes = frames_to_bytes(valid_runtime, 767 valid_runtime->period_size); 768 /* The same timer interrupt is used for playback and capture device */ 769 if ((running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) && 770 (running & (1 << SNDRV_PCM_STREAM_CAPTURE))) { 771 copy_play_buf(dpcm_play, dpcm_capt, elapsed_bytes); 772 bytepos_finish(dpcm_play, elapsed_bytes); 773 bytepos_finish(dpcm_capt, elapsed_bytes); 774 } else if (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) { 775 bytepos_finish(dpcm_play, elapsed_bytes); 776 } else if (running & (1 << SNDRV_PCM_STREAM_CAPTURE)) { 777 clear_capture_buf(dpcm_capt, elapsed_bytes); 778 bytepos_finish(dpcm_capt, elapsed_bytes); 779 } 780 spin_unlock_irqrestore(&cable->lock, flags); 781 782 if (substream_play) 783 snd_pcm_period_elapsed(substream_play); 784 if (substream_capt) 785 snd_pcm_period_elapsed(substream_capt); 786} 787 788static void loopback_snd_timer_function(struct snd_timer_instance *timeri, 789 unsigned long resolution, 790 unsigned long ticks) 791{ 792 struct loopback_cable *cable = timeri->callback_data; 793 794 loopback_snd_timer_period_elapsed(cable, SNDRV_TIMER_EVENT_TICK, 795 resolution); 796} 797 798static void loopback_snd_timer_work(struct work_struct *work) 799{ 800 struct loopback_cable *cable; 801 802 cable = container_of(work, struct loopback_cable, snd_timer.event_work); 803 loopback_snd_timer_period_elapsed(cable, SNDRV_TIMER_EVENT_MSTOP, 0); 804} 805 806static void loopback_snd_timer_event(struct snd_timer_instance *timeri, 807 int event, 808 struct timespec64 *tstamp, 809 unsigned long resolution) 810{ 811 /* Do not lock cable->lock here because timer->lock is already hold. 812 * There are other functions which first lock cable->lock and than 813 * timer->lock e.g. 814 * loopback_trigger() 815 * spin_lock(&cable->lock) 816 * loopback_snd_timer_start() 817 * snd_timer_start() 818 * spin_lock(&timer->lock) 819 * Therefore when using the oposit order of locks here it could result 820 * in a deadlock. 821 */ 822 823 if (event == SNDRV_TIMER_EVENT_MSTOP) { 824 struct loopback_cable *cable = timeri->callback_data; 825 826 /* sound card of the timer was stopped. Therefore there will not 827 * be any further timer callbacks. Due to this forward audio 828 * data from here if in draining state. When still in running 829 * state the streaming will be aborted by the usual timeout. It 830 * should not be aborted here because may be the timer sound 831 * card does only a recovery and the timer is back soon. 832 * This work triggers loopback_snd_timer_work() 833 */ 834 schedule_work(&cable->snd_timer.event_work); 835 } 836} 837 838static void loopback_jiffies_timer_dpcm_info(struct loopback_pcm *dpcm, 839 struct snd_info_buffer *buffer) 840{ 841 snd_iprintf(buffer, " update_pending:\t%u\n", 842 dpcm->period_update_pending); 843 snd_iprintf(buffer, " irq_pos:\t\t%u\n", dpcm->irq_pos); 844 snd_iprintf(buffer, " period_frac:\t%u\n", dpcm->period_size_frac); 845 snd_iprintf(buffer, " last_jiffies:\t%lu (%lu)\n", 846 dpcm->last_jiffies, jiffies); 847 snd_iprintf(buffer, " timer_expires:\t%lu\n", dpcm->timer.expires); 848} 849 850static void loopback_snd_timer_dpcm_info(struct loopback_pcm *dpcm, 851 struct snd_info_buffer *buffer) 852{ 853 struct loopback_cable *cable = dpcm->cable; 854 855 snd_iprintf(buffer, " sound timer:\thw:%d,%d,%d\n", 856 cable->snd_timer.id.card, 857 cable->snd_timer.id.device, 858 cable->snd_timer.id.subdevice); 859 snd_iprintf(buffer, " timer open:\t\t%s\n", 860 (cable->snd_timer.stream == SNDRV_PCM_STREAM_CAPTURE) ? 861 "capture" : "playback"); 862} 863 864static snd_pcm_uframes_t loopback_pointer(struct snd_pcm_substream *substream) 865{ 866 struct snd_pcm_runtime *runtime = substream->runtime; 867 struct loopback_pcm *dpcm = runtime->private_data; 868 snd_pcm_uframes_t pos; 869 870 spin_lock(&dpcm->cable->lock); 871 if (dpcm->cable->ops->pos_update) 872 dpcm->cable->ops->pos_update(dpcm->cable); 873 pos = dpcm->buf_pos; 874 spin_unlock(&dpcm->cable->lock); 875 return bytes_to_frames(runtime, pos); 876} 877 878static const struct snd_pcm_hardware loopback_pcm_hardware = 879{ 880 .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP | 881 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE | 882 SNDRV_PCM_INFO_RESUME), 883 .formats = (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE | 884 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE | 885 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE | 886 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE | 887 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE), 888 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_192000, 889 .rate_min = 8000, 890 .rate_max = 192000, 891 .channels_min = 1, 892 .channels_max = 32, 893 .buffer_bytes_max = 2 * 1024 * 1024, 894 .period_bytes_min = 64, 895 /* note check overflow in frac_pos() using pcm_rate_shift before 896 changing period_bytes_max value */ 897 .period_bytes_max = 1024 * 1024, 898 .periods_min = 1, 899 .periods_max = 1024, 900 .fifo_size = 0, 901}; 902 903static void loopback_runtime_free(struct snd_pcm_runtime *runtime) 904{ 905 struct loopback_pcm *dpcm = runtime->private_data; 906 kfree(dpcm); 907} 908 909static int loopback_hw_free(struct snd_pcm_substream *substream) 910{ 911 struct snd_pcm_runtime *runtime = substream->runtime; 912 struct loopback_pcm *dpcm = runtime->private_data; 913 struct loopback_cable *cable = dpcm->cable; 914 915 mutex_lock(&dpcm->loopback->cable_lock); 916 cable->valid &= ~(1 << substream->stream); 917 mutex_unlock(&dpcm->loopback->cable_lock); 918 return 0; 919} 920 921static unsigned int get_cable_index(struct snd_pcm_substream *substream) 922{ 923 if (!substream->pcm->device) 924 return substream->stream; 925 else 926 return !substream->stream; 927} 928 929static int rule_format(struct snd_pcm_hw_params *params, 930 struct snd_pcm_hw_rule *rule) 931{ 932 struct loopback_pcm *dpcm = rule->private; 933 struct loopback_cable *cable = dpcm->cable; 934 struct snd_mask m; 935 936 snd_mask_none(&m); 937 mutex_lock(&dpcm->loopback->cable_lock); 938 m.bits[0] = (u_int32_t)cable->hw.formats; 939 m.bits[1] = (u_int32_t)(cable->hw.formats >> 32); 940 mutex_unlock(&dpcm->loopback->cable_lock); 941 return snd_mask_refine(hw_param_mask(params, rule->var), &m); 942} 943 944static int rule_rate(struct snd_pcm_hw_params *params, 945 struct snd_pcm_hw_rule *rule) 946{ 947 struct loopback_pcm *dpcm = rule->private; 948 struct loopback_cable *cable = dpcm->cable; 949 struct snd_interval t; 950 951 mutex_lock(&dpcm->loopback->cable_lock); 952 t.min = cable->hw.rate_min; 953 t.max = cable->hw.rate_max; 954 mutex_unlock(&dpcm->loopback->cable_lock); 955 t.openmin = t.openmax = 0; 956 t.integer = 0; 957 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 958} 959 960static int rule_channels(struct snd_pcm_hw_params *params, 961 struct snd_pcm_hw_rule *rule) 962{ 963 struct loopback_pcm *dpcm = rule->private; 964 struct loopback_cable *cable = dpcm->cable; 965 struct snd_interval t; 966 967 mutex_lock(&dpcm->loopback->cable_lock); 968 t.min = cable->hw.channels_min; 969 t.max = cable->hw.channels_max; 970 mutex_unlock(&dpcm->loopback->cable_lock); 971 t.openmin = t.openmax = 0; 972 t.integer = 0; 973 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 974} 975 976static int rule_period_bytes(struct snd_pcm_hw_params *params, 977 struct snd_pcm_hw_rule *rule) 978{ 979 struct loopback_pcm *dpcm = rule->private; 980 struct loopback_cable *cable = dpcm->cable; 981 struct snd_interval t; 982 983 mutex_lock(&dpcm->loopback->cable_lock); 984 t.min = cable->hw.period_bytes_min; 985 t.max = cable->hw.period_bytes_max; 986 mutex_unlock(&dpcm->loopback->cable_lock); 987 t.openmin = 0; 988 t.openmax = 0; 989 t.integer = 0; 990 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 991} 992 993static void free_cable(struct snd_pcm_substream *substream) 994{ 995 struct loopback *loopback = substream->private_data; 996 int dev = get_cable_index(substream); 997 struct loopback_cable *cable; 998 999 cable = loopback->cables[substream->number][dev]; 1000 if (!cable) 1001 return; 1002 if (cable->streams[!substream->stream]) { 1003 /* other stream is still alive */ 1004 spin_lock_irq(&cable->lock); 1005 cable->streams[substream->stream] = NULL; 1006 spin_unlock_irq(&cable->lock); 1007 } else { 1008 struct loopback_pcm *dpcm = substream->runtime->private_data; 1009 1010 if (cable->ops && cable->ops->close_cable && dpcm) 1011 cable->ops->close_cable(dpcm); 1012 /* free the cable */ 1013 loopback->cables[substream->number][dev] = NULL; 1014 kfree(cable); 1015 } 1016} 1017 1018static int loopback_jiffies_timer_open(struct loopback_pcm *dpcm) 1019{ 1020 timer_setup(&dpcm->timer, loopback_jiffies_timer_function, 0); 1021 1022 return 0; 1023} 1024 1025static struct loopback_ops loopback_jiffies_timer_ops = { 1026 .open = loopback_jiffies_timer_open, 1027 .start = loopback_jiffies_timer_start, 1028 .stop = loopback_jiffies_timer_stop, 1029 .stop_sync = loopback_jiffies_timer_stop_sync, 1030 .close_substream = loopback_jiffies_timer_stop_sync, 1031 .pos_update = loopback_jiffies_timer_pos_update, 1032 .dpcm_info = loopback_jiffies_timer_dpcm_info, 1033}; 1034 1035static int loopback_parse_timer_id(const char *str, 1036 struct snd_timer_id *tid) 1037{ 1038 /* [<pref>:](<card name>|<card idx>)[{.,}<dev idx>[{.,}<subdev idx>]] */ 1039 const char * const sep_dev = ".,"; 1040 const char * const sep_pref = ":"; 1041 const char *name = str; 1042 char *sep, save = '\0'; 1043 int card_idx = 0, dev = 0, subdev = 0; 1044 int err; 1045 1046 sep = strpbrk(str, sep_pref); 1047 if (sep) 1048 name = sep + 1; 1049 sep = strpbrk(name, sep_dev); 1050 if (sep) { 1051 save = *sep; 1052 *sep = '\0'; 1053 } 1054 err = kstrtoint(name, 0, &card_idx); 1055 if (err == -EINVAL) { 1056 /* Must be the name, not number */ 1057 for (card_idx = 0; card_idx < snd_ecards_limit; card_idx++) { 1058 struct snd_card *card = snd_card_ref(card_idx); 1059 1060 if (card) { 1061 if (!strcmp(card->id, name)) 1062 err = 0; 1063 snd_card_unref(card); 1064 } 1065 if (!err) 1066 break; 1067 } 1068 } 1069 if (sep) { 1070 *sep = save; 1071 if (!err) { 1072 char *sep2, save2 = '\0'; 1073 1074 sep2 = strpbrk(sep + 1, sep_dev); 1075 if (sep2) { 1076 save2 = *sep2; 1077 *sep2 = '\0'; 1078 } 1079 err = kstrtoint(sep + 1, 0, &dev); 1080 if (sep2) { 1081 *sep2 = save2; 1082 if (!err) 1083 err = kstrtoint(sep2 + 1, 0, &subdev); 1084 } 1085 } 1086 } 1087 if (!err && tid) { 1088 tid->card = card_idx; 1089 tid->device = dev; 1090 tid->subdevice = subdev; 1091 } 1092 return err; 1093} 1094 1095/* call in loopback->cable_lock */ 1096static int loopback_snd_timer_open(struct loopback_pcm *dpcm) 1097{ 1098 int err = 0; 1099 struct snd_timer_id tid = { 1100 .dev_class = SNDRV_TIMER_CLASS_PCM, 1101 .dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION, 1102 }; 1103 struct snd_timer_instance *timeri; 1104 struct loopback_cable *cable = dpcm->cable; 1105 1106 /* check if timer was already opened. It is only opened once 1107 * per playback and capture subdevice (aka cable). 1108 */ 1109 if (cable->snd_timer.instance) 1110 goto exit; 1111 1112 err = loopback_parse_timer_id(dpcm->loopback->timer_source, &tid); 1113 if (err < 0) { 1114 pcm_err(dpcm->substream->pcm, 1115 "Parsing timer source \'%s\' failed with %d", 1116 dpcm->loopback->timer_source, err); 1117 goto exit; 1118 } 1119 1120 cable->snd_timer.stream = dpcm->substream->stream; 1121 cable->snd_timer.id = tid; 1122 1123 timeri = snd_timer_instance_new(dpcm->loopback->card->id); 1124 if (!timeri) { 1125 err = -ENOMEM; 1126 goto exit; 1127 } 1128 /* The callback has to be called from another work. If 1129 * SNDRV_TIMER_IFLG_FAST is specified it will be called from the 1130 * snd_pcm_period_elapsed() call of the selected sound card. 1131 * snd_pcm_period_elapsed() helds snd_pcm_stream_lock_irqsave(). 1132 * Due to our callback loopback_snd_timer_function() also calls 1133 * snd_pcm_period_elapsed() which calls snd_pcm_stream_lock_irqsave(). 1134 * This would end up in a dead lock. 1135 */ 1136 timeri->flags |= SNDRV_TIMER_IFLG_AUTO; 1137 timeri->callback = loopback_snd_timer_function; 1138 timeri->callback_data = (void *)cable; 1139 timeri->ccallback = loopback_snd_timer_event; 1140 1141 /* initialise a work used for draining */ 1142 INIT_WORK(&cable->snd_timer.event_work, loopback_snd_timer_work); 1143 1144 /* The mutex loopback->cable_lock is kept locked. 1145 * Therefore snd_timer_open() cannot be called a second time 1146 * by the other device of the same cable. 1147 * Therefore the following issue cannot happen: 1148 * [proc1] Call loopback_timer_open() -> 1149 * Unlock cable->lock for snd_timer_close/open() call 1150 * [proc2] Call loopback_timer_open() -> snd_timer_open(), 1151 * snd_timer_start() 1152 * [proc1] Call snd_timer_open() and overwrite running timer 1153 * instance 1154 */ 1155 err = snd_timer_open(timeri, &cable->snd_timer.id, current->pid); 1156 if (err < 0) { 1157 pcm_err(dpcm->substream->pcm, 1158 "snd_timer_open (%d,%d,%d) failed with %d", 1159 cable->snd_timer.id.card, 1160 cable->snd_timer.id.device, 1161 cable->snd_timer.id.subdevice, 1162 err); 1163 snd_timer_instance_free(timeri); 1164 goto exit; 1165 } 1166 1167 cable->snd_timer.instance = timeri; 1168 1169exit: 1170 return err; 1171} 1172 1173/* stop_sync() is not required for sound timer because it does not need to be 1174 * restarted in loopback_prepare() on Xrun recovery 1175 */ 1176static struct loopback_ops loopback_snd_timer_ops = { 1177 .open = loopback_snd_timer_open, 1178 .start = loopback_snd_timer_start, 1179 .stop = loopback_snd_timer_stop, 1180 .close_cable = loopback_snd_timer_close_cable, 1181 .dpcm_info = loopback_snd_timer_dpcm_info, 1182}; 1183 1184static int loopback_open(struct snd_pcm_substream *substream) 1185{ 1186 struct snd_pcm_runtime *runtime = substream->runtime; 1187 struct loopback *loopback = substream->private_data; 1188 struct loopback_pcm *dpcm; 1189 struct loopback_cable *cable = NULL; 1190 int err = 0; 1191 int dev = get_cable_index(substream); 1192 1193 mutex_lock(&loopback->cable_lock); 1194 dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL); 1195 if (!dpcm) { 1196 err = -ENOMEM; 1197 goto unlock; 1198 } 1199 dpcm->loopback = loopback; 1200 dpcm->substream = substream; 1201 1202 cable = loopback->cables[substream->number][dev]; 1203 if (!cable) { 1204 cable = kzalloc(sizeof(*cable), GFP_KERNEL); 1205 if (!cable) { 1206 err = -ENOMEM; 1207 goto unlock; 1208 } 1209 spin_lock_init(&cable->lock); 1210 cable->hw = loopback_pcm_hardware; 1211 if (loopback->timer_source) 1212 cable->ops = &loopback_snd_timer_ops; 1213 else 1214 cable->ops = &loopback_jiffies_timer_ops; 1215 loopback->cables[substream->number][dev] = cable; 1216 } 1217 dpcm->cable = cable; 1218 runtime->private_data = dpcm; 1219 1220 if (cable->ops->open) { 1221 err = cable->ops->open(dpcm); 1222 if (err < 0) 1223 goto unlock; 1224 } 1225 1226 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); 1227 1228 /* use dynamic rules based on actual runtime->hw values */ 1229 /* note that the default rules created in the PCM midlevel code */ 1230 /* are cached -> they do not reflect the actual state */ 1231 err = snd_pcm_hw_rule_add(runtime, 0, 1232 SNDRV_PCM_HW_PARAM_FORMAT, 1233 rule_format, dpcm, 1234 SNDRV_PCM_HW_PARAM_FORMAT, -1); 1235 if (err < 0) 1236 goto unlock; 1237 err = snd_pcm_hw_rule_add(runtime, 0, 1238 SNDRV_PCM_HW_PARAM_RATE, 1239 rule_rate, dpcm, 1240 SNDRV_PCM_HW_PARAM_RATE, -1); 1241 if (err < 0) 1242 goto unlock; 1243 err = snd_pcm_hw_rule_add(runtime, 0, 1244 SNDRV_PCM_HW_PARAM_CHANNELS, 1245 rule_channels, dpcm, 1246 SNDRV_PCM_HW_PARAM_CHANNELS, -1); 1247 if (err < 0) 1248 goto unlock; 1249 1250 /* In case of sound timer the period time of both devices of the same 1251 * loop has to be the same. 1252 * This rule only takes effect if a sound timer was chosen 1253 */ 1254 if (cable->snd_timer.instance) { 1255 err = snd_pcm_hw_rule_add(runtime, 0, 1256 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 1257 rule_period_bytes, dpcm, 1258 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, -1); 1259 if (err < 0) 1260 goto unlock; 1261 } 1262 1263 /* loopback_runtime_free() has not to be called if kfree(dpcm) was 1264 * already called here. Otherwise it will end up with a double free. 1265 */ 1266 runtime->private_free = loopback_runtime_free; 1267 if (get_notify(dpcm)) 1268 runtime->hw = loopback_pcm_hardware; 1269 else 1270 runtime->hw = cable->hw; 1271 1272 spin_lock_irq(&cable->lock); 1273 cable->streams[substream->stream] = dpcm; 1274 spin_unlock_irq(&cable->lock); 1275 1276 unlock: 1277 if (err < 0) { 1278 free_cable(substream); 1279 kfree(dpcm); 1280 } 1281 mutex_unlock(&loopback->cable_lock); 1282 return err; 1283} 1284 1285static int loopback_close(struct snd_pcm_substream *substream) 1286{ 1287 struct loopback *loopback = substream->private_data; 1288 struct loopback_pcm *dpcm = substream->runtime->private_data; 1289 int err = 0; 1290 1291 if (dpcm->cable->ops->close_substream) 1292 err = dpcm->cable->ops->close_substream(dpcm); 1293 mutex_lock(&loopback->cable_lock); 1294 free_cable(substream); 1295 mutex_unlock(&loopback->cable_lock); 1296 return err; 1297} 1298 1299static const struct snd_pcm_ops loopback_pcm_ops = { 1300 .open = loopback_open, 1301 .close = loopback_close, 1302 .hw_free = loopback_hw_free, 1303 .prepare = loopback_prepare, 1304 .trigger = loopback_trigger, 1305 .pointer = loopback_pointer, 1306}; 1307 1308static int loopback_pcm_new(struct loopback *loopback, 1309 int device, int substreams) 1310{ 1311 struct snd_pcm *pcm; 1312 int err; 1313 1314 err = snd_pcm_new(loopback->card, "Loopback PCM", device, 1315 substreams, substreams, &pcm); 1316 if (err < 0) 1317 return err; 1318 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &loopback_pcm_ops); 1319 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &loopback_pcm_ops); 1320 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0); 1321 1322 pcm->private_data = loopback; 1323 pcm->info_flags = 0; 1324 strcpy(pcm->name, "Loopback PCM"); 1325 1326 loopback->pcm[device] = pcm; 1327 return 0; 1328} 1329 1330static int loopback_rate_shift_info(struct snd_kcontrol *kcontrol, 1331 struct snd_ctl_elem_info *uinfo) 1332{ 1333 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1334 uinfo->count = 1; 1335 uinfo->value.integer.min = 80000; 1336 uinfo->value.integer.max = 120000; 1337 uinfo->value.integer.step = 1; 1338 return 0; 1339} 1340 1341static int loopback_rate_shift_get(struct snd_kcontrol *kcontrol, 1342 struct snd_ctl_elem_value *ucontrol) 1343{ 1344 struct loopback *loopback = snd_kcontrol_chip(kcontrol); 1345 1346 mutex_lock(&loopback->cable_lock); 1347 ucontrol->value.integer.value[0] = 1348 loopback->setup[kcontrol->id.subdevice] 1349 [kcontrol->id.device].rate_shift; 1350 mutex_unlock(&loopback->cable_lock); 1351 return 0; 1352} 1353 1354static int loopback_rate_shift_put(struct snd_kcontrol *kcontrol, 1355 struct snd_ctl_elem_value *ucontrol) 1356{ 1357 struct loopback *loopback = snd_kcontrol_chip(kcontrol); 1358 unsigned int val; 1359 int change = 0; 1360 1361 val = ucontrol->value.integer.value[0]; 1362 if (val < 80000) 1363 val = 80000; 1364 if (val > 120000) 1365 val = 120000; 1366 mutex_lock(&loopback->cable_lock); 1367 if (val != loopback->setup[kcontrol->id.subdevice] 1368 [kcontrol->id.device].rate_shift) { 1369 loopback->setup[kcontrol->id.subdevice] 1370 [kcontrol->id.device].rate_shift = val; 1371 change = 1; 1372 } 1373 mutex_unlock(&loopback->cable_lock); 1374 return change; 1375} 1376 1377static int loopback_notify_get(struct snd_kcontrol *kcontrol, 1378 struct snd_ctl_elem_value *ucontrol) 1379{ 1380 struct loopback *loopback = snd_kcontrol_chip(kcontrol); 1381 1382 mutex_lock(&loopback->cable_lock); 1383 ucontrol->value.integer.value[0] = 1384 loopback->setup[kcontrol->id.subdevice] 1385 [kcontrol->id.device].notify; 1386 mutex_unlock(&loopback->cable_lock); 1387 return 0; 1388} 1389 1390static int loopback_notify_put(struct snd_kcontrol *kcontrol, 1391 struct snd_ctl_elem_value *ucontrol) 1392{ 1393 struct loopback *loopback = snd_kcontrol_chip(kcontrol); 1394 unsigned int val; 1395 int change = 0; 1396 1397 val = ucontrol->value.integer.value[0] ? 1 : 0; 1398 mutex_lock(&loopback->cable_lock); 1399 if (val != loopback->setup[kcontrol->id.subdevice] 1400 [kcontrol->id.device].notify) { 1401 loopback->setup[kcontrol->id.subdevice] 1402 [kcontrol->id.device].notify = val; 1403 change = 1; 1404 } 1405 mutex_unlock(&loopback->cable_lock); 1406 return change; 1407} 1408 1409static int loopback_active_get(struct snd_kcontrol *kcontrol, 1410 struct snd_ctl_elem_value *ucontrol) 1411{ 1412 struct loopback *loopback = snd_kcontrol_chip(kcontrol); 1413 struct loopback_cable *cable; 1414 1415 unsigned int val = 0; 1416 1417 mutex_lock(&loopback->cable_lock); 1418 cable = loopback->cables[kcontrol->id.subdevice][kcontrol->id.device ^ 1]; 1419 if (cable != NULL) { 1420 unsigned int running = cable->running ^ cable->pause; 1421 1422 val = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ? 1 : 0; 1423 } 1424 mutex_unlock(&loopback->cable_lock); 1425 ucontrol->value.integer.value[0] = val; 1426 return 0; 1427} 1428 1429static int loopback_format_info(struct snd_kcontrol *kcontrol, 1430 struct snd_ctl_elem_info *uinfo) 1431{ 1432 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1433 uinfo->count = 1; 1434 uinfo->value.integer.min = 0; 1435 uinfo->value.integer.max = (__force int)SNDRV_PCM_FORMAT_LAST; 1436 uinfo->value.integer.step = 1; 1437 return 0; 1438} 1439 1440static int loopback_format_get(struct snd_kcontrol *kcontrol, 1441 struct snd_ctl_elem_value *ucontrol) 1442{ 1443 struct loopback *loopback = snd_kcontrol_chip(kcontrol); 1444 1445 ucontrol->value.integer.value[0] = 1446 (__force int)loopback->setup[kcontrol->id.subdevice] 1447 [kcontrol->id.device].format; 1448 return 0; 1449} 1450 1451static int loopback_rate_info(struct snd_kcontrol *kcontrol, 1452 struct snd_ctl_elem_info *uinfo) 1453{ 1454 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1455 uinfo->count = 1; 1456 uinfo->value.integer.min = 0; 1457 uinfo->value.integer.max = 192000; 1458 uinfo->value.integer.step = 1; 1459 return 0; 1460} 1461 1462static int loopback_rate_get(struct snd_kcontrol *kcontrol, 1463 struct snd_ctl_elem_value *ucontrol) 1464{ 1465 struct loopback *loopback = snd_kcontrol_chip(kcontrol); 1466 1467 mutex_lock(&loopback->cable_lock); 1468 ucontrol->value.integer.value[0] = 1469 loopback->setup[kcontrol->id.subdevice] 1470 [kcontrol->id.device].rate; 1471 mutex_unlock(&loopback->cable_lock); 1472 return 0; 1473} 1474 1475static int loopback_channels_info(struct snd_kcontrol *kcontrol, 1476 struct snd_ctl_elem_info *uinfo) 1477{ 1478 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1479 uinfo->count = 1; 1480 uinfo->value.integer.min = 1; 1481 uinfo->value.integer.max = 1024; 1482 uinfo->value.integer.step = 1; 1483 return 0; 1484} 1485 1486static int loopback_channels_get(struct snd_kcontrol *kcontrol, 1487 struct snd_ctl_elem_value *ucontrol) 1488{ 1489 struct loopback *loopback = snd_kcontrol_chip(kcontrol); 1490 1491 mutex_lock(&loopback->cable_lock); 1492 ucontrol->value.integer.value[0] = 1493 loopback->setup[kcontrol->id.subdevice] 1494 [kcontrol->id.device].channels; 1495 mutex_unlock(&loopback->cable_lock); 1496 return 0; 1497} 1498 1499static const struct snd_kcontrol_new loopback_controls[] = { 1500{ 1501 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1502 .name = "PCM Rate Shift 100000", 1503 .info = loopback_rate_shift_info, 1504 .get = loopback_rate_shift_get, 1505 .put = loopback_rate_shift_put, 1506}, 1507{ 1508 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1509 .name = "PCM Notify", 1510 .info = snd_ctl_boolean_mono_info, 1511 .get = loopback_notify_get, 1512 .put = loopback_notify_put, 1513}, 1514#define ACTIVE_IDX 2 1515{ 1516 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1517 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1518 .name = "PCM Slave Active", 1519 .info = snd_ctl_boolean_mono_info, 1520 .get = loopback_active_get, 1521}, 1522#define FORMAT_IDX 3 1523{ 1524 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1525 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1526 .name = "PCM Slave Format", 1527 .info = loopback_format_info, 1528 .get = loopback_format_get 1529}, 1530#define RATE_IDX 4 1531{ 1532 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1533 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1534 .name = "PCM Slave Rate", 1535 .info = loopback_rate_info, 1536 .get = loopback_rate_get 1537}, 1538#define CHANNELS_IDX 5 1539{ 1540 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1541 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1542 .name = "PCM Slave Channels", 1543 .info = loopback_channels_info, 1544 .get = loopback_channels_get 1545} 1546}; 1547 1548static int loopback_mixer_new(struct loopback *loopback, int notify) 1549{ 1550 struct snd_card *card = loopback->card; 1551 struct snd_pcm *pcm; 1552 struct snd_kcontrol *kctl; 1553 struct loopback_setup *setup; 1554 int err, dev, substr, substr_count, idx; 1555 1556 strcpy(card->mixername, "Loopback Mixer"); 1557 for (dev = 0; dev < 2; dev++) { 1558 pcm = loopback->pcm[dev]; 1559 substr_count = 1560 pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count; 1561 for (substr = 0; substr < substr_count; substr++) { 1562 setup = &loopback->setup[substr][dev]; 1563 setup->notify = notify; 1564 setup->rate_shift = NO_PITCH; 1565 setup->format = SNDRV_PCM_FORMAT_S16_LE; 1566 setup->rate = 48000; 1567 setup->channels = 2; 1568 for (idx = 0; idx < ARRAY_SIZE(loopback_controls); 1569 idx++) { 1570 kctl = snd_ctl_new1(&loopback_controls[idx], 1571 loopback); 1572 if (!kctl) 1573 return -ENOMEM; 1574 kctl->id.device = dev; 1575 kctl->id.subdevice = substr; 1576 1577 /* Add the control before copying the id so that 1578 * the numid field of the id is set in the copy. 1579 */ 1580 err = snd_ctl_add(card, kctl); 1581 if (err < 0) 1582 return err; 1583 1584 switch (idx) { 1585 case ACTIVE_IDX: 1586 setup->active_id = kctl->id; 1587 break; 1588 case FORMAT_IDX: 1589 setup->format_id = kctl->id; 1590 break; 1591 case RATE_IDX: 1592 setup->rate_id = kctl->id; 1593 break; 1594 case CHANNELS_IDX: 1595 setup->channels_id = kctl->id; 1596 break; 1597 default: 1598 break; 1599 } 1600 } 1601 } 1602 } 1603 return 0; 1604} 1605 1606static void print_dpcm_info(struct snd_info_buffer *buffer, 1607 struct loopback_pcm *dpcm, 1608 const char *id) 1609{ 1610 snd_iprintf(buffer, " %s\n", id); 1611 if (dpcm == NULL) { 1612 snd_iprintf(buffer, " inactive\n"); 1613 return; 1614 } 1615 snd_iprintf(buffer, " buffer_size:\t%u\n", dpcm->pcm_buffer_size); 1616 snd_iprintf(buffer, " buffer_pos:\t\t%u\n", dpcm->buf_pos); 1617 snd_iprintf(buffer, " silent_size:\t%u\n", dpcm->silent_size); 1618 snd_iprintf(buffer, " period_size:\t%u\n", dpcm->pcm_period_size); 1619 snd_iprintf(buffer, " bytes_per_sec:\t%u\n", dpcm->pcm_bps); 1620 snd_iprintf(buffer, " sample_align:\t%u\n", dpcm->pcm_salign); 1621 snd_iprintf(buffer, " rate_shift:\t\t%u\n", dpcm->pcm_rate_shift); 1622 if (dpcm->cable->ops->dpcm_info) 1623 dpcm->cable->ops->dpcm_info(dpcm, buffer); 1624} 1625 1626static void print_substream_info(struct snd_info_buffer *buffer, 1627 struct loopback *loopback, 1628 int sub, 1629 int num) 1630{ 1631 struct loopback_cable *cable = loopback->cables[sub][num]; 1632 1633 snd_iprintf(buffer, "Cable %i substream %i:\n", num, sub); 1634 if (cable == NULL) { 1635 snd_iprintf(buffer, " inactive\n"); 1636 return; 1637 } 1638 snd_iprintf(buffer, " valid: %u\n", cable->valid); 1639 snd_iprintf(buffer, " running: %u\n", cable->running); 1640 snd_iprintf(buffer, " pause: %u\n", cable->pause); 1641 print_dpcm_info(buffer, cable->streams[0], "Playback"); 1642 print_dpcm_info(buffer, cable->streams[1], "Capture"); 1643} 1644 1645static void print_cable_info(struct snd_info_entry *entry, 1646 struct snd_info_buffer *buffer) 1647{ 1648 struct loopback *loopback = entry->private_data; 1649 int sub, num; 1650 1651 mutex_lock(&loopback->cable_lock); 1652 num = entry->name[strlen(entry->name)-1]; 1653 num = num == '0' ? 0 : 1; 1654 for (sub = 0; sub < MAX_PCM_SUBSTREAMS; sub++) 1655 print_substream_info(buffer, loopback, sub, num); 1656 mutex_unlock(&loopback->cable_lock); 1657} 1658 1659static int loopback_cable_proc_new(struct loopback *loopback, int cidx) 1660{ 1661 char name[32]; 1662 1663 snprintf(name, sizeof(name), "cable#%d", cidx); 1664 return snd_card_ro_proc_new(loopback->card, name, loopback, 1665 print_cable_info); 1666} 1667 1668static void loopback_set_timer_source(struct loopback *loopback, 1669 const char *value) 1670{ 1671 if (loopback->timer_source) { 1672 devm_kfree(loopback->card->dev, loopback->timer_source); 1673 loopback->timer_source = NULL; 1674 } 1675 if (value && *value) 1676 loopback->timer_source = devm_kstrdup(loopback->card->dev, 1677 value, GFP_KERNEL); 1678} 1679 1680static void print_timer_source_info(struct snd_info_entry *entry, 1681 struct snd_info_buffer *buffer) 1682{ 1683 struct loopback *loopback = entry->private_data; 1684 1685 mutex_lock(&loopback->cable_lock); 1686 snd_iprintf(buffer, "%s\n", 1687 loopback->timer_source ? loopback->timer_source : ""); 1688 mutex_unlock(&loopback->cable_lock); 1689} 1690 1691static void change_timer_source_info(struct snd_info_entry *entry, 1692 struct snd_info_buffer *buffer) 1693{ 1694 struct loopback *loopback = entry->private_data; 1695 char line[64]; 1696 1697 mutex_lock(&loopback->cable_lock); 1698 if (!snd_info_get_line(buffer, line, sizeof(line))) 1699 loopback_set_timer_source(loopback, strim(line)); 1700 mutex_unlock(&loopback->cable_lock); 1701} 1702 1703static int loopback_timer_source_proc_new(struct loopback *loopback) 1704{ 1705 return snd_card_rw_proc_new(loopback->card, "timer_source", loopback, 1706 print_timer_source_info, 1707 change_timer_source_info); 1708} 1709 1710static int loopback_probe(struct platform_device *devptr) 1711{ 1712 struct snd_card *card; 1713 struct loopback *loopback; 1714 int dev = devptr->id; 1715 int err; 1716 1717 err = snd_card_new(&devptr->dev, index[dev], id[dev], THIS_MODULE, 1718 sizeof(struct loopback), &card); 1719 if (err < 0) 1720 return err; 1721 loopback = card->private_data; 1722 1723 if (pcm_substreams[dev] < 1) 1724 pcm_substreams[dev] = 1; 1725 if (pcm_substreams[dev] > MAX_PCM_SUBSTREAMS) 1726 pcm_substreams[dev] = MAX_PCM_SUBSTREAMS; 1727 1728 loopback->card = card; 1729 loopback_set_timer_source(loopback, timer_source[dev]); 1730 1731 mutex_init(&loopback->cable_lock); 1732 1733 err = loopback_pcm_new(loopback, 0, pcm_substreams[dev]); 1734 if (err < 0) 1735 goto __nodev; 1736 err = loopback_pcm_new(loopback, 1, pcm_substreams[dev]); 1737 if (err < 0) 1738 goto __nodev; 1739 err = loopback_mixer_new(loopback, pcm_notify[dev] ? 1 : 0); 1740 if (err < 0) 1741 goto __nodev; 1742 loopback_cable_proc_new(loopback, 0); 1743 loopback_cable_proc_new(loopback, 1); 1744 loopback_timer_source_proc_new(loopback); 1745 strcpy(card->driver, "Loopback"); 1746 strcpy(card->shortname, "Loopback"); 1747 sprintf(card->longname, "Loopback %i", dev + 1); 1748 err = snd_card_register(card); 1749 if (!err) { 1750 platform_set_drvdata(devptr, card); 1751 return 0; 1752 } 1753 __nodev: 1754 snd_card_free(card); 1755 return err; 1756} 1757 1758static int loopback_remove(struct platform_device *devptr) 1759{ 1760 snd_card_free(platform_get_drvdata(devptr)); 1761 return 0; 1762} 1763 1764#ifdef CONFIG_PM_SLEEP 1765static int loopback_suspend(struct device *pdev) 1766{ 1767 struct snd_card *card = dev_get_drvdata(pdev); 1768 1769 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 1770 return 0; 1771} 1772 1773static int loopback_resume(struct device *pdev) 1774{ 1775 struct snd_card *card = dev_get_drvdata(pdev); 1776 1777 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 1778 return 0; 1779} 1780 1781static SIMPLE_DEV_PM_OPS(loopback_pm, loopback_suspend, loopback_resume); 1782#define LOOPBACK_PM_OPS &loopback_pm 1783#else 1784#define LOOPBACK_PM_OPS NULL 1785#endif 1786 1787#define SND_LOOPBACK_DRIVER "snd_aloop" 1788 1789static struct platform_driver loopback_driver = { 1790 .probe = loopback_probe, 1791 .remove = loopback_remove, 1792 .driver = { 1793 .name = SND_LOOPBACK_DRIVER, 1794 .pm = LOOPBACK_PM_OPS, 1795 }, 1796}; 1797 1798static void loopback_unregister_all(void) 1799{ 1800 int i; 1801 1802 for (i = 0; i < ARRAY_SIZE(devices); ++i) 1803 platform_device_unregister(devices[i]); 1804 platform_driver_unregister(&loopback_driver); 1805} 1806 1807static int __init alsa_card_loopback_init(void) 1808{ 1809 int i, err, cards; 1810 1811 err = platform_driver_register(&loopback_driver); 1812 if (err < 0) 1813 return err; 1814 1815 1816 cards = 0; 1817 for (i = 0; i < SNDRV_CARDS; i++) { 1818 struct platform_device *device; 1819 if (!enable[i]) 1820 continue; 1821 device = platform_device_register_simple(SND_LOOPBACK_DRIVER, 1822 i, NULL, 0); 1823 if (IS_ERR(device)) 1824 continue; 1825 if (!platform_get_drvdata(device)) { 1826 platform_device_unregister(device); 1827 continue; 1828 } 1829 devices[i] = device; 1830 cards++; 1831 } 1832 if (!cards) { 1833#ifdef MODULE 1834 printk(KERN_ERR "aloop: No loopback enabled\n"); 1835#endif 1836 loopback_unregister_all(); 1837 return -ENODEV; 1838 } 1839 return 0; 1840} 1841 1842static void __exit alsa_card_loopback_exit(void) 1843{ 1844 loopback_unregister_all(); 1845} 1846 1847module_init(alsa_card_loopback_init) 1848module_exit(alsa_card_loopback_exit) 1849