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 READY_TIMEOUT_MS 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 keep_resources(struct snd_motu * motu,unsigned int rate,struct amdtp_stream * stream)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 begin_session(struct snd_motu * motu)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, ®, 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, ®, 82 sizeof(reg)); 83 } 84 finish_session(struct snd_motu * motu)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, ®, 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, ®, 106 sizeof(reg)); 107 } 108 snd_motu_stream_cache_packet_formats(struct snd_motu * motu)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 snd_motu_stream_reserve_duplex(struct snd_motu * motu,unsigned int rate,unsigned int frames_per_period,unsigned int frames_per_buffer)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 kfree(motu->cache.event_offsets); 157 motu->cache.event_offsets = NULL; 158 159 err = snd_motu_protocol_set_clock_rate(motu, rate); 160 if (err < 0) { 161 dev_err(&motu->unit->device, 162 "fail to set sampling rate: %d\n", err); 163 return err; 164 } 165 166 err = snd_motu_stream_cache_packet_formats(motu); 167 if (err < 0) 168 return err; 169 170 err = keep_resources(motu, rate, &motu->tx_stream); 171 if (err < 0) 172 return err; 173 174 err = keep_resources(motu, rate, &motu->rx_stream); 175 if (err < 0) { 176 fw_iso_resources_free(&motu->tx_resources); 177 return err; 178 } 179 180 err = amdtp_domain_set_events_per_period(&motu->domain, 181 frames_per_period, frames_per_buffer); 182 if (err < 0) { 183 fw_iso_resources_free(&motu->tx_resources); 184 fw_iso_resources_free(&motu->rx_resources); 185 return err; 186 } 187 188 motu->cache.size = motu->tx_stream.syt_interval * frames_per_buffer; 189 motu->cache.event_offsets = kcalloc(motu->cache.size, sizeof(*motu->cache.event_offsets), 190 GFP_KERNEL); 191 if (!motu->cache.event_offsets) { 192 fw_iso_resources_free(&motu->tx_resources); 193 fw_iso_resources_free(&motu->rx_resources); 194 return -ENOMEM; 195 } 196 } 197 198 return 0; 199 } 200 ensure_packet_formats(struct snd_motu * motu)201 static int ensure_packet_formats(struct snd_motu *motu) 202 { 203 __be32 reg; 204 u32 data; 205 int err; 206 207 err = snd_motu_transaction_read(motu, PACKET_FORMAT_OFFSET, ®, 208 sizeof(reg)); 209 if (err < 0) 210 return err; 211 data = be32_to_cpu(reg); 212 213 data &= ~(TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS | 214 RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS| 215 TX_PACKET_TRANSMISSION_SPEED_MASK); 216 if (motu->spec->tx_fixed_pcm_chunks[0] == motu->tx_packet_formats.pcm_chunks[0]) 217 data |= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS; 218 if (motu->spec->rx_fixed_pcm_chunks[0] == motu->rx_packet_formats.pcm_chunks[0]) 219 data |= RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS; 220 data |= fw_parent_device(motu->unit)->max_speed; 221 222 reg = cpu_to_be32(data); 223 return snd_motu_transaction_write(motu, PACKET_FORMAT_OFFSET, ®, 224 sizeof(reg)); 225 } 226 snd_motu_stream_start_duplex(struct snd_motu * motu)227 int snd_motu_stream_start_duplex(struct snd_motu *motu) 228 { 229 unsigned int generation = motu->rx_resources.generation; 230 int err = 0; 231 232 if (motu->substreams_counter == 0) 233 return 0; 234 235 if (amdtp_streaming_error(&motu->rx_stream) || 236 amdtp_streaming_error(&motu->tx_stream)) { 237 amdtp_domain_stop(&motu->domain); 238 finish_session(motu); 239 } 240 241 if (generation != fw_parent_device(motu->unit)->card->generation) { 242 err = fw_iso_resources_update(&motu->rx_resources); 243 if (err < 0) 244 return err; 245 246 err = fw_iso_resources_update(&motu->tx_resources); 247 if (err < 0) 248 return err; 249 } 250 251 if (!amdtp_stream_running(&motu->rx_stream)) { 252 int spd = fw_parent_device(motu->unit)->max_speed; 253 254 err = ensure_packet_formats(motu); 255 if (err < 0) 256 return err; 257 258 if (motu->spec->flags & SND_MOTU_SPEC_REGISTER_DSP) { 259 err = snd_motu_register_dsp_message_parser_init(motu); 260 if (err < 0) 261 return err; 262 } else if (motu->spec->flags & SND_MOTU_SPEC_COMMAND_DSP) { 263 err = snd_motu_command_dsp_message_parser_init(motu, motu->tx_stream.sfc); 264 if (err < 0) 265 return err; 266 } 267 268 err = begin_session(motu); 269 if (err < 0) { 270 dev_err(&motu->unit->device, 271 "fail to start isochronous comm: %d\n", err); 272 goto stop_streams; 273 } 274 275 err = amdtp_domain_add_stream(&motu->domain, &motu->tx_stream, 276 motu->tx_resources.channel, spd); 277 if (err < 0) 278 goto stop_streams; 279 280 err = amdtp_domain_add_stream(&motu->domain, &motu->rx_stream, 281 motu->rx_resources.channel, spd); 282 if (err < 0) 283 goto stop_streams; 284 285 motu->cache.tail = 0; 286 motu->cache.tx_cycle_count = UINT_MAX; 287 motu->cache.head = 0; 288 motu->cache.rx_cycle_count = UINT_MAX; 289 290 // NOTE: The device requires both of replay; the sequence of the number of data 291 // blocks per packet, and the sequence of source packet header per data block as 292 // presentation time. 293 err = amdtp_domain_start(&motu->domain, 0, true, false); 294 if (err < 0) 295 goto stop_streams; 296 297 if (!amdtp_domain_wait_ready(&motu->domain, READY_TIMEOUT_MS)) { 298 err = -ETIMEDOUT; 299 goto stop_streams; 300 } 301 302 err = snd_motu_protocol_switch_fetching_mode(motu, true); 303 if (err < 0) { 304 dev_err(&motu->unit->device, 305 "fail to enable frame fetching: %d\n", err); 306 goto stop_streams; 307 } 308 } 309 310 return 0; 311 312 stop_streams: 313 amdtp_domain_stop(&motu->domain); 314 finish_session(motu); 315 return err; 316 } 317 snd_motu_stream_stop_duplex(struct snd_motu * motu)318 void snd_motu_stream_stop_duplex(struct snd_motu *motu) 319 { 320 if (motu->substreams_counter == 0) { 321 amdtp_domain_stop(&motu->domain); 322 finish_session(motu); 323 324 fw_iso_resources_free(&motu->tx_resources); 325 fw_iso_resources_free(&motu->rx_resources); 326 327 kfree(motu->cache.event_offsets); 328 motu->cache.event_offsets = NULL; 329 } 330 } 331 init_stream(struct snd_motu * motu,struct amdtp_stream * s)332 static int init_stream(struct snd_motu *motu, struct amdtp_stream *s) 333 { 334 struct fw_iso_resources *resources; 335 enum amdtp_stream_direction dir; 336 int err; 337 338 if (s == &motu->tx_stream) { 339 resources = &motu->tx_resources; 340 dir = AMDTP_IN_STREAM; 341 } else { 342 resources = &motu->rx_resources; 343 dir = AMDTP_OUT_STREAM; 344 } 345 346 err = fw_iso_resources_init(resources, motu->unit); 347 if (err < 0) 348 return err; 349 350 err = amdtp_motu_init(s, motu->unit, dir, motu->spec, &motu->cache); 351 if (err < 0) 352 fw_iso_resources_destroy(resources); 353 354 return err; 355 } 356 destroy_stream(struct snd_motu * motu,struct amdtp_stream * s)357 static void destroy_stream(struct snd_motu *motu, struct amdtp_stream *s) 358 { 359 amdtp_stream_destroy(s); 360 361 if (s == &motu->tx_stream) 362 fw_iso_resources_destroy(&motu->tx_resources); 363 else 364 fw_iso_resources_destroy(&motu->rx_resources); 365 } 366 snd_motu_stream_init_duplex(struct snd_motu * motu)367 int snd_motu_stream_init_duplex(struct snd_motu *motu) 368 { 369 int err; 370 371 err = init_stream(motu, &motu->tx_stream); 372 if (err < 0) 373 return err; 374 375 err = init_stream(motu, &motu->rx_stream); 376 if (err < 0) { 377 destroy_stream(motu, &motu->tx_stream); 378 return err; 379 } 380 381 err = amdtp_domain_init(&motu->domain); 382 if (err < 0) { 383 destroy_stream(motu, &motu->tx_stream); 384 destroy_stream(motu, &motu->rx_stream); 385 } 386 387 return err; 388 } 389 390 // This function should be called before starting streams or after stopping 391 // streams. snd_motu_stream_destroy_duplex(struct snd_motu * motu)392 void snd_motu_stream_destroy_duplex(struct snd_motu *motu) 393 { 394 amdtp_domain_destroy(&motu->domain); 395 396 destroy_stream(motu, &motu->rx_stream); 397 destroy_stream(motu, &motu->tx_stream); 398 399 motu->substreams_counter = 0; 400 } 401 motu_lock_changed(struct snd_motu * motu)402 static void motu_lock_changed(struct snd_motu *motu) 403 { 404 motu->dev_lock_changed = true; 405 wake_up(&motu->hwdep_wait); 406 } 407 snd_motu_stream_lock_try(struct snd_motu * motu)408 int snd_motu_stream_lock_try(struct snd_motu *motu) 409 { 410 int err; 411 412 spin_lock_irq(&motu->lock); 413 414 if (motu->dev_lock_count < 0) { 415 err = -EBUSY; 416 goto out; 417 } 418 419 if (motu->dev_lock_count++ == 0) 420 motu_lock_changed(motu); 421 err = 0; 422 out: 423 spin_unlock_irq(&motu->lock); 424 return err; 425 } 426 snd_motu_stream_lock_release(struct snd_motu * motu)427 void snd_motu_stream_lock_release(struct snd_motu *motu) 428 { 429 spin_lock_irq(&motu->lock); 430 431 if (WARN_ON(motu->dev_lock_count <= 0)) 432 goto out; 433 434 if (--motu->dev_lock_count == 0) 435 motu_lock_changed(motu); 436 out: 437 spin_unlock_irq(&motu->lock); 438 } 439