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, ®, 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 85 static void finish_session(struct snd_motu *motu) 86 { 87 __be32 reg; 88 u32 data; 89 int err; 90 91 err = motu->spec->protocol->switch_fetching_mode(motu, false); 92 if (err < 0) 93 return; 94 95 amdtp_stream_stop(&motu->tx_stream); 96 amdtp_stream_stop(&motu->rx_stream); 97 98 err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, ®, 99 sizeof(reg)); 100 if (err < 0) 101 return; 102 data = be32_to_cpu(reg); 103 104 data &= ~(RX_ISOC_COMM_IS_ACTIVATED | TX_ISOC_COMM_IS_ACTIVATED); 105 data |= CHANGE_RX_ISOC_COMM_STATE | CHANGE_TX_ISOC_COMM_STATE; 106 107 reg = cpu_to_be32(data); 108 snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, ®, 109 sizeof(reg)); 110 } 111 112 static int start_isoc_ctx(struct snd_motu *motu, struct amdtp_stream *stream) 113 { 114 struct fw_iso_resources *resources; 115 int err; 116 117 if (stream == &motu->rx_stream) 118 resources = &motu->rx_resources; 119 else 120 resources = &motu->tx_resources; 121 122 err = amdtp_stream_start(stream, resources->channel, 123 fw_parent_device(motu->unit)->max_speed); 124 if (err < 0) 125 return err; 126 127 if (!amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT)) 128 return -ETIMEDOUT; 129 130 return 0; 131 } 132 133 int snd_motu_stream_cache_packet_formats(struct snd_motu *motu) 134 { 135 int err; 136 137 err = motu->spec->protocol->cache_packet_formats(motu); 138 if (err < 0) 139 return err; 140 141 if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) { 142 motu->tx_packet_formats.midi_flag_offset = 4; 143 motu->tx_packet_formats.midi_byte_offset = 6; 144 } else if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q) { 145 motu->tx_packet_formats.midi_flag_offset = 8; 146 motu->tx_packet_formats.midi_byte_offset = 7; 147 } 148 149 if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) { 150 motu->rx_packet_formats.midi_flag_offset = 4; 151 motu->rx_packet_formats.midi_byte_offset = 6; 152 } else if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) { 153 motu->rx_packet_formats.midi_flag_offset = 8; 154 motu->rx_packet_formats.midi_byte_offset = 7; 155 } 156 157 return 0; 158 } 159 160 int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate) 161 { 162 unsigned int curr_rate; 163 int err; 164 165 err = motu->spec->protocol->get_clock_rate(motu, &curr_rate); 166 if (err < 0) 167 return err; 168 if (rate == 0) 169 rate = curr_rate; 170 171 if (motu->substreams_counter == 0 || curr_rate != rate) { 172 finish_session(motu); 173 174 fw_iso_resources_free(&motu->tx_resources); 175 fw_iso_resources_free(&motu->rx_resources); 176 177 err = motu->spec->protocol->set_clock_rate(motu, rate); 178 if (err < 0) { 179 dev_err(&motu->unit->device, 180 "fail to set sampling rate: %d\n", err); 181 return err; 182 } 183 184 err = snd_motu_stream_cache_packet_formats(motu); 185 if (err < 0) 186 return err; 187 188 err = keep_resources(motu, rate, &motu->tx_stream); 189 if (err < 0) 190 return err; 191 192 err = keep_resources(motu, rate, &motu->rx_stream); 193 if (err < 0) { 194 fw_iso_resources_free(&motu->tx_resources); 195 return err; 196 } 197 } 198 199 return 0; 200 } 201 202 static int ensure_packet_formats(struct snd_motu *motu) 203 { 204 __be32 reg; 205 u32 data; 206 int err; 207 208 err = snd_motu_transaction_read(motu, PACKET_FORMAT_OFFSET, ®, 209 sizeof(reg)); 210 if (err < 0) 211 return err; 212 data = be32_to_cpu(reg); 213 214 data &= ~(TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS | 215 RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS| 216 TX_PACKET_TRANSMISSION_SPEED_MASK); 217 if (motu->tx_packet_formats.differed_part_pcm_chunks[0] == 0) 218 data |= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS; 219 if (motu->rx_packet_formats.differed_part_pcm_chunks[0] == 0) 220 data |= RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS; 221 data |= fw_parent_device(motu->unit)->max_speed; 222 223 reg = cpu_to_be32(data); 224 return snd_motu_transaction_write(motu, PACKET_FORMAT_OFFSET, ®, 225 sizeof(reg)); 226 } 227 228 int snd_motu_stream_start_duplex(struct snd_motu *motu) 229 { 230 unsigned int generation = motu->rx_resources.generation; 231 int err = 0; 232 233 if (motu->substreams_counter == 0) 234 return 0; 235 236 if (amdtp_streaming_error(&motu->rx_stream) || 237 amdtp_streaming_error(&motu->tx_stream)) 238 finish_session(motu); 239 240 if (generation != fw_parent_device(motu->unit)->card->generation) { 241 err = fw_iso_resources_update(&motu->rx_resources); 242 if (err < 0) 243 return err; 244 245 err = fw_iso_resources_update(&motu->tx_resources); 246 if (err < 0) 247 return err; 248 } 249 250 if (!amdtp_stream_running(&motu->rx_stream)) { 251 err = ensure_packet_formats(motu); 252 if (err < 0) 253 return err; 254 255 err = begin_session(motu); 256 if (err < 0) { 257 dev_err(&motu->unit->device, 258 "fail to start isochronous comm: %d\n", err); 259 goto stop_streams; 260 } 261 262 err = start_isoc_ctx(motu, &motu->rx_stream); 263 if (err < 0) { 264 dev_err(&motu->unit->device, 265 "fail to start IT context: %d\n", err); 266 goto stop_streams; 267 } 268 269 err = motu->spec->protocol->switch_fetching_mode(motu, true); 270 if (err < 0) { 271 dev_err(&motu->unit->device, 272 "fail to enable frame fetching: %d\n", err); 273 goto stop_streams; 274 } 275 } 276 277 if (!amdtp_stream_running(&motu->tx_stream)) { 278 err = start_isoc_ctx(motu, &motu->tx_stream); 279 if (err < 0) { 280 dev_err(&motu->unit->device, 281 "fail to start IR context: %d", err); 282 goto stop_streams; 283 } 284 } 285 286 return 0; 287 288 stop_streams: 289 finish_session(motu); 290 return err; 291 } 292 293 void snd_motu_stream_stop_duplex(struct snd_motu *motu) 294 { 295 if (motu->substreams_counter == 0) { 296 finish_session(motu); 297 298 fw_iso_resources_free(&motu->tx_resources); 299 fw_iso_resources_free(&motu->rx_resources); 300 } 301 } 302 303 static int init_stream(struct snd_motu *motu, enum amdtp_stream_direction dir) 304 { 305 int err; 306 struct amdtp_stream *stream; 307 struct fw_iso_resources *resources; 308 309 if (dir == AMDTP_IN_STREAM) { 310 stream = &motu->tx_stream; 311 resources = &motu->tx_resources; 312 } else { 313 stream = &motu->rx_stream; 314 resources = &motu->rx_resources; 315 } 316 317 err = fw_iso_resources_init(resources, motu->unit); 318 if (err < 0) 319 return err; 320 321 err = amdtp_motu_init(stream, motu->unit, dir, motu->spec->protocol); 322 if (err < 0) { 323 amdtp_stream_destroy(stream); 324 fw_iso_resources_destroy(resources); 325 } 326 327 return err; 328 } 329 330 static void destroy_stream(struct snd_motu *motu, 331 enum amdtp_stream_direction dir) 332 { 333 struct amdtp_stream *stream; 334 struct fw_iso_resources *resources; 335 336 if (dir == AMDTP_IN_STREAM) { 337 stream = &motu->tx_stream; 338 resources = &motu->tx_resources; 339 } else { 340 stream = &motu->rx_stream; 341 resources = &motu->rx_resources; 342 } 343 344 amdtp_stream_destroy(stream); 345 fw_iso_resources_destroy(resources); 346 } 347 348 int snd_motu_stream_init_duplex(struct snd_motu *motu) 349 { 350 int err; 351 352 err = init_stream(motu, AMDTP_IN_STREAM); 353 if (err < 0) 354 return err; 355 356 err = init_stream(motu, AMDTP_OUT_STREAM); 357 if (err < 0) 358 destroy_stream(motu, AMDTP_IN_STREAM); 359 360 return err; 361 } 362 363 /* 364 * This function should be called before starting streams or after stopping 365 * streams. 366 */ 367 void snd_motu_stream_destroy_duplex(struct snd_motu *motu) 368 { 369 destroy_stream(motu, AMDTP_IN_STREAM); 370 destroy_stream(motu, AMDTP_OUT_STREAM); 371 372 motu->substreams_counter = 0; 373 } 374 375 static void motu_lock_changed(struct snd_motu *motu) 376 { 377 motu->dev_lock_changed = true; 378 wake_up(&motu->hwdep_wait); 379 } 380 381 int snd_motu_stream_lock_try(struct snd_motu *motu) 382 { 383 int err; 384 385 spin_lock_irq(&motu->lock); 386 387 if (motu->dev_lock_count < 0) { 388 err = -EBUSY; 389 goto out; 390 } 391 392 if (motu->dev_lock_count++ == 0) 393 motu_lock_changed(motu); 394 err = 0; 395 out: 396 spin_unlock_irq(&motu->lock); 397 return err; 398 } 399 400 void snd_motu_stream_lock_release(struct snd_motu *motu) 401 { 402 spin_lock_irq(&motu->lock); 403 404 if (WARN_ON(motu->dev_lock_count <= 0)) 405 goto out; 406 407 if (--motu->dev_lock_count == 0) 408 motu_lock_changed(motu); 409 out: 410 spin_unlock_irq(&motu->lock); 411 } 412