sound/firewire/motu/motu-stream.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * motu-stream.c - a part of driver for MOTU FireWire series
   4  *
   5  * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
   6  */
   7
   8 #include "motu.h"
   9
  10 #define CALLBACK_TIMEOUT        200
  11
  12 #define ISOC_COMM_CONTROL_OFFSET                0x0b00
  13 #define  ISOC_COMM_CONTROL_MASK                 0xffff0000
  14 #define  CHANGE_RX_ISOC_COMM_STATE              0x80000000
  15 #define  RX_ISOC_COMM_IS_ACTIVATED              0x40000000
  16 #define  RX_ISOC_COMM_CHANNEL_MASK              0x3f000000
  17 #define  RX_ISOC_COMM_CHANNEL_SHIFT             24
  18 #define  CHANGE_TX_ISOC_COMM_STATE              0x00800000
  19 #define  TX_ISOC_COMM_IS_ACTIVATED              0x00400000
  20 #define  TX_ISOC_COMM_CHANNEL_MASK              0x003f0000
  21 #define  TX_ISOC_COMM_CHANNEL_SHIFT             16
  22
  23 #define PACKET_FORMAT_OFFSET                    0x0b10
  24 #define  TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS 0x00000080
  25 #define  RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS 0x00000040
  26 #define  TX_PACKET_TRANSMISSION_SPEED_MASK      0x0000000f
  27
  28 static int keep_resources(struct snd_motu *motu, unsigned int rate,
  29                           struct amdtp_stream *stream)
  30 {
  31         struct fw_iso_resources *resources;
  32         struct snd_motu_packet_format *packet_format;
  33         unsigned int midi_ports = 0;
  34         int err;
  35
  36         if (stream == &motu->rx_stream) {
  37                 resources = &motu->rx_resources;
  38                 packet_format = &motu->rx_packet_formats;
  39
  40                 if ((motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) ||
  41                     (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q))
  42                         midi_ports = 1;
  43         } else {
  44                 resources = &motu->tx_resources;
  45                 packet_format = &motu->tx_packet_formats;
  46
  47                 if ((motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) ||
  48                     (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q))
  49                         midi_ports = 1;
  50         }
  51
  52         err = amdtp_motu_set_parameters(stream, rate, midi_ports,
  53                                         packet_format);
  54         if (err < 0)
  55                 return err;
  56
  57         return fw_iso_resources_allocate(resources,
  58                                 amdtp_stream_get_max_payload(stream),
  59                                 fw_parent_device(motu->unit)->max_speed);
  60 }
  61
  62 static int begin_session(struct snd_motu *motu)
  63 {
  64         __be32 reg;
  65         u32 data;
  66         int err;
  67
  68         // Configure the unit to start isochronous communication.
  69         err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
  70                                         sizeof(reg));
  71         if (err < 0)
  72                 return err;
  73         data = be32_to_cpu(reg) & ~ISOC_COMM_CONTROL_MASK;
  74
  75         data |= CHANGE_RX_ISOC_COMM_STATE | RX_ISOC_COMM_IS_ACTIVATED |
  76                 (motu->rx_resources.channel << RX_ISOC_COMM_CHANNEL_SHIFT) |
  77                 CHANGE_TX_ISOC_COMM_STATE | TX_ISOC_COMM_IS_ACTIVATED |
  78                 (motu->tx_resources.channel << TX_ISOC_COMM_CHANNEL_SHIFT);
  79
  80         reg = cpu_to_be32(data);
  81         return snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
  82                                           sizeof(reg));
  83 }
  84
  85 static void finish_session(struct snd_motu *motu)
  86 {
  87         __be32 reg;
  88         u32 data;
  89         int err;
  90
  91         err = snd_motu_protocol_switch_fetching_mode(motu, false);
  92         if (err < 0)
  93                 return;
  94
  95         err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
  96                                         sizeof(reg));
  97         if (err < 0)
  98                 return;
  99         data = be32_to_cpu(reg);
 100
 101         data &= ~(RX_ISOC_COMM_IS_ACTIVATED | TX_ISOC_COMM_IS_ACTIVATED);
 102         data |= CHANGE_RX_ISOC_COMM_STATE | CHANGE_TX_ISOC_COMM_STATE;
 103
 104         reg = cpu_to_be32(data);
 105         snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
 106                                    sizeof(reg));
 107 }
 108
 109 int snd_motu_stream_cache_packet_formats(struct snd_motu *motu)
 110 {
 111         int err;
 112
 113         err = snd_motu_protocol_cache_packet_formats(motu);
 114         if (err < 0)
 115                 return err;
 116
 117         if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) {
 118                 motu->tx_packet_formats.midi_flag_offset = 4;
 119                 motu->tx_packet_formats.midi_byte_offset = 6;
 120         } else if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q) {
 121                 motu->tx_packet_formats.midi_flag_offset = 8;
 122                 motu->tx_packet_formats.midi_byte_offset = 7;
 123         }
 124
 125         if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) {
 126                 motu->rx_packet_formats.midi_flag_offset = 4;
 127                 motu->rx_packet_formats.midi_byte_offset = 6;
 128         } else if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) {
 129                 motu->rx_packet_formats.midi_flag_offset = 8;
 130                 motu->rx_packet_formats.midi_byte_offset = 7;
 131         }
 132
 133         return 0;
 134 }
 135
 136 int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate,
 137                                    unsigned int frames_per_period,
 138                                    unsigned int frames_per_buffer)
 139 {
 140         unsigned int curr_rate;
 141         int err;
 142
 143         err = snd_motu_protocol_get_clock_rate(motu, &curr_rate);
 144         if (err < 0)
 145                 return err;
 146         if (rate == 0)
 147                 rate = curr_rate;
 148
 149         if (motu->substreams_counter == 0 || curr_rate != rate) {
 150                 amdtp_domain_stop(&motu->domain);
 151                 finish_session(motu);
 152
 153                 fw_iso_resources_free(&motu->tx_resources);
 154                 fw_iso_resources_free(&motu->rx_resources);
 155
 156                 err = snd_motu_protocol_set_clock_rate(motu, rate);
 157                 if (err < 0) {
 158                         dev_err(&motu->unit->device,
 159                                 "fail to set sampling rate: %d\n", err);
 160                         return err;
 161                 }
 162
 163                 err = snd_motu_stream_cache_packet_formats(motu);
 164                 if (err < 0)
 165                         return err;
 166
 167                 err = keep_resources(motu, rate, &motu->tx_stream);
 168                 if (err < 0)
 169                         return err;
 170
 171                 err = keep_resources(motu, rate, &motu->rx_stream);
 172                 if (err < 0) {
 173                         fw_iso_resources_free(&motu->tx_resources);
 174                         return err;
 175                 }
 176
 177                 err = amdtp_domain_set_events_per_period(&motu->domain,
 178                                         frames_per_period, frames_per_buffer);
 179                 if (err < 0) {
 180                         fw_iso_resources_free(&motu->tx_resources);
 181                         fw_iso_resources_free(&motu->rx_resources);
 182                         return err;
 183                 }
 184         }
 185
 186         return 0;
 187 }
 188
 189 static int ensure_packet_formats(struct snd_motu *motu)
 190 {
 191         __be32 reg;
 192         u32 data;
 193         int err;
 194
 195         err = snd_motu_transaction_read(motu, PACKET_FORMAT_OFFSET, &reg,
 196                                         sizeof(reg));
 197         if (err < 0)
 198                 return err;
 199         data = be32_to_cpu(reg);
 200
 201         data &= ~(TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS |
 202                   RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS|
 203                   TX_PACKET_TRANSMISSION_SPEED_MASK);
 204         if (motu->spec->tx_fixed_pcm_chunks[0] == motu->tx_packet_formats.pcm_chunks[0])
 205                 data |= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
 206         if (motu->spec->rx_fixed_pcm_chunks[0] == motu->rx_packet_formats.pcm_chunks[0])
 207                 data |= RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
 208         data |= fw_parent_device(motu->unit)->max_speed;
 209
 210         reg = cpu_to_be32(data);
 211         return snd_motu_transaction_write(motu, PACKET_FORMAT_OFFSET, &reg,
 212                                           sizeof(reg));
 213 }
 214
 215 int snd_motu_stream_start_duplex(struct snd_motu *motu)
 216 {
 217         unsigned int generation = motu->rx_resources.generation;
 218         int err = 0;
 219
 220         if (motu->substreams_counter == 0)
 221                 return 0;
 222
 223         if (amdtp_streaming_error(&motu->rx_stream) ||
 224             amdtp_streaming_error(&motu->tx_stream)) {
 225                 amdtp_domain_stop(&motu->domain);
 226                 finish_session(motu);
 227         }
 228
 229         if (generation != fw_parent_device(motu->unit)->card->generation) {
 230                 err = fw_iso_resources_update(&motu->rx_resources);
 231                 if (err < 0)
 232                         return err;
 233
 234                 err = fw_iso_resources_update(&motu->tx_resources);
 235                 if (err < 0)
 236                         return err;
 237         }
 238
 239         if (!amdtp_stream_running(&motu->rx_stream)) {
 240                 int spd = fw_parent_device(motu->unit)->max_speed;
 241
 242                 err = ensure_packet_formats(motu);
 243                 if (err < 0)
 244                         return err;
 245
 246                 err = begin_session(motu);
 247                 if (err < 0) {
 248                         dev_err(&motu->unit->device,
 249                                 "fail to start isochronous comm: %d\n", err);
 250                         goto stop_streams;
 251                 }
 252
 253                 err = amdtp_domain_add_stream(&motu->domain, &motu->tx_stream,
 254                                               motu->tx_resources.channel, spd);
 255                 if (err < 0)
 256                         goto stop_streams;
 257
 258                 err = amdtp_domain_add_stream(&motu->domain, &motu->rx_stream,
 259                                               motu->rx_resources.channel, spd);
 260                 if (err < 0)
 261                         goto stop_streams;
 262
 263                 err = amdtp_domain_start(&motu->domain, 0);
 264                 if (err < 0)
 265                         goto stop_streams;
 266
 267                 if (!amdtp_stream_wait_callback(&motu->tx_stream,
 268                                                 CALLBACK_TIMEOUT) ||
 269                     !amdtp_stream_wait_callback(&motu->rx_stream,
 270                                                 CALLBACK_TIMEOUT)) {
 271                         err = -ETIMEDOUT;
 272                         goto stop_streams;
 273                 }
 274
 275                 err = snd_motu_protocol_switch_fetching_mode(motu, true);
 276                 if (err < 0) {
 277                         dev_err(&motu->unit->device,
 278                                 "fail to enable frame fetching: %d\n", err);
 279                         goto stop_streams;
 280                 }
 281         }
 282
 283         return 0;
 284
 285 stop_streams:
 286         amdtp_domain_stop(&motu->domain);
 287         finish_session(motu);
 288         return err;
 289 }
 290
 291 void snd_motu_stream_stop_duplex(struct snd_motu *motu)
 292 {
 293         if (motu->substreams_counter == 0) {
 294                 amdtp_domain_stop(&motu->domain);
 295                 finish_session(motu);
 296
 297                 fw_iso_resources_free(&motu->tx_resources);
 298                 fw_iso_resources_free(&motu->rx_resources);
 299         }
 300 }
 301
 302 static int init_stream(struct snd_motu *motu, struct amdtp_stream *s)
 303 {
 304         struct fw_iso_resources *resources;
 305         enum amdtp_stream_direction dir;
 306         int err;
 307
 308         if (s == &motu->tx_stream) {
 309                 resources = &motu->tx_resources;
 310                 dir = AMDTP_IN_STREAM;
 311         } else {
 312                 resources = &motu->rx_resources;
 313                 dir = AMDTP_OUT_STREAM;
 314         }
 315
 316         err = fw_iso_resources_init(resources, motu->unit);
 317         if (err < 0)
 318                 return err;
 319
 320         err = amdtp_motu_init(s, motu->unit, dir, motu->spec);
 321         if (err < 0)
 322                 fw_iso_resources_destroy(resources);
 323
 324         return err;
 325 }
 326
 327 static void destroy_stream(struct snd_motu *motu, struct amdtp_stream *s)
 328 {
 329         amdtp_stream_destroy(s);
 330
 331         if (s == &motu->tx_stream)
 332                 fw_iso_resources_destroy(&motu->tx_resources);
 333         else
 334                 fw_iso_resources_destroy(&motu->rx_resources);
 335 }
 336
 337 int snd_motu_stream_init_duplex(struct snd_motu *motu)
 338 {
 339         int err;
 340
 341         err = init_stream(motu, &motu->tx_stream);
 342         if (err < 0)
 343                 return err;
 344
 345         err = init_stream(motu, &motu->rx_stream);
 346         if (err < 0) {
 347                 destroy_stream(motu, &motu->tx_stream);
 348                 return err;
 349         }
 350
 351         err = amdtp_domain_init(&motu->domain);
 352         if (err < 0) {
 353                 destroy_stream(motu, &motu->tx_stream);
 354                 destroy_stream(motu, &motu->rx_stream);
 355         }
 356
 357         return err;
 358 }
 359
 360 // This function should be called before starting streams or after stopping
 361 // streams.
 362 void snd_motu_stream_destroy_duplex(struct snd_motu *motu)
 363 {
 364         amdtp_domain_destroy(&motu->domain);
 365
 366         destroy_stream(motu, &motu->rx_stream);
 367         destroy_stream(motu, &motu->tx_stream);
 368
 369         motu->substreams_counter = 0;
 370 }
 371
 372 static void motu_lock_changed(struct snd_motu *motu)
 373 {
 374         motu->dev_lock_changed = true;
 375         wake_up(&motu->hwdep_wait);
 376 }
 377
 378 int snd_motu_stream_lock_try(struct snd_motu *motu)
 379 {
 380         int err;
 381
 382         spin_lock_irq(&motu->lock);
 383
 384         if (motu->dev_lock_count < 0) {
 385                 err = -EBUSY;
 386                 goto out;
 387         }
 388
 389         if (motu->dev_lock_count++ == 0)
 390                 motu_lock_changed(motu);
 391         err = 0;
 392 out:
 393         spin_unlock_irq(&motu->lock);
 394         return err;
 395 }
 396
 397 void snd_motu_stream_lock_release(struct snd_motu *motu)
 398 {
 399         spin_lock_irq(&motu->lock);
 400
 401         if (WARN_ON(motu->dev_lock_count <= 0))
 402                 goto out;
 403
 404         if (--motu->dev_lock_count == 0)
 405                 motu_lock_changed(motu);
 406 out:
 407         spin_unlock_irq(&motu->lock);
 408 }