1 /* 2 * This program is free software; you can redistribute it and/or modify 3 * it under the terms of the GNU General Public License as published by 4 * the Free Software Foundation; either version 2 of the License, or 5 * (at your option) any later version. 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 15 */ 16 17 /* USX2Y "rawusb" aka hwdep_pcm implementation 18 19 Its usb's unableness to atomically handle power of 2 period sized data chuncs 20 at standard samplerates, 21 what led to this part of the usx2y module: 22 It provides the alsa kernel half of the usx2y-alsa-jack driver pair. 23 The pair uses a hardware dependant alsa-device for mmaped pcm transport. 24 Advantage achieved: 25 The usb_hc moves pcm data from/into memory via DMA. 26 That memory is mmaped by jack's usx2y driver. 27 Jack's usx2y driver is the first/last to read/write pcm data. 28 Read/write is a combination of power of 2 period shaping and 29 float/int conversation. 30 Compared to mainline alsa/jack we leave out power of 2 period shaping inside 31 snd-usb-usx2y which needs memcpy() and additional buffers. 32 As a side effect possible unwanted pcm-data coruption resulting of 33 standard alsa's snd-usb-usx2y period shaping scheme falls away. 34 Result is sane jack operation at buffering schemes down to 128frames, 35 2 periods. 36 plain usx2y alsa mode is able to achieve 64frames, 4periods, but only at the 37 cost of easier triggered i.e. aeolus xruns (128 or 256frames, 38 2periods works but is useless cause of crackling). 39 40 This is a first "proof of concept" implementation. 41 Later, funcionalities should migrate to more apropriate places: 42 Userland: 43 - The jackd could mmap its float-pcm buffers directly from alsa-lib. 44 - alsa-lib could provide power of 2 period sized shaping combined with int/float 45 conversation. 46 Currently the usx2y jack driver provides above 2 services. 47 Kernel: 48 - rawusb dma pcm buffer transport should go to snd-usb-lib, so also snd-usb-audio 49 devices can use it. 50 Currently rawusb dma pcm buffer transport (this file) is only available to snd-usb-usx2y. 51 */ 52 53 #include <linux/delay.h> 54 #include "usbusx2yaudio.c" 55 56 #if defined(USX2Y_NRPACKS_VARIABLE) || (!defined(USX2Y_NRPACKS_VARIABLE) && USX2Y_NRPACKS == 1) 57 58 #include <sound/hwdep.h> 59 60 61 static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs) 62 { 63 struct urb *urb = subs->completed_urb; 64 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 65 int i, lens = 0, hwptr_done = subs->hwptr_done; 66 struct usX2Ydev *usX2Y = subs->usX2Y; 67 if (0 > usX2Y->hwdep_pcm_shm->capture_iso_start) { //FIXME 68 int head = usX2Y->hwdep_pcm_shm->captured_iso_head + 1; 69 if (head >= ARRAY_SIZE(usX2Y->hwdep_pcm_shm->captured_iso)) 70 head = 0; 71 usX2Y->hwdep_pcm_shm->capture_iso_start = head; 72 snd_printdd("cap start %i\n", head); 73 } 74 for (i = 0; i < nr_of_packs(); i++) { 75 if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */ 76 snd_printk(KERN_ERR "activ frame status %i. Most propably some hardware problem.\n", urb->iso_frame_desc[i].status); 77 return urb->iso_frame_desc[i].status; 78 } 79 lens += urb->iso_frame_desc[i].actual_length / usX2Y->stride; 80 } 81 if ((hwptr_done += lens) >= runtime->buffer_size) 82 hwptr_done -= runtime->buffer_size; 83 subs->hwptr_done = hwptr_done; 84 subs->transfer_done += lens; 85 /* update the pointer, call callback if necessary */ 86 if (subs->transfer_done >= runtime->period_size) { 87 subs->transfer_done -= runtime->period_size; 88 snd_pcm_period_elapsed(subs->pcm_substream); 89 } 90 return 0; 91 } 92 93 static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, 94 struct usX2Ydev * usX2Y) 95 { 96 return (runtime->buffer_size * 1000) / usX2Y->rate + 1; //FIXME: so far only correct period_size == 2^x ? 97 } 98 99 /* 100 * prepare urb for playback data pipe 101 * 102 * we copy the data directly from the pcm buffer. 103 * the current position to be copied is held in hwptr field. 104 * since a urb can handle only a single linear buffer, if the total 105 * transferred area overflows the buffer boundary, we cannot send 106 * it directly from the buffer. thus the data is once copied to 107 * a temporary buffer and urb points to that. 108 */ 109 static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs, 110 struct urb *urb) 111 { 112 int count, counts, pack; 113 struct usX2Ydev *usX2Y = subs->usX2Y; 114 struct snd_usX2Y_hwdep_pcm_shm *shm = usX2Y->hwdep_pcm_shm; 115 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 116 117 if (0 > shm->playback_iso_start) { 118 shm->playback_iso_start = shm->captured_iso_head - 119 usX2Y_iso_frames_per_buffer(runtime, usX2Y); 120 if (0 > shm->playback_iso_start) 121 shm->playback_iso_start += ARRAY_SIZE(shm->captured_iso); 122 shm->playback_iso_head = shm->playback_iso_start; 123 } 124 125 count = 0; 126 for (pack = 0; pack < nr_of_packs(); pack++) { 127 /* calculate the size of a packet */ 128 counts = shm->captured_iso[shm->playback_iso_head].length / usX2Y->stride; 129 if (counts < 43 || counts > 50) { 130 snd_printk(KERN_ERR "should not be here with counts=%i\n", counts); 131 return -EPIPE; 132 } 133 /* set up descriptor */ 134 urb->iso_frame_desc[pack].offset = shm->captured_iso[shm->playback_iso_head].offset; 135 urb->iso_frame_desc[pack].length = shm->captured_iso[shm->playback_iso_head].length; 136 if (atomic_read(&subs->state) != state_RUNNING) 137 memset((char *)urb->transfer_buffer + urb->iso_frame_desc[pack].offset, 0, 138 urb->iso_frame_desc[pack].length); 139 if (++shm->playback_iso_head >= ARRAY_SIZE(shm->captured_iso)) 140 shm->playback_iso_head = 0; 141 count += counts; 142 } 143 urb->transfer_buffer_length = count * usX2Y->stride; 144 return 0; 145 } 146 147 148 static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream *subs, 149 struct urb *urb) 150 { 151 int pack; 152 for (pack = 0; pack < nr_of_packs(); ++pack) { 153 struct usb_iso_packet_descriptor *desc = urb->iso_frame_desc + pack; 154 if (NULL != subs) { 155 struct snd_usX2Y_hwdep_pcm_shm *shm = subs->usX2Y->hwdep_pcm_shm; 156 int head = shm->captured_iso_head + 1; 157 if (head >= ARRAY_SIZE(shm->captured_iso)) 158 head = 0; 159 shm->captured_iso[head].frame = urb->start_frame + pack; 160 shm->captured_iso[head].offset = desc->offset; 161 shm->captured_iso[head].length = desc->actual_length; 162 shm->captured_iso_head = head; 163 shm->captured_iso_frames++; 164 } 165 if ((desc->offset += desc->length * NRURBS*nr_of_packs()) + 166 desc->length >= SSS) 167 desc->offset -= (SSS - desc->length); 168 } 169 } 170 171 static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *capsubs, 172 struct snd_usX2Y_substream *capsubs2, 173 struct snd_usX2Y_substream *playbacksubs, 174 int frame) 175 { 176 int err, state; 177 struct urb *urb = playbacksubs->completed_urb; 178 179 state = atomic_read(&playbacksubs->state); 180 if (NULL != urb) { 181 if (state == state_RUNNING) 182 usX2Y_urb_play_retire(playbacksubs, urb); 183 else if (state >= state_PRERUNNING) 184 atomic_inc(&playbacksubs->state); 185 } else { 186 switch (state) { 187 case state_STARTING1: 188 urb = playbacksubs->urb[0]; 189 atomic_inc(&playbacksubs->state); 190 break; 191 case state_STARTING2: 192 urb = playbacksubs->urb[1]; 193 atomic_inc(&playbacksubs->state); 194 break; 195 } 196 } 197 if (urb) { 198 if ((err = usX2Y_hwdep_urb_play_prepare(playbacksubs, urb)) || 199 (err = usX2Y_urb_submit(playbacksubs, urb, frame))) { 200 return err; 201 } 202 } 203 204 playbacksubs->completed_urb = NULL; 205 206 state = atomic_read(&capsubs->state); 207 if (state >= state_PREPARED) { 208 if (state == state_RUNNING) { 209 if ((err = usX2Y_usbpcm_urb_capt_retire(capsubs))) 210 return err; 211 } else if (state >= state_PRERUNNING) 212 atomic_inc(&capsubs->state); 213 usX2Y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb); 214 if (NULL != capsubs2) 215 usX2Y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb); 216 if ((err = usX2Y_urb_submit(capsubs, capsubs->completed_urb, frame))) 217 return err; 218 if (NULL != capsubs2) 219 if ((err = usX2Y_urb_submit(capsubs2, capsubs2->completed_urb, frame))) 220 return err; 221 } 222 capsubs->completed_urb = NULL; 223 if (NULL != capsubs2) 224 capsubs2->completed_urb = NULL; 225 return 0; 226 } 227 228 229 static void i_usX2Y_usbpcm_urb_complete(struct urb *urb) 230 { 231 struct snd_usX2Y_substream *subs = urb->context; 232 struct usX2Ydev *usX2Y = subs->usX2Y; 233 struct snd_usX2Y_substream *capsubs, *capsubs2, *playbacksubs; 234 235 if (unlikely(atomic_read(&subs->state) < state_PREPARED)) { 236 snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", 237 usb_get_current_frame_number(usX2Y->chip.dev), 238 subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", 239 urb->status, urb->start_frame); 240 return; 241 } 242 if (unlikely(urb->status)) { 243 usX2Y_error_urb_status(usX2Y, subs, urb); 244 return; 245 } 246 if (likely((urb->start_frame & 0xFFFF) == (usX2Y->wait_iso_frame & 0xFFFF))) 247 subs->completed_urb = urb; 248 else { 249 usX2Y_error_sequence(usX2Y, subs, urb); 250 return; 251 } 252 253 capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; 254 capsubs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 255 playbacksubs = usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 256 if (capsubs->completed_urb && atomic_read(&capsubs->state) >= state_PREPARED && 257 (NULL == capsubs2 || capsubs2->completed_urb) && 258 (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < state_PREPARED)) { 259 if (!usX2Y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame)) 260 usX2Y->wait_iso_frame += nr_of_packs(); 261 else { 262 snd_printdd("\n"); 263 usX2Y_clients_stop(usX2Y); 264 } 265 } 266 } 267 268 269 static void usX2Y_hwdep_urb_release(struct urb **urb) 270 { 271 usb_kill_urb(*urb); 272 usb_free_urb(*urb); 273 *urb = NULL; 274 } 275 276 /* 277 * release a substream 278 */ 279 static void usX2Y_usbpcm_urbs_release(struct snd_usX2Y_substream *subs) 280 { 281 int i; 282 snd_printdd("snd_usX2Y_urbs_release() %i\n", subs->endpoint); 283 for (i = 0; i < NRURBS; i++) 284 usX2Y_hwdep_urb_release(subs->urb + i); 285 } 286 287 static void usX2Y_usbpcm_subs_startup_finish(struct usX2Ydev * usX2Y) 288 { 289 usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_urb_complete); 290 usX2Y->prepare_subs = NULL; 291 } 292 293 static void i_usX2Y_usbpcm_subs_startup(struct urb *urb) 294 { 295 struct snd_usX2Y_substream *subs = urb->context; 296 struct usX2Ydev *usX2Y = subs->usX2Y; 297 struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs; 298 if (NULL != prepare_subs && 299 urb->start_frame == prepare_subs->urb[0]->start_frame) { 300 atomic_inc(&prepare_subs->state); 301 if (prepare_subs == usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]) { 302 struct snd_usX2Y_substream *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 303 if (cap_subs2 != NULL) 304 atomic_inc(&cap_subs2->state); 305 } 306 usX2Y_usbpcm_subs_startup_finish(usX2Y); 307 wake_up(&usX2Y->prepare_wait_queue); 308 } 309 310 i_usX2Y_usbpcm_urb_complete(urb); 311 } 312 313 /* 314 * initialize a substream's urbs 315 */ 316 static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs) 317 { 318 int i; 319 unsigned int pipe; 320 int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 321 struct usb_device *dev = subs->usX2Y->chip.dev; 322 323 pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) : 324 usb_rcvisocpipe(dev, subs->endpoint); 325 subs->maxpacksize = usb_maxpacket(dev, pipe, is_playback); 326 if (!subs->maxpacksize) 327 return -EINVAL; 328 329 /* allocate and initialize data urbs */ 330 for (i = 0; i < NRURBS; i++) { 331 struct urb **purb = subs->urb + i; 332 if (*purb) { 333 usb_kill_urb(*purb); 334 continue; 335 } 336 *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL); 337 if (NULL == *purb) { 338 usX2Y_usbpcm_urbs_release(subs); 339 return -ENOMEM; 340 } 341 (*purb)->transfer_buffer = is_playback ? 342 subs->usX2Y->hwdep_pcm_shm->playback : ( 343 subs->endpoint == 0x8 ? 344 subs->usX2Y->hwdep_pcm_shm->capture0x8 : 345 subs->usX2Y->hwdep_pcm_shm->capture0xA); 346 347 (*purb)->dev = dev; 348 (*purb)->pipe = pipe; 349 (*purb)->number_of_packets = nr_of_packs(); 350 (*purb)->context = subs; 351 (*purb)->interval = 1; 352 (*purb)->complete = i_usX2Y_usbpcm_subs_startup; 353 } 354 return 0; 355 } 356 357 /* 358 * free the buffer 359 */ 360 static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream) 361 { 362 struct snd_pcm_runtime *runtime = substream->runtime; 363 struct snd_usX2Y_substream *subs = runtime->private_data, 364 *cap_subs2 = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 365 mutex_lock(&subs->usX2Y->prepare_mutex); 366 snd_printdd("snd_usX2Y_usbpcm_hw_free(%p)\n", substream); 367 368 if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) { 369 struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; 370 atomic_set(&subs->state, state_STOPPED); 371 usX2Y_usbpcm_urbs_release(subs); 372 if (!cap_subs->pcm_substream || 373 !cap_subs->pcm_substream->runtime || 374 !cap_subs->pcm_substream->runtime->status || 375 cap_subs->pcm_substream->runtime->status->state < SNDRV_PCM_STATE_PREPARED) { 376 atomic_set(&cap_subs->state, state_STOPPED); 377 if (NULL != cap_subs2) 378 atomic_set(&cap_subs2->state, state_STOPPED); 379 usX2Y_usbpcm_urbs_release(cap_subs); 380 if (NULL != cap_subs2) 381 usX2Y_usbpcm_urbs_release(cap_subs2); 382 } 383 } else { 384 struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 385 if (atomic_read(&playback_subs->state) < state_PREPARED) { 386 atomic_set(&subs->state, state_STOPPED); 387 if (NULL != cap_subs2) 388 atomic_set(&cap_subs2->state, state_STOPPED); 389 usX2Y_usbpcm_urbs_release(subs); 390 if (NULL != cap_subs2) 391 usX2Y_usbpcm_urbs_release(cap_subs2); 392 } 393 } 394 mutex_unlock(&subs->usX2Y->prepare_mutex); 395 return snd_pcm_lib_free_pages(substream); 396 } 397 398 static void usX2Y_usbpcm_subs_startup(struct snd_usX2Y_substream *subs) 399 { 400 struct usX2Ydev * usX2Y = subs->usX2Y; 401 usX2Y->prepare_subs = subs; 402 subs->urb[0]->start_frame = -1; 403 smp_wmb(); // Make sure above modifications are seen by i_usX2Y_subs_startup() 404 usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_subs_startup); 405 } 406 407 static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) 408 { 409 int p, u, err, 410 stream = subs->pcm_substream->stream; 411 struct usX2Ydev *usX2Y = subs->usX2Y; 412 413 if (SNDRV_PCM_STREAM_CAPTURE == stream) { 414 usX2Y->hwdep_pcm_shm->captured_iso_head = -1; 415 usX2Y->hwdep_pcm_shm->captured_iso_frames = 0; 416 } 417 418 for (p = 0; 3 >= (stream + p); p += 2) { 419 struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p]; 420 if (subs != NULL) { 421 if ((err = usX2Y_usbpcm_urbs_allocate(subs)) < 0) 422 return err; 423 subs->completed_urb = NULL; 424 } 425 } 426 427 for (p = 0; p < 4; p++) { 428 struct snd_usX2Y_substream *subs = usX2Y->subs[p]; 429 if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED) 430 goto start; 431 } 432 433 start: 434 usX2Y_usbpcm_subs_startup(subs); 435 for (u = 0; u < NRURBS; u++) { 436 for (p = 0; 3 >= (stream + p); p += 2) { 437 struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p]; 438 if (subs != NULL) { 439 struct urb *urb = subs->urb[u]; 440 if (usb_pipein(urb->pipe)) { 441 unsigned long pack; 442 if (0 == u) 443 atomic_set(&subs->state, state_STARTING3); 444 urb->dev = usX2Y->chip.dev; 445 urb->transfer_flags = URB_ISO_ASAP; 446 for (pack = 0; pack < nr_of_packs(); pack++) { 447 urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs()); 448 urb->iso_frame_desc[pack].length = subs->maxpacksize; 449 } 450 urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs(); 451 if ((err = usb_submit_urb(urb, GFP_KERNEL)) < 0) { 452 snd_printk (KERN_ERR "cannot usb_submit_urb() for urb %d, err = %d\n", u, err); 453 err = -EPIPE; 454 goto cleanup; 455 } else { 456 snd_printdd("%i\n", urb->start_frame); 457 if (u == 0) 458 usX2Y->wait_iso_frame = urb->start_frame; 459 } 460 urb->transfer_flags = 0; 461 } else { 462 atomic_set(&subs->state, state_STARTING1); 463 break; 464 } 465 } 466 } 467 } 468 err = 0; 469 wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs); 470 if (atomic_read(&subs->state) != state_PREPARED) 471 err = -EPIPE; 472 473 cleanup: 474 if (err) { 475 usX2Y_subs_startup_finish(usX2Y); // Call it now 476 usX2Y_clients_stop(usX2Y); // something is completely wroong > stop evrything 477 } 478 return err; 479 } 480 481 /* 482 * prepare callback 483 * 484 * set format and initialize urbs 485 */ 486 static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream) 487 { 488 struct snd_pcm_runtime *runtime = substream->runtime; 489 struct snd_usX2Y_substream *subs = runtime->private_data; 490 struct usX2Ydev *usX2Y = subs->usX2Y; 491 struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; 492 int err = 0; 493 snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream); 494 495 if (NULL == usX2Y->hwdep_pcm_shm) { 496 if (NULL == (usX2Y->hwdep_pcm_shm = snd_malloc_pages(sizeof(struct snd_usX2Y_hwdep_pcm_shm), GFP_KERNEL))) 497 return -ENOMEM; 498 memset(usX2Y->hwdep_pcm_shm, 0, sizeof(struct snd_usX2Y_hwdep_pcm_shm)); 499 } 500 501 mutex_lock(&usX2Y->prepare_mutex); 502 usX2Y_subs_prepare(subs); 503 // Start hardware streams 504 // SyncStream first.... 505 if (atomic_read(&capsubs->state) < state_PREPARED) { 506 if (usX2Y->format != runtime->format) 507 if ((err = usX2Y_format_set(usX2Y, runtime->format)) < 0) 508 goto up_prepare_mutex; 509 if (usX2Y->rate != runtime->rate) 510 if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0) 511 goto up_prepare_mutex; 512 snd_printdd("starting capture pipe for %s\n", subs == capsubs ? 513 "self" : "playpipe"); 514 if (0 > (err = usX2Y_usbpcm_urbs_start(capsubs))) 515 goto up_prepare_mutex; 516 } 517 518 if (subs != capsubs) { 519 usX2Y->hwdep_pcm_shm->playback_iso_start = -1; 520 if (atomic_read(&subs->state) < state_PREPARED) { 521 while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) > 522 usX2Y->hwdep_pcm_shm->captured_iso_frames) { 523 snd_printdd("Wait: iso_frames_per_buffer=%i," 524 "captured_iso_frames=%i\n", 525 usX2Y_iso_frames_per_buffer(runtime, usX2Y), 526 usX2Y->hwdep_pcm_shm->captured_iso_frames); 527 if (msleep_interruptible(10)) { 528 err = -ERESTARTSYS; 529 goto up_prepare_mutex; 530 } 531 } 532 if (0 > (err = usX2Y_usbpcm_urbs_start(subs))) 533 goto up_prepare_mutex; 534 } 535 snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", 536 usX2Y_iso_frames_per_buffer(runtime, usX2Y), 537 usX2Y->hwdep_pcm_shm->captured_iso_frames); 538 } else 539 usX2Y->hwdep_pcm_shm->capture_iso_start = -1; 540 541 up_prepare_mutex: 542 mutex_unlock(&usX2Y->prepare_mutex); 543 return err; 544 } 545 546 static struct snd_pcm_hardware snd_usX2Y_4c = 547 { 548 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 549 SNDRV_PCM_INFO_BLOCK_TRANSFER | 550 SNDRV_PCM_INFO_MMAP_VALID), 551 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE, 552 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, 553 .rate_min = 44100, 554 .rate_max = 48000, 555 .channels_min = 2, 556 .channels_max = 4, 557 .buffer_bytes_max = (2*128*1024), 558 .period_bytes_min = 64, 559 .period_bytes_max = (128*1024), 560 .periods_min = 2, 561 .periods_max = 1024, 562 .fifo_size = 0 563 }; 564 565 566 567 static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream) 568 { 569 struct snd_usX2Y_substream *subs = ((struct snd_usX2Y_substream **) 570 snd_pcm_substream_chip(substream))[substream->stream]; 571 struct snd_pcm_runtime *runtime = substream->runtime; 572 573 if (!(subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)) 574 return -EBUSY; 575 576 runtime->hw = SNDRV_PCM_STREAM_PLAYBACK == substream->stream ? snd_usX2Y_2c : 577 (subs->usX2Y->subs[3] ? snd_usX2Y_4c : snd_usX2Y_2c); 578 runtime->private_data = subs; 579 subs->pcm_substream = substream; 580 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000); 581 return 0; 582 } 583 584 585 static int snd_usX2Y_usbpcm_close(struct snd_pcm_substream *substream) 586 { 587 struct snd_pcm_runtime *runtime = substream->runtime; 588 struct snd_usX2Y_substream *subs = runtime->private_data; 589 590 subs->pcm_substream = NULL; 591 return 0; 592 } 593 594 595 static struct snd_pcm_ops snd_usX2Y_usbpcm_ops = 596 { 597 .open = snd_usX2Y_usbpcm_open, 598 .close = snd_usX2Y_usbpcm_close, 599 .ioctl = snd_pcm_lib_ioctl, 600 .hw_params = snd_usX2Y_pcm_hw_params, 601 .hw_free = snd_usX2Y_usbpcm_hw_free, 602 .prepare = snd_usX2Y_usbpcm_prepare, 603 .trigger = snd_usX2Y_pcm_trigger, 604 .pointer = snd_usX2Y_pcm_pointer, 605 }; 606 607 608 static int usX2Y_pcms_lock_check(struct snd_card *card) 609 { 610 struct list_head *list; 611 struct snd_device *dev; 612 struct snd_pcm *pcm; 613 int err = 0; 614 list_for_each(list, &card->devices) { 615 dev = snd_device(list); 616 if (dev->type != SNDRV_DEV_PCM) 617 continue; 618 pcm = dev->device_data; 619 mutex_lock(&pcm->open_mutex); 620 } 621 list_for_each(list, &card->devices) { 622 int s; 623 dev = snd_device(list); 624 if (dev->type != SNDRV_DEV_PCM) 625 continue; 626 pcm = dev->device_data; 627 for (s = 0; s < 2; ++s) { 628 struct snd_pcm_substream *substream; 629 substream = pcm->streams[s].substream; 630 if (substream && SUBSTREAM_BUSY(substream)) 631 err = -EBUSY; 632 } 633 } 634 return err; 635 } 636 637 638 static void usX2Y_pcms_unlock(struct snd_card *card) 639 { 640 struct list_head *list; 641 struct snd_device *dev; 642 struct snd_pcm *pcm; 643 list_for_each(list, &card->devices) { 644 dev = snd_device(list); 645 if (dev->type != SNDRV_DEV_PCM) 646 continue; 647 pcm = dev->device_data; 648 mutex_unlock(&pcm->open_mutex); 649 } 650 } 651 652 653 static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file) 654 { 655 // we need to be the first 656 struct snd_card *card = hw->card; 657 int err = usX2Y_pcms_lock_check(card); 658 if (0 == err) 659 usX2Y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS; 660 usX2Y_pcms_unlock(card); 661 return err; 662 } 663 664 665 static int snd_usX2Y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file) 666 { 667 struct snd_card *card = hw->card; 668 int err = usX2Y_pcms_lock_check(card); 669 if (0 == err) 670 usX2Y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS; 671 usX2Y_pcms_unlock(card); 672 return err; 673 } 674 675 676 static void snd_usX2Y_hwdep_pcm_vm_open(struct vm_area_struct *area) 677 { 678 } 679 680 681 static void snd_usX2Y_hwdep_pcm_vm_close(struct vm_area_struct *area) 682 { 683 } 684 685 686 static int snd_usX2Y_hwdep_pcm_vm_fault(struct vm_area_struct *area, 687 struct vm_fault *vmf) 688 { 689 unsigned long offset; 690 void *vaddr; 691 692 offset = vmf->pgoff << PAGE_SHIFT; 693 vaddr = (char*)((struct usX2Ydev *)area->vm_private_data)->hwdep_pcm_shm + offset; 694 vmf->page = virt_to_page(vaddr); 695 get_page(vmf->page); 696 return 0; 697 } 698 699 700 static struct vm_operations_struct snd_usX2Y_hwdep_pcm_vm_ops = { 701 .open = snd_usX2Y_hwdep_pcm_vm_open, 702 .close = snd_usX2Y_hwdep_pcm_vm_close, 703 .fault = snd_usX2Y_hwdep_pcm_vm_fault, 704 }; 705 706 707 static int snd_usX2Y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) 708 { 709 unsigned long size = (unsigned long)(area->vm_end - area->vm_start); 710 struct usX2Ydev *usX2Y = hw->private_data; 711 712 if (!(usX2Y->chip_status & USX2Y_STAT_CHIP_INIT)) 713 return -EBUSY; 714 715 /* if userspace tries to mmap beyond end of our buffer, fail */ 716 if (size > PAGE_ALIGN(sizeof(struct snd_usX2Y_hwdep_pcm_shm))) { 717 snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(struct snd_usX2Y_hwdep_pcm_shm)); 718 return -EINVAL; 719 } 720 721 if (!usX2Y->hwdep_pcm_shm) { 722 return -ENODEV; 723 } 724 area->vm_ops = &snd_usX2Y_hwdep_pcm_vm_ops; 725 area->vm_flags |= VM_RESERVED | VM_DONTEXPAND; 726 area->vm_private_data = hw->private_data; 727 return 0; 728 } 729 730 731 static void snd_usX2Y_hwdep_pcm_private_free(struct snd_hwdep *hwdep) 732 { 733 struct usX2Ydev *usX2Y = hwdep->private_data; 734 if (NULL != usX2Y->hwdep_pcm_shm) 735 snd_free_pages(usX2Y->hwdep_pcm_shm, sizeof(struct snd_usX2Y_hwdep_pcm_shm)); 736 } 737 738 739 int usX2Y_hwdep_pcm_new(struct snd_card *card) 740 { 741 int err; 742 struct snd_hwdep *hw; 743 struct snd_pcm *pcm; 744 struct usb_device *dev = usX2Y(card)->chip.dev; 745 if (1 != nr_of_packs()) 746 return 0; 747 748 if ((err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw)) < 0) 749 return err; 750 751 hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM; 752 hw->private_data = usX2Y(card); 753 hw->private_free = snd_usX2Y_hwdep_pcm_private_free; 754 hw->ops.open = snd_usX2Y_hwdep_pcm_open; 755 hw->ops.release = snd_usX2Y_hwdep_pcm_release; 756 hw->ops.mmap = snd_usX2Y_hwdep_pcm_mmap; 757 hw->exclusive = 1; 758 sprintf(hw->name, "/proc/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum); 759 760 err = snd_pcm_new(card, NAME_ALLCAPS" hwdep Audio", 2, 1, 1, &pcm); 761 if (err < 0) { 762 return err; 763 } 764 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usX2Y_usbpcm_ops); 765 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_usbpcm_ops); 766 767 pcm->private_data = usX2Y(card)->subs; 768 pcm->info_flags = 0; 769 770 sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio"); 771 if (0 > (err = snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream, 772 SNDRV_DMA_TYPE_CONTINUOUS, 773 snd_dma_continuous_data(GFP_KERNEL), 774 64*1024, 128*1024)) || 775 0 > (err = snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, 776 SNDRV_DMA_TYPE_CONTINUOUS, 777 snd_dma_continuous_data(GFP_KERNEL), 778 64*1024, 128*1024))) { 779 return err; 780 } 781 782 783 return 0; 784 } 785 786 #else 787 788 int usX2Y_hwdep_pcm_new(struct snd_card *card) 789 { 790 return 0; 791 } 792 793 #endif 794