kernel/sound/firewire/dice/dice-stream.c

   1 /*
   2  * dice_stream.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 #define CALLBACK_TIMEOUT        200
  13
  14 const unsigned int snd_dice_rates[SND_DICE_RATES_COUNT] = {
  15         /* mode 0 */
  16         [0] =  32000,
  17         [1] =  44100,
  18         [2] =  48000,
  19         /* mode 1 */
  20         [3] =  88200,
  21         [4] =  96000,
  22         /* mode 2 */
  23         [5] = 176400,
  24         [6] = 192000,
  25 };
  26
  27 int snd_dice_stream_get_rate_mode(struct snd_dice *dice, unsigned int rate,
  28                                   unsigned int *mode)
  29 {
  30         int i;
  31
  32         for (i = 0; i < ARRAY_SIZE(snd_dice_rates); i++) {
  33                 if (!(dice->clock_caps & BIT(i)))
  34                         continue;
  35                 if (snd_dice_rates[i] != rate)
  36                         continue;
  37
  38                 *mode = (i - 1) / 2;
  39                 return 0;
  40         }
  41         return -EINVAL;
  42 }
  43
  44 static void release_resources(struct snd_dice *dice,
  45                               struct fw_iso_resources *resources)
  46 {
  47         unsigned int channel;
  48
  49         /* Reset channel number */
  50         channel = cpu_to_be32((u32)-1);
  51         if (resources == &dice->tx_resources)
  52                 snd_dice_transaction_write_tx(dice, TX_ISOCHRONOUS,
  53                                               &channel, 4);
  54         else
  55                 snd_dice_transaction_write_rx(dice, RX_ISOCHRONOUS,
  56                                               &channel, 4);
  57
  58         fw_iso_resources_free(resources);
  59 }
  60
  61 static int keep_resources(struct snd_dice *dice,
  62                           struct fw_iso_resources *resources,
  63                           unsigned int max_payload_bytes)
  64 {
  65         unsigned int channel;
  66         int err;
  67
  68         err = fw_iso_resources_allocate(resources, max_payload_bytes,
  69                                 fw_parent_device(dice->unit)->max_speed);
  70         if (err < 0)
  71                 goto end;
  72
  73         /* Set channel number */
  74         channel = cpu_to_be32(resources->channel);
  75         if (resources == &dice->tx_resources)
  76                 err = snd_dice_transaction_write_tx(dice, TX_ISOCHRONOUS,
  77                                                     &channel, 4);
  78         else
  79                 err = snd_dice_transaction_write_rx(dice, RX_ISOCHRONOUS,
  80                                                     &channel, 4);
  81         if (err < 0)
  82                 release_resources(dice, resources);
  83 end:
  84         return err;
  85 }
  86
  87 static void stop_stream(struct snd_dice *dice, struct amdtp_stream *stream)
  88 {
  89         amdtp_stream_pcm_abort(stream);
  90         amdtp_stream_stop(stream);
  91
  92         if (stream == &dice->tx_stream)
  93                 release_resources(dice, &dice->tx_resources);
  94         else
  95                 release_resources(dice, &dice->rx_resources);
  96 }
  97
  98 static int start_stream(struct snd_dice *dice, struct amdtp_stream *stream,
  99                         unsigned int rate)
 100 {
 101         struct fw_iso_resources *resources;
 102         unsigned int i, mode, pcm_chs, midi_ports;
 103         int err;
 104
 105         err = snd_dice_stream_get_rate_mode(dice, rate, &mode);
 106         if (err < 0)
 107                 goto end;
 108         if (stream == &dice->tx_stream) {
 109                 resources = &dice->tx_resources;
 110                 pcm_chs = dice->tx_channels[mode];
 111                 midi_ports = dice->tx_midi_ports[mode];
 112         } else {
 113                 resources = &dice->rx_resources;
 114                 pcm_chs = dice->rx_channels[mode];
 115                 midi_ports = dice->rx_midi_ports[mode];
 116         }
 117
 118         /*
 119          * At 176.4/192.0 kHz, Dice has a quirk to transfer two PCM frames in
 120          * one data block of AMDTP packet. Thus sampling transfer frequency is
 121          * a half of PCM sampling frequency, i.e. PCM frames at 192.0 kHz are
 122          * transferred on AMDTP packets at 96 kHz. Two successive samples of a
 123          * channel are stored consecutively in the packet. This quirk is called
 124          * as 'Dual Wire'.
 125          * For this quirk, blocking mode is required and PCM buffer size should
 126          * be aligned to SYT_INTERVAL.
 127          */
 128         if (mode > 1) {
 129                 rate /= 2;
 130                 pcm_chs *= 2;
 131                 stream->double_pcm_frames = true;
 132         } else {
 133                 stream->double_pcm_frames = false;
 134         }
 135
 136         amdtp_stream_set_parameters(stream, rate, pcm_chs, midi_ports);
 137         if (mode > 1) {
 138                 pcm_chs /= 2;
 139
 140                 for (i = 0; i < pcm_chs; i++) {
 141                         stream->pcm_positions[i] = i * 2;
 142                         stream->pcm_positions[i + pcm_chs] = i * 2 + 1;
 143                 }
 144         }
 145
 146         err = keep_resources(dice, resources,
 147                              amdtp_stream_get_max_payload(stream));
 148         if (err < 0) {
 149                 dev_err(&dice->unit->device,
 150                         "fail to keep isochronous resources\n");
 151                 goto end;
 152         }
 153
 154         err = amdtp_stream_start(stream, resources->channel,
 155                                  fw_parent_device(dice->unit)->max_speed);
 156         if (err < 0)
 157                 release_resources(dice, resources);
 158 end:
 159         return err;
 160 }
 161
 162 static int get_sync_mode(struct snd_dice *dice, enum cip_flags *sync_mode)
 163 {
 164         u32 source;
 165         int err;
 166
 167         err = snd_dice_transaction_get_clock_source(dice, &source);
 168         if (err < 0)
 169                 goto end;
 170
 171         switch (source) {
 172         /* So-called 'SYT Match' modes, sync_to_syt value of packets received */
 173         case CLOCK_SOURCE_ARX4: /* in 4th stream */
 174         case CLOCK_SOURCE_ARX3: /* in 3rd stream */
 175         case CLOCK_SOURCE_ARX2: /* in 2nd stream */
 176                 err = -ENOSYS;
 177                 break;
 178         case CLOCK_SOURCE_ARX1: /* in 1st stream, which this driver uses */
 179                 *sync_mode = 0;
 180                 break;
 181         default:
 182                 *sync_mode = CIP_SYNC_TO_DEVICE;
 183                 break;
 184         }
 185 end:
 186         return err;
 187 }
 188
 189 int snd_dice_stream_start_duplex(struct snd_dice *dice, unsigned int rate)
 190 {
 191         struct amdtp_stream *master, *slave;
 192         unsigned int curr_rate;
 193         enum cip_flags sync_mode;
 194         int err = 0;
 195
 196         if (dice->substreams_counter == 0)
 197                 goto end;
 198
 199         err = get_sync_mode(dice, &sync_mode);
 200         if (err < 0)
 201                 goto end;
 202         if (sync_mode == CIP_SYNC_TO_DEVICE) {
 203                 master = &dice->tx_stream;
 204                 slave  = &dice->rx_stream;
 205         } else {
 206                 master = &dice->rx_stream;
 207                 slave  = &dice->tx_stream;
 208         }
 209
 210         /* Some packet queueing errors. */
 211         if (amdtp_streaming_error(master) || amdtp_streaming_error(slave))
 212                 stop_stream(dice, master);
 213
 214         /* Stop stream if rate is different. */
 215         err = snd_dice_transaction_get_rate(dice, &curr_rate);
 216         if (err < 0) {
 217                 dev_err(&dice->unit->device,
 218                         "fail to get sampling rate\n");
 219                 goto end;
 220         }
 221         if (rate == 0)
 222                 rate = curr_rate;
 223         if (rate != curr_rate)
 224                 stop_stream(dice, master);
 225
 226         if (!amdtp_stream_running(master)) {
 227                 stop_stream(dice, slave);
 228                 snd_dice_transaction_clear_enable(dice);
 229
 230                 amdtp_stream_set_sync(sync_mode, master, slave);
 231
 232                 err = snd_dice_transaction_set_rate(dice, rate);
 233                 if (err < 0) {
 234                         dev_err(&dice->unit->device,
 235                                 "fail to set sampling rate\n");
 236                         goto end;
 237                 }
 238
 239                 /* Start both streams. */
 240                 err = start_stream(dice, master, rate);
 241                 if (err < 0) {
 242                         dev_err(&dice->unit->device,
 243                                 "fail to start AMDTP master stream\n");
 244                         goto end;
 245                 }
 246                 err = start_stream(dice, slave, rate);
 247                 if (err < 0) {
 248                         dev_err(&dice->unit->device,
 249                                 "fail to start AMDTP slave stream\n");
 250                         stop_stream(dice, master);
 251                         goto end;
 252                 }
 253                 err = snd_dice_transaction_set_enable(dice);
 254                 if (err < 0) {
 255                         dev_err(&dice->unit->device,
 256                                 "fail to enable interface\n");
 257                         stop_stream(dice, master);
 258                         stop_stream(dice, slave);
 259                         goto end;
 260                 }
 261
 262                 /* Wait first callbacks */
 263                 if (!amdtp_stream_wait_callback(master, CALLBACK_TIMEOUT) ||
 264                     !amdtp_stream_wait_callback(slave, CALLBACK_TIMEOUT)) {
 265                         snd_dice_transaction_clear_enable(dice);
 266                         stop_stream(dice, master);
 267                         stop_stream(dice, slave);
 268                         err = -ETIMEDOUT;
 269                 }
 270         }
 271 end:
 272         return err;
 273 }
 274
 275 void snd_dice_stream_stop_duplex(struct snd_dice *dice)
 276 {
 277         if (dice->substreams_counter > 0)
 278                 return;
 279
 280         snd_dice_transaction_clear_enable(dice);
 281
 282         stop_stream(dice, &dice->tx_stream);
 283         stop_stream(dice, &dice->rx_stream);
 284 }
 285
 286 static int init_stream(struct snd_dice *dice, struct amdtp_stream *stream)
 287 {
 288         int err;
 289         struct fw_iso_resources *resources;
 290         enum amdtp_stream_direction dir;
 291
 292         if (stream == &dice->tx_stream) {
 293                 resources = &dice->tx_resources;
 294                 dir = AMDTP_IN_STREAM;
 295         } else {
 296                 resources = &dice->rx_resources;
 297                 dir = AMDTP_OUT_STREAM;
 298         }
 299
 300         err = fw_iso_resources_init(resources, dice->unit);
 301         if (err < 0)
 302                 goto end;
 303         resources->channels_mask = 0x00000000ffffffffuLL;
 304
 305         err = amdtp_stream_init(stream, dice->unit, dir, CIP_BLOCKING);
 306         if (err < 0) {
 307                 amdtp_stream_destroy(stream);
 308                 fw_iso_resources_destroy(resources);
 309         }
 310 end:
 311         return err;
 312 }
 313
 314 /*
 315  * This function should be called before starting streams or after stopping
 316  * streams.
 317  */
 318 static void destroy_stream(struct snd_dice *dice, struct amdtp_stream *stream)
 319 {
 320         struct fw_iso_resources *resources;
 321
 322         if (stream == &dice->tx_stream)
 323                 resources = &dice->tx_resources;
 324         else
 325                 resources = &dice->rx_resources;
 326
 327         amdtp_stream_destroy(stream);
 328         fw_iso_resources_destroy(resources);
 329 }
 330
 331 int snd_dice_stream_init_duplex(struct snd_dice *dice)
 332 {
 333         int err;
 334
 335         dice->substreams_counter = 0;
 336
 337         err = init_stream(dice, &dice->tx_stream);
 338         if (err < 0)
 339                 goto end;
 340
 341         err = init_stream(dice, &dice->rx_stream);
 342         if (err < 0)
 343                 destroy_stream(dice, &dice->tx_stream);
 344 end:
 345         return err;
 346 }
 347
 348 void snd_dice_stream_destroy_duplex(struct snd_dice *dice)
 349 {
 350         snd_dice_transaction_clear_enable(dice);
 351
 352         destroy_stream(dice, &dice->tx_stream);
 353         destroy_stream(dice, &dice->rx_stream);
 354
 355         dice->substreams_counter = 0;
 356 }
 357
 358 void snd_dice_stream_update_duplex(struct snd_dice *dice)
 359 {
 360         /*
 361          * On a bus reset, the DICE firmware disables streaming and then goes
 362          * off contemplating its own navel for hundreds of milliseconds before
 363          * it can react to any of our attempts to reenable streaming.  This
 364          * means that we lose synchronization anyway, so we force our streams
 365          * to stop so that the application can restart them in an orderly
 366          * manner.
 367          */
 368         dice->global_enabled = false;
 369
 370         stop_stream(dice, &dice->rx_stream);
 371         stop_stream(dice, &dice->tx_stream);
 372
 373         fw_iso_resources_update(&dice->rx_resources);
 374         fw_iso_resources_update(&dice->tx_resources);
 375 }
 376
 377 static void dice_lock_changed(struct snd_dice *dice)
 378 {
 379         dice->dev_lock_changed = true;
 380         wake_up(&dice->hwdep_wait);
 381 }
 382
 383 int snd_dice_stream_lock_try(struct snd_dice *dice)
 384 {
 385         int err;
 386
 387         spin_lock_irq(&dice->lock);
 388
 389         if (dice->dev_lock_count < 0) {
 390                 err = -EBUSY;
 391                 goto out;
 392         }
 393
 394         if (dice->dev_lock_count++ == 0)
 395                 dice_lock_changed(dice);
 396         err = 0;
 397 out:
 398         spin_unlock_irq(&dice->lock);
 399         return err;
 400 }
 401
 402 void snd_dice_stream_lock_release(struct snd_dice *dice)
 403 {
 404         spin_lock_irq(&dice->lock);
 405
 406         if (WARN_ON(dice->dev_lock_count <= 0))
 407                 goto out;
 408
 409         if (--dice->dev_lock_count == 0)
 410                 dice_lock_changed(dice);
 411 out:
 412         spin_unlock_irq(&dice->lock);
 413 }