sound/drivers/aloop.c

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