sound/firewire/dice/dice-pcm.c

   1 /*
   2  * dice_pcm.c - a part of driver for DICE based devices
   3  *
   4  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
   5  * Copyright (c) 2014 Takashi Sakamoto <o-takashi@sakamocchi.jp>
   6  *
   7  * Licensed under the terms of the GNU General Public License, version 2.
   8  */
   9
  10 #include "dice.h"
  11
  12 static int dice_rate_constraint(struct snd_pcm_hw_params *params,
  13                                 struct snd_pcm_hw_rule *rule)
  14 {
  15         struct snd_pcm_substream *substream = rule->private;
  16         struct snd_dice *dice = substream->private_data;
  17
  18         const struct snd_interval *c =
  19                 hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  20         struct snd_interval *r =
  21                 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
  22         struct snd_interval rates = {
  23                 .min = UINT_MAX, .max = 0, .integer = 1
  24         };
  25         unsigned int i, rate, mode, *pcm_channels;
  26
  27         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
  28                 pcm_channels = dice->tx_channels;
  29         else
  30                 pcm_channels = dice->rx_channels;
  31
  32         for (i = 0; i < ARRAY_SIZE(snd_dice_rates); ++i) {
  33                 rate = snd_dice_rates[i];
  34                 if (snd_dice_stream_get_rate_mode(dice, rate, &mode) < 0)
  35                         continue;
  36
  37                 if (!snd_interval_test(c, pcm_channels[mode]))
  38                         continue;
  39
  40                 rates.min = min(rates.min, rate);
  41                 rates.max = max(rates.max, rate);
  42         }
  43
  44         return snd_interval_refine(r, &rates);
  45 }
  46
  47 static int dice_channels_constraint(struct snd_pcm_hw_params *params,
  48                                     struct snd_pcm_hw_rule *rule)
  49 {
  50         struct snd_pcm_substream *substream = rule->private;
  51         struct snd_dice *dice = substream->private_data;
  52
  53         const struct snd_interval *r =
  54                 hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
  55         struct snd_interval *c =
  56                 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  57         struct snd_interval channels = {
  58                 .min = UINT_MAX, .max = 0, .integer = 1
  59         };
  60         unsigned int i, rate, mode, *pcm_channels;
  61
  62         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
  63                 pcm_channels = dice->tx_channels;
  64         else
  65                 pcm_channels = dice->rx_channels;
  66
  67         for (i = 0; i < ARRAY_SIZE(snd_dice_rates); ++i) {
  68                 rate = snd_dice_rates[i];
  69                 if (snd_dice_stream_get_rate_mode(dice, rate, &mode) < 0)
  70                         continue;
  71
  72                 if (!snd_interval_test(r, rate))
  73                         continue;
  74
  75                 channels.min = min(channels.min, pcm_channels[mode]);
  76                 channels.max = max(channels.max, pcm_channels[mode]);
  77         }
  78
  79         return snd_interval_refine(c, &channels);
  80 }
  81
  82 static void limit_channels_and_rates(struct snd_dice *dice,
  83                                      struct snd_pcm_runtime *runtime,
  84                                      unsigned int *pcm_channels)
  85 {
  86         struct snd_pcm_hardware *hw = &runtime->hw;
  87         unsigned int i, rate, mode;
  88
  89         hw->channels_min = UINT_MAX;
  90         hw->channels_max = 0;
  91
  92         for (i = 0; i < ARRAY_SIZE(snd_dice_rates); ++i) {
  93                 rate = snd_dice_rates[i];
  94                 if (snd_dice_stream_get_rate_mode(dice, rate, &mode) < 0)
  95                         continue;
  96                 hw->rates |= snd_pcm_rate_to_rate_bit(rate);
  97
  98                 if (pcm_channels[mode] == 0)
  99                         continue;
 100                 hw->channels_min = min(hw->channels_min, pcm_channels[mode]);
 101                 hw->channels_max = max(hw->channels_max, pcm_channels[mode]);
 102         }
 103
 104         snd_pcm_limit_hw_rates(runtime);
 105 }
 106
 107 static void limit_period_and_buffer(struct snd_pcm_hardware *hw)
 108 {
 109         hw->periods_min = 2;                    /* SNDRV_PCM_INFO_BATCH */
 110         hw->periods_max = UINT_MAX;
 111
 112         hw->period_bytes_min = 4 * hw->channels_max;    /* byte for a frame */
 113
 114         /* Just to prevent from allocating much pages. */
 115         hw->period_bytes_max = hw->period_bytes_min * 2048;
 116         hw->buffer_bytes_max = hw->period_bytes_max * hw->periods_min;
 117 }
 118
 119 static int init_hw_info(struct snd_dice *dice,
 120                         struct snd_pcm_substream *substream)
 121 {
 122         struct snd_pcm_runtime *runtime = substream->runtime;
 123         struct snd_pcm_hardware *hw = &runtime->hw;
 124         struct amdtp_stream *stream;
 125         unsigned int *pcm_channels;
 126         int err;
 127
 128         hw->info = SNDRV_PCM_INFO_MMAP |
 129                    SNDRV_PCM_INFO_MMAP_VALID |
 130                    SNDRV_PCM_INFO_BATCH |
 131                    SNDRV_PCM_INFO_INTERLEAVED |
 132                    SNDRV_PCM_INFO_JOINT_DUPLEX |
 133                    SNDRV_PCM_INFO_BLOCK_TRANSFER;
 134
 135         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
 136                 hw->formats = AMDTP_IN_PCM_FORMAT_BITS;
 137                 stream = &dice->tx_stream;
 138                 pcm_channels = dice->tx_channels;
 139         } else {
 140                 hw->formats = AMDTP_OUT_PCM_FORMAT_BITS;
 141                 stream = &dice->rx_stream;
 142                 pcm_channels = dice->rx_channels;
 143         }
 144
 145         limit_channels_and_rates(dice, runtime, pcm_channels);
 146         limit_period_and_buffer(hw);
 147
 148         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 149                                   dice_rate_constraint, substream,
 150                                   SNDRV_PCM_HW_PARAM_CHANNELS, -1);
 151         if (err < 0)
 152                 goto end;
 153         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 154                                   dice_channels_constraint, substream,
 155                                   SNDRV_PCM_HW_PARAM_RATE, -1);
 156         if (err < 0)
 157                 goto end;
 158
 159         err = amdtp_stream_add_pcm_hw_constraints(stream, runtime);
 160 end:
 161         return err;
 162 }
 163
 164 static int pcm_open(struct snd_pcm_substream *substream)
 165 {
 166         struct snd_dice *dice = substream->private_data;
 167         unsigned int source, rate;
 168         bool internal;
 169         int err;
 170
 171         err = snd_dice_stream_lock_try(dice);
 172         if (err < 0)
 173                 goto end;
 174
 175         err = init_hw_info(dice, substream);
 176         if (err < 0)
 177                 goto err_locked;
 178
 179         err = snd_dice_transaction_get_clock_source(dice, &source);
 180         if (err < 0)
 181                 goto err_locked;
 182         switch (source) {
 183         case CLOCK_SOURCE_AES1:
 184         case CLOCK_SOURCE_AES2:
 185         case CLOCK_SOURCE_AES3:
 186         case CLOCK_SOURCE_AES4:
 187         case CLOCK_SOURCE_AES_ANY:
 188         case CLOCK_SOURCE_ADAT:
 189         case CLOCK_SOURCE_TDIF:
 190         case CLOCK_SOURCE_WC:
 191                 internal = false;
 192                 break;
 193         default:
 194                 internal = true;
 195                 break;
 196         }
 197
 198         /*
 199          * When source of clock is not internal or any PCM streams are running,
 200          * available sampling rate is limited at current sampling rate.
 201          */
 202         if (!internal ||
 203             amdtp_stream_pcm_running(&dice->tx_stream) ||
 204             amdtp_stream_pcm_running(&dice->rx_stream)) {
 205                 err = snd_dice_transaction_get_rate(dice, &rate);
 206                 if (err < 0)
 207                         goto err_locked;
 208                 substream->runtime->hw.rate_min = rate;
 209                 substream->runtime->hw.rate_max = rate;
 210         }
 211
 212         snd_pcm_set_sync(substream);
 213 end:
 214         return err;
 215 err_locked:
 216         snd_dice_stream_lock_release(dice);
 217         return err;
 218 }
 219
 220 static int pcm_close(struct snd_pcm_substream *substream)
 221 {
 222         struct snd_dice *dice = substream->private_data;
 223
 224         snd_dice_stream_lock_release(dice);
 225
 226         return 0;
 227 }
 228
 229 static int capture_hw_params(struct snd_pcm_substream *substream,
 230                              struct snd_pcm_hw_params *hw_params)
 231 {
 232         struct snd_dice *dice = substream->private_data;
 233
 234         if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
 235                 mutex_lock(&dice->mutex);
 236                 dice->substreams_counter++;
 237                 mutex_unlock(&dice->mutex);
 238         }
 239
 240         amdtp_stream_set_pcm_format(&dice->tx_stream,
 241                                     params_format(hw_params));
 242
 243         return snd_pcm_lib_alloc_vmalloc_buffer(substream,
 244                                                 params_buffer_bytes(hw_params));
 245 }
 246 static int playback_hw_params(struct snd_pcm_substream *substream,
 247                               struct snd_pcm_hw_params *hw_params)
 248 {
 249         struct snd_dice *dice = substream->private_data;
 250
 251         if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
 252                 mutex_lock(&dice->mutex);
 253                 dice->substreams_counter++;
 254                 mutex_unlock(&dice->mutex);
 255         }
 256
 257         amdtp_stream_set_pcm_format(&dice->rx_stream,
 258                                     params_format(hw_params));
 259
 260         return snd_pcm_lib_alloc_vmalloc_buffer(substream,
 261                                                 params_buffer_bytes(hw_params));
 262 }
 263
 264 static int capture_hw_free(struct snd_pcm_substream *substream)
 265 {
 266         struct snd_dice *dice = substream->private_data;
 267
 268         mutex_lock(&dice->mutex);
 269
 270         if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
 271                 dice->substreams_counter--;
 272
 273         snd_dice_stream_stop_duplex(dice);
 274
 275         mutex_unlock(&dice->mutex);
 276
 277         return snd_pcm_lib_free_vmalloc_buffer(substream);
 278 }
 279
 280 static int playback_hw_free(struct snd_pcm_substream *substream)
 281 {
 282         struct snd_dice *dice = substream->private_data;
 283
 284         mutex_lock(&dice->mutex);
 285
 286         if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
 287                 dice->substreams_counter--;
 288
 289         snd_dice_stream_stop_duplex(dice);
 290
 291         mutex_unlock(&dice->mutex);
 292
 293         return snd_pcm_lib_free_vmalloc_buffer(substream);
 294 }
 295
 296 static int capture_prepare(struct snd_pcm_substream *substream)
 297 {
 298         struct snd_dice *dice = substream->private_data;
 299         int err;
 300
 301         mutex_lock(&dice->mutex);
 302         err = snd_dice_stream_start_duplex(dice, substream->runtime->rate);
 303         mutex_unlock(&dice->mutex);
 304         if (err >= 0)
 305                 amdtp_stream_pcm_prepare(&dice->tx_stream);
 306
 307         return 0;
 308 }
 309 static int playback_prepare(struct snd_pcm_substream *substream)
 310 {
 311         struct snd_dice *dice = substream->private_data;
 312         int err;
 313
 314         mutex_lock(&dice->mutex);
 315         err = snd_dice_stream_start_duplex(dice, substream->runtime->rate);
 316         mutex_unlock(&dice->mutex);
 317         if (err >= 0)
 318                 amdtp_stream_pcm_prepare(&dice->rx_stream);
 319
 320         return err;
 321 }
 322
 323 static int capture_trigger(struct snd_pcm_substream *substream, int cmd)
 324 {
 325         struct snd_dice *dice = substream->private_data;
 326
 327         switch (cmd) {
 328         case SNDRV_PCM_TRIGGER_START:
 329                 amdtp_stream_pcm_trigger(&dice->tx_stream, substream);
 330                 break;
 331         case SNDRV_PCM_TRIGGER_STOP:
 332                 amdtp_stream_pcm_trigger(&dice->tx_stream, NULL);
 333                 break;
 334         default:
 335                 return -EINVAL;
 336         }
 337
 338         return 0;
 339 }
 340 static int playback_trigger(struct snd_pcm_substream *substream, int cmd)
 341 {
 342         struct snd_dice *dice = substream->private_data;
 343
 344         switch (cmd) {
 345         case SNDRV_PCM_TRIGGER_START:
 346                 amdtp_stream_pcm_trigger(&dice->rx_stream, substream);
 347                 break;
 348         case SNDRV_PCM_TRIGGER_STOP:
 349                 amdtp_stream_pcm_trigger(&dice->rx_stream, NULL);
 350                 break;
 351         default:
 352                 return -EINVAL;
 353         }
 354
 355         return 0;
 356 }
 357
 358 static snd_pcm_uframes_t capture_pointer(struct snd_pcm_substream *substream)
 359 {
 360         struct snd_dice *dice = substream->private_data;
 361
 362         return amdtp_stream_pcm_pointer(&dice->tx_stream);
 363 }
 364 static snd_pcm_uframes_t playback_pointer(struct snd_pcm_substream *substream)
 365 {
 366         struct snd_dice *dice = substream->private_data;
 367
 368         return amdtp_stream_pcm_pointer(&dice->rx_stream);
 369 }
 370
 371 int snd_dice_create_pcm(struct snd_dice *dice)
 372 {
 373         static struct snd_pcm_ops capture_ops = {
 374                 .open      = pcm_open,
 375                 .close     = pcm_close,
 376                 .ioctl     = snd_pcm_lib_ioctl,
 377                 .hw_params = capture_hw_params,
 378                 .hw_free   = capture_hw_free,
 379                 .prepare   = capture_prepare,
 380                 .trigger   = capture_trigger,
 381                 .pointer   = capture_pointer,
 382                 .page      = snd_pcm_lib_get_vmalloc_page,
 383                 .mmap      = snd_pcm_lib_mmap_vmalloc,
 384         };
 385         static struct snd_pcm_ops playback_ops = {
 386                 .open      = pcm_open,
 387                 .close     = pcm_close,
 388                 .ioctl     = snd_pcm_lib_ioctl,
 389                 .hw_params = playback_hw_params,
 390                 .hw_free   = playback_hw_free,
 391                 .prepare   = playback_prepare,
 392                 .trigger   = playback_trigger,
 393                 .pointer   = playback_pointer,
 394                 .page      = snd_pcm_lib_get_vmalloc_page,
 395                 .mmap      = snd_pcm_lib_mmap_vmalloc,
 396         };
 397         struct snd_pcm *pcm;
 398         unsigned int i, capture, playback;
 399         int err;
 400
 401         capture = playback = 0;
 402         for (i = 0; i < 3; i++) {
 403                 if (dice->tx_channels[i] > 0)
 404                         capture = 1;
 405                 if (dice->rx_channels[i] > 0)
 406                         playback = 1;
 407         }
 408
 409         err = snd_pcm_new(dice->card, "DICE", 0, playback, capture, &pcm);
 410         if (err < 0)
 411                 return err;
 412         pcm->private_data = dice;
 413         strcpy(pcm->name, dice->card->shortname);
 414
 415         if (capture > 0)
 416                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops);
 417
 418         if (playback > 0)
 419                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_ops);
 420
 421         return 0;
 422 }