sound/firewire/oxfw/oxfw-pcm.c

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