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         unsigned 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         unsigned 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         unsigned 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 pcm_open(struct snd_pcm_substream *substream)
 122 {
 123         struct snd_oxfw *oxfw = substream->private_data;
 124         struct snd_pcm_runtime *runtime = substream->runtime;
 125         u8 **formats;
 126         int err;
 127
 128         formats = oxfw->rx_stream_formats;
 129
 130         runtime->hw.info = SNDRV_PCM_INFO_BATCH |
 131                            SNDRV_PCM_INFO_BLOCK_TRANSFER |
 132                            SNDRV_PCM_INFO_INTERLEAVED |
 133                            SNDRV_PCM_INFO_MMAP |
 134                            SNDRV_PCM_INFO_MMAP_VALID;
 135
 136         limit_channels_and_rates(&runtime->hw, formats);
 137         limit_period_and_buffer(&runtime->hw);
 138
 139         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 140                                   hw_rule_channels, formats,
 141                                   SNDRV_PCM_HW_PARAM_RATE, -1);
 142         if (err < 0)
 143                 goto end;
 144
 145         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 146                                   hw_rule_rate, formats,
 147                                   SNDRV_PCM_HW_PARAM_CHANNELS, -1);
 148         if (err < 0)
 149                 goto end;
 150
 151         err = amdtp_stream_add_pcm_hw_constraints(&oxfw->rx_stream, runtime);
 152         if (err < 0)
 153                 goto end;
 154
 155         snd_pcm_set_sync(substream);
 156 end:
 157         return err;
 158 }
 159
 160 static int pcm_close(struct snd_pcm_substream *substream)
 161 {
 162         return 0;
 163 }
 164
 165 static int pcm_hw_params(struct snd_pcm_substream *substream,
 166                          struct snd_pcm_hw_params *hw_params)
 167 {
 168         struct snd_oxfw *oxfw = substream->private_data;
 169
 170         amdtp_stream_set_pcm_format(&oxfw->rx_stream, params_format(hw_params));
 171         return snd_pcm_lib_alloc_vmalloc_buffer(substream,
 172                                                 params_buffer_bytes(hw_params));
 173 }
 174
 175 static int pcm_hw_free(struct snd_pcm_substream *substream)
 176 {
 177         struct snd_oxfw *oxfw = substream->private_data;
 178
 179         mutex_lock(&oxfw->mutex);
 180         snd_oxfw_stream_stop_simplex(oxfw);
 181         mutex_unlock(&oxfw->mutex);
 182
 183         return snd_pcm_lib_free_vmalloc_buffer(substream);
 184 }
 185
 186 static int pcm_prepare(struct snd_pcm_substream *substream)
 187 {
 188         struct snd_oxfw *oxfw = substream->private_data;
 189         struct snd_pcm_runtime *runtime = substream->runtime;
 190         int err;
 191
 192         mutex_lock(&oxfw->mutex);
 193         err = snd_oxfw_stream_start_simplex(oxfw, runtime->rate,
 194                                             runtime->channels);
 195         mutex_unlock(&oxfw->mutex);
 196         if (err < 0)
 197                 goto end;
 198
 199         amdtp_stream_pcm_prepare(&oxfw->rx_stream);
 200 end:
 201         return err;
 202 }
 203
 204 static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 205 {
 206         struct snd_oxfw *oxfw = substream->private_data;
 207         struct snd_pcm_substream *pcm;
 208
 209         switch (cmd) {
 210         case SNDRV_PCM_TRIGGER_START:
 211                 pcm = substream;
 212                 break;
 213         case SNDRV_PCM_TRIGGER_STOP:
 214                 pcm = NULL;
 215                 break;
 216         default:
 217                 return -EINVAL;
 218         }
 219         amdtp_stream_pcm_trigger(&oxfw->rx_stream, pcm);
 220         return 0;
 221 }
 222
 223 static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
 224 {
 225         struct snd_oxfw *oxfw = substream->private_data;
 226
 227         return amdtp_stream_pcm_pointer(&oxfw->rx_stream);
 228 }
 229
 230 int snd_oxfw_create_pcm(struct snd_oxfw *oxfw)
 231 {
 232         static struct snd_pcm_ops ops = {
 233                 .open      = pcm_open,
 234                 .close     = pcm_close,
 235                 .ioctl     = snd_pcm_lib_ioctl,
 236                 .hw_params = pcm_hw_params,
 237                 .hw_free   = pcm_hw_free,
 238                 .prepare   = pcm_prepare,
 239                 .trigger   = pcm_trigger,
 240                 .pointer   = pcm_pointer,
 241                 .page      = snd_pcm_lib_get_vmalloc_page,
 242                 .mmap      = snd_pcm_lib_mmap_vmalloc,
 243         };
 244         struct snd_pcm *pcm;
 245         int err;
 246
 247         err = snd_pcm_new(oxfw->card, oxfw->card->driver, 0, 1, 0, &pcm);
 248         if (err < 0)
 249                 return err;
 250         pcm->private_data = oxfw;
 251         strcpy(pcm->name, oxfw->card->shortname);
 252         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ops);
 253         return 0;
 254 }