sound/firewire/fireworks/fireworks_pcm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * fireworks_pcm.c - a part of driver for Fireworks based devices
   4  *
   5  * Copyright (c) 2009-2010 Clemens Ladisch
   6  * Copyright (c) 2013-2014 Takashi Sakamoto
   7  */
   8 #include "./fireworks.h"
   9
  10 /*
  11  * NOTE:
  12  * Fireworks changes its AMDTP channels for PCM data according to its sampling
  13  * rate. There are three modes. Here _XX is either _rx or _tx.
  14  *  0:  32.0- 48.0 kHz then snd_efw_hwinfo.amdtp_XX_pcm_channels applied
  15  *  1:  88.2- 96.0 kHz then snd_efw_hwinfo.amdtp_XX_pcm_channels_2x applied
  16  *  2: 176.4-192.0 kHz then snd_efw_hwinfo.amdtp_XX_pcm_channels_4x applied
  17  *
  18  * The number of PCM channels for analog input and output are always fixed but
  19  * the number of PCM channels for digital input and output are differed.
  20  *
  21  * Additionally, according to "AudioFire Owner's Manual Version 2.2", in some
  22  * model, the number of PCM channels for digital input has more restriction
  23  * depending on which digital interface is selected.
  24  *  - S/PDIF coaxial and optical        : use input 1-2
  25  *  - ADAT optical at 32.0-48.0 kHz     : use input 1-8
  26  *  - ADAT optical at 88.2-96.0 kHz     : use input 1-4 (S/MUX format)
  27  *
  28  * The data in AMDTP channels for blank PCM channels are zero.
  29  */
  30 static const unsigned int freq_table[] = {
  31         /* multiplier mode 0 */
  32         [0] = 32000,
  33         [1] = 44100,
  34         [2] = 48000,
  35         /* multiplier mode 1 */
  36         [3] = 88200,
  37         [4] = 96000,
  38         /* multiplier mode 2 */
  39         [5] = 176400,
  40         [6] = 192000,
  41 };
  42
  43 static inline unsigned int
  44 get_multiplier_mode_with_index(unsigned int index)
  45 {
  46         return ((int)index - 1) / 2;
  47 }
  48
  49 int snd_efw_get_multiplier_mode(unsigned int sampling_rate, unsigned int *mode)
  50 {
  51         unsigned int i;
  52
  53         for (i = 0; i < ARRAY_SIZE(freq_table); i++) {
  54                 if (freq_table[i] == sampling_rate) {
  55                         *mode = get_multiplier_mode_with_index(i);
  56                         return 0;
  57                 }
  58         }
  59
  60         return -EINVAL;
  61 }
  62
  63 static int
  64 hw_rule_rate(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
  65 {
  66         unsigned int *pcm_channels = rule->private;
  67         struct snd_interval *r =
  68                 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
  69         const struct snd_interval *c =
  70                 hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  71         struct snd_interval t = {
  72                 .min = UINT_MAX, .max = 0, .integer = 1
  73         };
  74         unsigned int i, mode;
  75
  76         for (i = 0; i < ARRAY_SIZE(freq_table); i++) {
  77                 mode = get_multiplier_mode_with_index(i);
  78                 if (!snd_interval_test(c, pcm_channels[mode]))
  79                         continue;
  80
  81                 t.min = min(t.min, freq_table[i]);
  82                 t.max = max(t.max, freq_table[i]);
  83         }
  84
  85         return snd_interval_refine(r, &t);
  86 }
  87
  88 static int
  89 hw_rule_channels(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
  90 {
  91         unsigned int *pcm_channels = rule->private;
  92         struct snd_interval *c =
  93                 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  94         const struct snd_interval *r =
  95                 hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
  96         struct snd_interval t = {
  97                 .min = UINT_MAX, .max = 0, .integer = 1
  98         };
  99         unsigned int i, mode;
 100
 101         for (i = 0; i < ARRAY_SIZE(freq_table); i++) {
 102                 mode = get_multiplier_mode_with_index(i);
 103                 if (!snd_interval_test(r, freq_table[i]))
 104                         continue;
 105
 106                 t.min = min(t.min, pcm_channels[mode]);
 107                 t.max = max(t.max, pcm_channels[mode]);
 108         }
 109
 110         return snd_interval_refine(c, &t);
 111 }
 112
 113 static void
 114 limit_channels(struct snd_pcm_hardware *hw, unsigned int *pcm_channels)
 115 {
 116         unsigned int i, mode;
 117
 118         hw->channels_min = UINT_MAX;
 119         hw->channels_max = 0;
 120
 121         for (i = 0; i < ARRAY_SIZE(freq_table); i++) {
 122                 mode = get_multiplier_mode_with_index(i);
 123                 if (pcm_channels[mode] == 0)
 124                         continue;
 125
 126                 hw->channels_min = min(hw->channels_min, pcm_channels[mode]);
 127                 hw->channels_max = max(hw->channels_max, pcm_channels[mode]);
 128         }
 129 }
 130
 131 static int
 132 pcm_init_hw_params(struct snd_efw *efw,
 133                    struct snd_pcm_substream *substream)
 134 {
 135         struct snd_pcm_runtime *runtime = substream->runtime;
 136         struct amdtp_stream *s;
 137         unsigned int *pcm_channels;
 138         int err;
 139
 140         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
 141                 runtime->hw.formats = AM824_IN_PCM_FORMAT_BITS;
 142                 s = &efw->tx_stream;
 143                 pcm_channels = efw->pcm_capture_channels;
 144         } else {
 145                 runtime->hw.formats = AM824_OUT_PCM_FORMAT_BITS;
 146                 s = &efw->rx_stream;
 147                 pcm_channels = efw->pcm_playback_channels;
 148         }
 149
 150         /* limit rates */
 151         runtime->hw.rates = efw->supported_sampling_rate,
 152         snd_pcm_limit_hw_rates(runtime);
 153
 154         limit_channels(&runtime->hw, pcm_channels);
 155
 156         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 157                                   hw_rule_channels, pcm_channels,
 158                                   SNDRV_PCM_HW_PARAM_RATE, -1);
 159         if (err < 0)
 160                 goto end;
 161
 162         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 163                                   hw_rule_rate, pcm_channels,
 164                                   SNDRV_PCM_HW_PARAM_CHANNELS, -1);
 165         if (err < 0)
 166                 goto end;
 167
 168         err = amdtp_am824_add_pcm_hw_constraints(s, runtime);
 169 end:
 170         return err;
 171 }
 172
 173 static int pcm_open(struct snd_pcm_substream *substream)
 174 {
 175         struct snd_efw *efw = substream->private_data;
 176         struct amdtp_domain *d = &efw->domain;
 177         enum snd_efw_clock_source clock_source;
 178         int err;
 179
 180         err = snd_efw_stream_lock_try(efw);
 181         if (err < 0)
 182                 return err;
 183
 184         err = pcm_init_hw_params(efw, substream);
 185         if (err < 0)
 186                 goto err_locked;
 187
 188         err = snd_efw_command_get_clock_source(efw, &clock_source);
 189         if (err < 0)
 190                 goto err_locked;
 191
 192         mutex_lock(&efw->mutex);
 193
 194         // When source of clock is not internal or any stream is reserved for
 195         // transmission of PCM frames, the available sampling rate is limited
 196         // at current one.
 197         if ((clock_source != SND_EFW_CLOCK_SOURCE_INTERNAL) ||
 198             (efw->substreams_counter > 0 && d->events_per_period > 0)) {
 199                 unsigned int frames_per_period = d->events_per_period;
 200                 unsigned int frames_per_buffer = d->events_per_buffer;
 201                 unsigned int sampling_rate;
 202
 203                 err = snd_efw_command_get_sampling_rate(efw, &sampling_rate);
 204                 if (err < 0) {
 205                         mutex_unlock(&efw->mutex);
 206                         goto err_locked;
 207                 }
 208                 substream->runtime->hw.rate_min = sampling_rate;
 209                 substream->runtime->hw.rate_max = sampling_rate;
 210
 211                 if (frames_per_period > 0) {
 212                         err = snd_pcm_hw_constraint_minmax(substream->runtime,
 213                                         SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
 214                                         frames_per_period, frames_per_period);
 215                         if (err < 0) {
 216                                 mutex_unlock(&efw->mutex);
 217                                 goto err_locked;
 218                         }
 219
 220                         err = snd_pcm_hw_constraint_minmax(substream->runtime,
 221                                         SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
 222                                         frames_per_buffer, frames_per_buffer);
 223                         if (err < 0) {
 224                                 mutex_unlock(&efw->mutex);
 225                                 goto err_locked;
 226                         }
 227                 }
 228         }
 229
 230         mutex_unlock(&efw->mutex);
 231
 232         snd_pcm_set_sync(substream);
 233
 234         return 0;
 235 err_locked:
 236         snd_efw_stream_lock_release(efw);
 237         return err;
 238 }
 239
 240 static int pcm_close(struct snd_pcm_substream *substream)
 241 {
 242         struct snd_efw *efw = substream->private_data;
 243         snd_efw_stream_lock_release(efw);
 244         return 0;
 245 }
 246
 247 static int pcm_hw_params(struct snd_pcm_substream *substream,
 248                                  struct snd_pcm_hw_params *hw_params)
 249 {
 250         struct snd_efw *efw = substream->private_data;
 251         int err;
 252
 253         err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 254         if (err < 0)
 255                 return err;
 256
 257         if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
 258                 unsigned int rate = params_rate(hw_params);
 259                 unsigned int frames_per_period = params_period_size(hw_params);
 260                 unsigned int frames_per_buffer = params_buffer_size(hw_params);
 261
 262                 mutex_lock(&efw->mutex);
 263                 err = snd_efw_stream_reserve_duplex(efw, rate,
 264                                         frames_per_period, frames_per_buffer);
 265                 if (err >= 0)
 266                         ++efw->substreams_counter;
 267                 mutex_unlock(&efw->mutex);
 268         }
 269
 270         return err;
 271 }
 272
 273 static int pcm_hw_free(struct snd_pcm_substream *substream)
 274 {
 275         struct snd_efw *efw = substream->private_data;
 276
 277         mutex_lock(&efw->mutex);
 278
 279         if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
 280                 --efw->substreams_counter;
 281
 282         snd_efw_stream_stop_duplex(efw);
 283
 284         mutex_unlock(&efw->mutex);
 285
 286         return snd_pcm_lib_free_pages(substream);
 287 }
 288
 289 static int pcm_capture_prepare(struct snd_pcm_substream *substream)
 290 {
 291         struct snd_efw *efw = substream->private_data;
 292         int err;
 293
 294         err = snd_efw_stream_start_duplex(efw);
 295         if (err >= 0)
 296                 amdtp_stream_pcm_prepare(&efw->tx_stream);
 297
 298         return err;
 299 }
 300 static int pcm_playback_prepare(struct snd_pcm_substream *substream)
 301 {
 302         struct snd_efw *efw = substream->private_data;
 303         int err;
 304
 305         err = snd_efw_stream_start_duplex(efw);
 306         if (err >= 0)
 307                 amdtp_stream_pcm_prepare(&efw->rx_stream);
 308
 309         return err;
 310 }
 311
 312 static int pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
 313 {
 314         struct snd_efw *efw = substream->private_data;
 315
 316         switch (cmd) {
 317         case SNDRV_PCM_TRIGGER_START:
 318                 amdtp_stream_pcm_trigger(&efw->tx_stream, substream);
 319                 break;
 320         case SNDRV_PCM_TRIGGER_STOP:
 321                 amdtp_stream_pcm_trigger(&efw->tx_stream, NULL);
 322                 break;
 323         default:
 324                 return -EINVAL;
 325         }
 326
 327         return 0;
 328 }
 329 static int pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
 330 {
 331         struct snd_efw *efw = substream->private_data;
 332
 333         switch (cmd) {
 334         case SNDRV_PCM_TRIGGER_START:
 335                 amdtp_stream_pcm_trigger(&efw->rx_stream, substream);
 336                 break;
 337         case SNDRV_PCM_TRIGGER_STOP:
 338                 amdtp_stream_pcm_trigger(&efw->rx_stream, NULL);
 339                 break;
 340         default:
 341                 return -EINVAL;
 342         }
 343
 344         return 0;
 345 }
 346
 347 static snd_pcm_uframes_t pcm_capture_pointer(struct snd_pcm_substream *sbstrm)
 348 {
 349         struct snd_efw *efw = sbstrm->private_data;
 350
 351         return amdtp_domain_stream_pcm_pointer(&efw->domain, &efw->tx_stream);
 352 }
 353 static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstrm)
 354 {
 355         struct snd_efw *efw = sbstrm->private_data;
 356
 357         return amdtp_domain_stream_pcm_pointer(&efw->domain, &efw->rx_stream);
 358 }
 359
 360 static int pcm_capture_ack(struct snd_pcm_substream *substream)
 361 {
 362         struct snd_efw *efw = substream->private_data;
 363
 364         return amdtp_domain_stream_pcm_ack(&efw->domain, &efw->tx_stream);
 365 }
 366
 367 static int pcm_playback_ack(struct snd_pcm_substream *substream)
 368 {
 369         struct snd_efw *efw = substream->private_data;
 370
 371         return amdtp_domain_stream_pcm_ack(&efw->domain, &efw->rx_stream);
 372 }
 373
 374 int snd_efw_create_pcm_devices(struct snd_efw *efw)
 375 {
 376         static const struct snd_pcm_ops capture_ops = {
 377                 .open           = pcm_open,
 378                 .close          = pcm_close,
 379                 .ioctl          = snd_pcm_lib_ioctl,
 380                 .hw_params      = pcm_hw_params,
 381                 .hw_free        = pcm_hw_free,
 382                 .prepare        = pcm_capture_prepare,
 383                 .trigger        = pcm_capture_trigger,
 384                 .pointer        = pcm_capture_pointer,
 385                 .ack            = pcm_capture_ack,
 386         };
 387         static const struct snd_pcm_ops playback_ops = {
 388                 .open           = pcm_open,
 389                 .close          = pcm_close,
 390                 .ioctl          = snd_pcm_lib_ioctl,
 391                 .hw_params      = pcm_hw_params,
 392                 .hw_free        = pcm_hw_free,
 393                 .prepare        = pcm_playback_prepare,
 394                 .trigger        = pcm_playback_trigger,
 395                 .pointer        = pcm_playback_pointer,
 396                 .ack            = pcm_playback_ack,
 397         };
 398         struct snd_pcm *pcm;
 399         int err;
 400
 401         err = snd_pcm_new(efw->card, efw->card->driver, 0, 1, 1, &pcm);
 402         if (err < 0)
 403                 goto end;
 404
 405         pcm->private_data = efw;
 406         snprintf(pcm->name, sizeof(pcm->name), "%s PCM", efw->card->shortname);
 407         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_ops);
 408         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops);
 409         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_VMALLOC,
 410                                               NULL, 0, 0);
 411 end:
 412         return err;
 413 }
 414