1 /* 2 * fireworks_stream.c - a part of driver for Fireworks based devices 3 * 4 * Copyright (c) 2013-2014 Takashi Sakamoto 5 * 6 * Licensed under the terms of the GNU General Public License, version 2. 7 */ 8 #include "./fireworks.h" 9 10 #define CALLBACK_TIMEOUT 100 11 12 static int 13 init_stream(struct snd_efw *efw, struct amdtp_stream *stream) 14 { 15 struct cmp_connection *conn; 16 enum cmp_direction c_dir; 17 enum amdtp_stream_direction s_dir; 18 int err; 19 20 if (stream == &efw->tx_stream) { 21 conn = &efw->out_conn; 22 c_dir = CMP_OUTPUT; 23 s_dir = AMDTP_IN_STREAM; 24 } else { 25 conn = &efw->in_conn; 26 c_dir = CMP_INPUT; 27 s_dir = AMDTP_OUT_STREAM; 28 } 29 30 err = cmp_connection_init(conn, efw->unit, c_dir, 0); 31 if (err < 0) 32 goto end; 33 34 err = amdtp_stream_init(stream, efw->unit, s_dir, CIP_BLOCKING); 35 if (err < 0) { 36 amdtp_stream_destroy(stream); 37 cmp_connection_destroy(conn); 38 } 39 end: 40 return err; 41 } 42 43 static void 44 stop_stream(struct snd_efw *efw, struct amdtp_stream *stream) 45 { 46 amdtp_stream_pcm_abort(stream); 47 amdtp_stream_stop(stream); 48 49 if (stream == &efw->tx_stream) 50 cmp_connection_break(&efw->out_conn); 51 else 52 cmp_connection_break(&efw->in_conn); 53 } 54 55 static int 56 start_stream(struct snd_efw *efw, struct amdtp_stream *stream, 57 unsigned int sampling_rate) 58 { 59 struct cmp_connection *conn; 60 unsigned int mode, pcm_channels, midi_ports; 61 int err; 62 63 err = snd_efw_get_multiplier_mode(sampling_rate, &mode); 64 if (err < 0) 65 goto end; 66 if (stream == &efw->tx_stream) { 67 conn = &efw->out_conn; 68 pcm_channels = efw->pcm_capture_channels[mode]; 69 midi_ports = efw->midi_out_ports; 70 } else { 71 conn = &efw->in_conn; 72 pcm_channels = efw->pcm_playback_channels[mode]; 73 midi_ports = efw->midi_in_ports; 74 } 75 76 amdtp_stream_set_parameters(stream, sampling_rate, 77 pcm_channels, midi_ports); 78 79 /* establish connection via CMP */ 80 err = cmp_connection_establish(conn, 81 amdtp_stream_get_max_payload(stream)); 82 if (err < 0) 83 goto end; 84 85 /* start amdtp stream */ 86 err = amdtp_stream_start(stream, 87 conn->resources.channel, 88 conn->speed); 89 if (err < 0) { 90 stop_stream(efw, stream); 91 goto end; 92 } 93 94 /* wait first callback */ 95 if (!amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT)) { 96 stop_stream(efw, stream); 97 err = -ETIMEDOUT; 98 } 99 end: 100 return err; 101 } 102 103 /* 104 * This function should be called before starting the stream or after stopping 105 * the streams. 106 */ 107 static void 108 destroy_stream(struct snd_efw *efw, struct amdtp_stream *stream) 109 { 110 struct cmp_connection *conn; 111 112 if (stream == &efw->tx_stream) 113 conn = &efw->out_conn; 114 else 115 conn = &efw->in_conn; 116 117 amdtp_stream_destroy(stream); 118 cmp_connection_destroy(&efw->out_conn); 119 } 120 121 static int 122 get_sync_mode(struct snd_efw *efw, enum cip_flags *sync_mode) 123 { 124 enum snd_efw_clock_source clock_source; 125 int err; 126 127 err = snd_efw_command_get_clock_source(efw, &clock_source); 128 if (err < 0) 129 return err; 130 131 if (clock_source == SND_EFW_CLOCK_SOURCE_SYTMATCH) 132 return -ENOSYS; 133 134 *sync_mode = CIP_SYNC_TO_DEVICE; 135 return 0; 136 } 137 138 static int 139 check_connection_used_by_others(struct snd_efw *efw, struct amdtp_stream *s) 140 { 141 struct cmp_connection *conn; 142 bool used; 143 int err; 144 145 if (s == &efw->tx_stream) 146 conn = &efw->out_conn; 147 else 148 conn = &efw->in_conn; 149 150 err = cmp_connection_check_used(conn, &used); 151 if ((err >= 0) && used && !amdtp_stream_running(s)) { 152 dev_err(&efw->unit->device, 153 "Connection established by others: %cPCR[%d]\n", 154 (conn->direction == CMP_OUTPUT) ? 'o' : 'i', 155 conn->pcr_index); 156 err = -EBUSY; 157 } 158 159 return err; 160 } 161 162 int snd_efw_stream_init_duplex(struct snd_efw *efw) 163 { 164 int err; 165 166 err = init_stream(efw, &efw->tx_stream); 167 if (err < 0) 168 goto end; 169 /* Fireworks transmits NODATA packets with TAG0. */ 170 efw->tx_stream.flags |= CIP_EMPTY_WITH_TAG0; 171 /* Fireworks has its own meaning for dbc. */ 172 efw->tx_stream.flags |= CIP_DBC_IS_END_EVENT; 173 /* Fireworks reset dbc at bus reset. */ 174 efw->tx_stream.flags |= CIP_SKIP_DBC_ZERO_CHECK; 175 /* AudioFire9 always reports wrong dbs. */ 176 if (efw->is_af9) 177 efw->tx_stream.flags |= CIP_WRONG_DBS; 178 /* Firmware version 5.5 reports fixed interval for dbc. */ 179 if (efw->firmware_version == 0x5050000) 180 efw->tx_stream.tx_dbc_interval = 8; 181 182 err = init_stream(efw, &efw->rx_stream); 183 if (err < 0) { 184 destroy_stream(efw, &efw->tx_stream); 185 goto end; 186 } 187 188 /* set IEC61883 compliant mode (actually not fully compliant...) */ 189 err = snd_efw_command_set_tx_mode(efw, SND_EFW_TRANSPORT_MODE_IEC61883); 190 if (err < 0) { 191 destroy_stream(efw, &efw->tx_stream); 192 destroy_stream(efw, &efw->rx_stream); 193 } 194 end: 195 return err; 196 } 197 198 int snd_efw_stream_start_duplex(struct snd_efw *efw, unsigned int rate) 199 { 200 struct amdtp_stream *master, *slave; 201 atomic_t *slave_substreams; 202 enum cip_flags sync_mode; 203 unsigned int curr_rate; 204 int err = 0; 205 206 mutex_lock(&efw->mutex); 207 208 /* Need no substreams */ 209 if ((atomic_read(&efw->playback_substreams) == 0) && 210 (atomic_read(&efw->capture_substreams) == 0)) 211 goto end; 212 213 err = get_sync_mode(efw, &sync_mode); 214 if (err < 0) 215 goto end; 216 if (sync_mode == CIP_SYNC_TO_DEVICE) { 217 master = &efw->tx_stream; 218 slave = &efw->rx_stream; 219 slave_substreams = &efw->playback_substreams; 220 } else { 221 master = &efw->rx_stream; 222 slave = &efw->tx_stream; 223 slave_substreams = &efw->capture_substreams; 224 } 225 226 /* 227 * Considering JACK/FFADO streaming: 228 * TODO: This can be removed hwdep functionality becomes popular. 229 */ 230 err = check_connection_used_by_others(efw, master); 231 if (err < 0) 232 goto end; 233 234 /* packet queueing error */ 235 if (amdtp_streaming_error(slave)) 236 stop_stream(efw, slave); 237 if (amdtp_streaming_error(master)) 238 stop_stream(efw, master); 239 240 /* stop streams if rate is different */ 241 err = snd_efw_command_get_sampling_rate(efw, &curr_rate); 242 if (err < 0) 243 goto end; 244 if (rate == 0) 245 rate = curr_rate; 246 if (rate != curr_rate) { 247 stop_stream(efw, slave); 248 stop_stream(efw, master); 249 } 250 251 /* master should be always running */ 252 if (!amdtp_stream_running(master)) { 253 amdtp_stream_set_sync(sync_mode, master, slave); 254 efw->master = master; 255 256 err = snd_efw_command_set_sampling_rate(efw, rate); 257 if (err < 0) 258 goto end; 259 260 err = start_stream(efw, master, rate); 261 if (err < 0) { 262 dev_err(&efw->unit->device, 263 "fail to start AMDTP master stream:%d\n", err); 264 goto end; 265 } 266 } 267 268 /* start slave if needed */ 269 if (atomic_read(slave_substreams) > 0 && !amdtp_stream_running(slave)) { 270 err = start_stream(efw, slave, rate); 271 if (err < 0) { 272 dev_err(&efw->unit->device, 273 "fail to start AMDTP slave stream:%d\n", err); 274 stop_stream(efw, master); 275 } 276 } 277 end: 278 mutex_unlock(&efw->mutex); 279 return err; 280 } 281 282 void snd_efw_stream_stop_duplex(struct snd_efw *efw) 283 { 284 struct amdtp_stream *master, *slave; 285 atomic_t *master_substreams, *slave_substreams; 286 287 if (efw->master == &efw->rx_stream) { 288 slave = &efw->tx_stream; 289 master = &efw->rx_stream; 290 slave_substreams = &efw->capture_substreams; 291 master_substreams = &efw->playback_substreams; 292 } else { 293 slave = &efw->rx_stream; 294 master = &efw->tx_stream; 295 slave_substreams = &efw->playback_substreams; 296 master_substreams = &efw->capture_substreams; 297 } 298 299 mutex_lock(&efw->mutex); 300 301 if (atomic_read(slave_substreams) == 0) { 302 stop_stream(efw, slave); 303 304 if (atomic_read(master_substreams) == 0) 305 stop_stream(efw, master); 306 } 307 308 mutex_unlock(&efw->mutex); 309 } 310 311 void snd_efw_stream_update_duplex(struct snd_efw *efw) 312 { 313 if ((cmp_connection_update(&efw->out_conn) < 0) || 314 (cmp_connection_update(&efw->in_conn) < 0)) { 315 mutex_lock(&efw->mutex); 316 stop_stream(efw, &efw->rx_stream); 317 stop_stream(efw, &efw->tx_stream); 318 mutex_unlock(&efw->mutex); 319 } else { 320 amdtp_stream_update(&efw->rx_stream); 321 amdtp_stream_update(&efw->tx_stream); 322 } 323 } 324 325 void snd_efw_stream_destroy_duplex(struct snd_efw *efw) 326 { 327 destroy_stream(efw, &efw->rx_stream); 328 destroy_stream(efw, &efw->tx_stream); 329 } 330 331 void snd_efw_stream_lock_changed(struct snd_efw *efw) 332 { 333 efw->dev_lock_changed = true; 334 wake_up(&efw->hwdep_wait); 335 } 336 337 int snd_efw_stream_lock_try(struct snd_efw *efw) 338 { 339 int err; 340 341 spin_lock_irq(&efw->lock); 342 343 /* user land lock this */ 344 if (efw->dev_lock_count < 0) { 345 err = -EBUSY; 346 goto end; 347 } 348 349 /* this is the first time */ 350 if (efw->dev_lock_count++ == 0) 351 snd_efw_stream_lock_changed(efw); 352 err = 0; 353 end: 354 spin_unlock_irq(&efw->lock); 355 return err; 356 } 357 358 void snd_efw_stream_lock_release(struct snd_efw *efw) 359 { 360 spin_lock_irq(&efw->lock); 361 362 if (WARN_ON(efw->dev_lock_count <= 0)) 363 goto end; 364 if (--efw->dev_lock_count == 0) 365 snd_efw_stream_lock_changed(efw); 366 end: 367 spin_unlock_irq(&efw->lock); 368 } 369