11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 31da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 41da177e4SLinus Torvalds * the Free Software Foundation; either version 2 of the License, or 51da177e4SLinus Torvalds * (at your option) any later version. 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, 81da177e4SLinus Torvalds * but WITHOUT ANY WARRANTY; without even the implied warranty of 91da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 101da177e4SLinus Torvalds * GNU General Public License for more details. 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License 131da177e4SLinus Torvalds * along with this program; if not, write to the Free Software 141da177e4SLinus Torvalds * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 151da177e4SLinus Torvalds */ 161da177e4SLinus Torvalds 171da177e4SLinus Torvalds /* USX2Y "rawusb" aka hwdep_pcm implementation 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds Its usb's unableness to atomically handle power of 2 period sized data chuncs 201da177e4SLinus Torvalds at standard samplerates, 211da177e4SLinus Torvalds what led to this part of the usx2y module: 221da177e4SLinus Torvalds It provides the alsa kernel half of the usx2y-alsa-jack driver pair. 2325985edcSLucas De Marchi The pair uses a hardware dependent alsa-device for mmaped pcm transport. 241da177e4SLinus Torvalds Advantage achieved: 251da177e4SLinus Torvalds The usb_hc moves pcm data from/into memory via DMA. 261da177e4SLinus Torvalds That memory is mmaped by jack's usx2y driver. 271da177e4SLinus Torvalds Jack's usx2y driver is the first/last to read/write pcm data. 281da177e4SLinus Torvalds Read/write is a combination of power of 2 period shaping and 291da177e4SLinus Torvalds float/int conversation. 301da177e4SLinus Torvalds Compared to mainline alsa/jack we leave out power of 2 period shaping inside 311da177e4SLinus Torvalds snd-usb-usx2y which needs memcpy() and additional buffers. 321da177e4SLinus Torvalds As a side effect possible unwanted pcm-data coruption resulting of 331da177e4SLinus Torvalds standard alsa's snd-usb-usx2y period shaping scheme falls away. 341da177e4SLinus Torvalds Result is sane jack operation at buffering schemes down to 128frames, 351da177e4SLinus Torvalds 2 periods. 361da177e4SLinus Torvalds plain usx2y alsa mode is able to achieve 64frames, 4periods, but only at the 371da177e4SLinus Torvalds cost of easier triggered i.e. aeolus xruns (128 or 256frames, 381da177e4SLinus Torvalds 2periods works but is useless cause of crackling). 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds This is a first "proof of concept" implementation. 4125985edcSLucas De Marchi Later, functionalities should migrate to more appropriate places: 421da177e4SLinus Torvalds Userland: 431da177e4SLinus Torvalds - The jackd could mmap its float-pcm buffers directly from alsa-lib. 441da177e4SLinus Torvalds - alsa-lib could provide power of 2 period sized shaping combined with int/float 451da177e4SLinus Torvalds conversation. 461da177e4SLinus Torvalds Currently the usx2y jack driver provides above 2 services. 471da177e4SLinus Torvalds Kernel: 481da177e4SLinus Torvalds - rawusb dma pcm buffer transport should go to snd-usb-lib, so also snd-usb-audio 491da177e4SLinus Torvalds devices can use it. 501da177e4SLinus Torvalds Currently rawusb dma pcm buffer transport (this file) is only available to snd-usb-usx2y. 511da177e4SLinus Torvalds */ 521da177e4SLinus Torvalds 53b27c187fSNishanth Aravamudan #include <linux/delay.h> 545a0e3ad6STejun Heo #include <linux/gfp.h> 551da177e4SLinus Torvalds #include "usbusx2yaudio.c" 561da177e4SLinus Torvalds 571d2019fbSNicolas Kaiser #if defined(USX2Y_NRPACKS_VARIABLE) || USX2Y_NRPACKS == 1 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds #include <sound/hwdep.h> 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds 62bbe85bbdSTakashi Iwai static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs) 631da177e4SLinus Torvalds { 641da177e4SLinus Torvalds struct urb *urb = subs->completed_urb; 65bbe85bbdSTakashi Iwai struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 661da177e4SLinus Torvalds int i, lens = 0, hwptr_done = subs->hwptr_done; 67bbe85bbdSTakashi Iwai struct usX2Ydev *usX2Y = subs->usX2Y; 681da177e4SLinus Torvalds if (0 > usX2Y->hwdep_pcm_shm->capture_iso_start) { //FIXME 691da177e4SLinus Torvalds int head = usX2Y->hwdep_pcm_shm->captured_iso_head + 1; 701da177e4SLinus Torvalds if (head >= ARRAY_SIZE(usX2Y->hwdep_pcm_shm->captured_iso)) 711da177e4SLinus Torvalds head = 0; 721da177e4SLinus Torvalds usX2Y->hwdep_pcm_shm->capture_iso_start = head; 731da177e4SLinus Torvalds snd_printdd("cap start %i\n", head); 741da177e4SLinus Torvalds } 751da177e4SLinus Torvalds for (i = 0; i < nr_of_packs(); i++) { 761da177e4SLinus Torvalds if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */ 776e8d5d2fSMasanari Iida snd_printk(KERN_ERR "active frame status %i. Most probably some hardware problem.\n", urb->iso_frame_desc[i].status); 781da177e4SLinus Torvalds return urb->iso_frame_desc[i].status; 791da177e4SLinus Torvalds } 801da177e4SLinus Torvalds lens += urb->iso_frame_desc[i].actual_length / usX2Y->stride; 811da177e4SLinus Torvalds } 821da177e4SLinus Torvalds if ((hwptr_done += lens) >= runtime->buffer_size) 831da177e4SLinus Torvalds hwptr_done -= runtime->buffer_size; 841da177e4SLinus Torvalds subs->hwptr_done = hwptr_done; 851da177e4SLinus Torvalds subs->transfer_done += lens; 861da177e4SLinus Torvalds /* update the pointer, call callback if necessary */ 871da177e4SLinus Torvalds if (subs->transfer_done >= runtime->period_size) { 881da177e4SLinus Torvalds subs->transfer_done -= runtime->period_size; 891da177e4SLinus Torvalds snd_pcm_period_elapsed(subs->pcm_substream); 901da177e4SLinus Torvalds } 911da177e4SLinus Torvalds return 0; 921da177e4SLinus Torvalds } 931da177e4SLinus Torvalds 94bbe85bbdSTakashi Iwai static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, 95bbe85bbdSTakashi Iwai struct usX2Ydev * usX2Y) 961da177e4SLinus Torvalds { 971da177e4SLinus Torvalds return (runtime->buffer_size * 1000) / usX2Y->rate + 1; //FIXME: so far only correct period_size == 2^x ? 981da177e4SLinus Torvalds } 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds /* 1011da177e4SLinus Torvalds * prepare urb for playback data pipe 1021da177e4SLinus Torvalds * 1031da177e4SLinus Torvalds * we copy the data directly from the pcm buffer. 1041da177e4SLinus Torvalds * the current position to be copied is held in hwptr field. 1051da177e4SLinus Torvalds * since a urb can handle only a single linear buffer, if the total 1061da177e4SLinus Torvalds * transferred area overflows the buffer boundary, we cannot send 1071da177e4SLinus Torvalds * it directly from the buffer. thus the data is once copied to 1081da177e4SLinus Torvalds * a temporary buffer and urb points to that. 1091da177e4SLinus Torvalds */ 110bbe85bbdSTakashi Iwai static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs, 1111da177e4SLinus Torvalds struct urb *urb) 1121da177e4SLinus Torvalds { 1131da177e4SLinus Torvalds int count, counts, pack; 114bbe85bbdSTakashi Iwai struct usX2Ydev *usX2Y = subs->usX2Y; 1151da177e4SLinus Torvalds struct snd_usX2Y_hwdep_pcm_shm *shm = usX2Y->hwdep_pcm_shm; 116bbe85bbdSTakashi Iwai struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds if (0 > shm->playback_iso_start) { 1191da177e4SLinus Torvalds shm->playback_iso_start = shm->captured_iso_head - 1201da177e4SLinus Torvalds usX2Y_iso_frames_per_buffer(runtime, usX2Y); 1211da177e4SLinus Torvalds if (0 > shm->playback_iso_start) 1221da177e4SLinus Torvalds shm->playback_iso_start += ARRAY_SIZE(shm->captured_iso); 1231da177e4SLinus Torvalds shm->playback_iso_head = shm->playback_iso_start; 1241da177e4SLinus Torvalds } 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds count = 0; 1271da177e4SLinus Torvalds for (pack = 0; pack < nr_of_packs(); pack++) { 1281da177e4SLinus Torvalds /* calculate the size of a packet */ 1291da177e4SLinus Torvalds counts = shm->captured_iso[shm->playback_iso_head].length / usX2Y->stride; 1301da177e4SLinus Torvalds if (counts < 43 || counts > 50) { 131d3d579f8STakashi Iwai snd_printk(KERN_ERR "should not be here with counts=%i\n", counts); 1321da177e4SLinus Torvalds return -EPIPE; 1331da177e4SLinus Torvalds } 1341da177e4SLinus Torvalds /* set up descriptor */ 1351da177e4SLinus Torvalds urb->iso_frame_desc[pack].offset = shm->captured_iso[shm->playback_iso_head].offset; 1361da177e4SLinus Torvalds urb->iso_frame_desc[pack].length = shm->captured_iso[shm->playback_iso_head].length; 1371da177e4SLinus Torvalds if (atomic_read(&subs->state) != state_RUNNING) 1381da177e4SLinus Torvalds memset((char *)urb->transfer_buffer + urb->iso_frame_desc[pack].offset, 0, 1391da177e4SLinus Torvalds urb->iso_frame_desc[pack].length); 1401da177e4SLinus Torvalds if (++shm->playback_iso_head >= ARRAY_SIZE(shm->captured_iso)) 1411da177e4SLinus Torvalds shm->playback_iso_head = 0; 1421da177e4SLinus Torvalds count += counts; 1431da177e4SLinus Torvalds } 1441da177e4SLinus Torvalds urb->transfer_buffer_length = count * usX2Y->stride; 1451da177e4SLinus Torvalds return 0; 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds 1481da177e4SLinus Torvalds 149bbe85bbdSTakashi Iwai static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream *subs, 150bbe85bbdSTakashi Iwai struct urb *urb) 1511da177e4SLinus Torvalds { 1521da177e4SLinus Torvalds int pack; 1531da177e4SLinus Torvalds for (pack = 0; pack < nr_of_packs(); ++pack) { 1541da177e4SLinus Torvalds struct usb_iso_packet_descriptor *desc = urb->iso_frame_desc + pack; 1551da177e4SLinus Torvalds if (NULL != subs) { 156bbe85bbdSTakashi Iwai struct snd_usX2Y_hwdep_pcm_shm *shm = subs->usX2Y->hwdep_pcm_shm; 1571da177e4SLinus Torvalds int head = shm->captured_iso_head + 1; 1581da177e4SLinus Torvalds if (head >= ARRAY_SIZE(shm->captured_iso)) 1591da177e4SLinus Torvalds head = 0; 1601da177e4SLinus Torvalds shm->captured_iso[head].frame = urb->start_frame + pack; 1611da177e4SLinus Torvalds shm->captured_iso[head].offset = desc->offset; 1621da177e4SLinus Torvalds shm->captured_iso[head].length = desc->actual_length; 1631da177e4SLinus Torvalds shm->captured_iso_head = head; 1641da177e4SLinus Torvalds shm->captured_iso_frames++; 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds if ((desc->offset += desc->length * NRURBS*nr_of_packs()) + 1671da177e4SLinus Torvalds desc->length >= SSS) 1681da177e4SLinus Torvalds desc->offset -= (SSS - desc->length); 1691da177e4SLinus Torvalds } 1701da177e4SLinus Torvalds } 1711da177e4SLinus Torvalds 172bbe85bbdSTakashi Iwai static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *capsubs, 173bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *capsubs2, 174bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *playbacksubs, 175bbe85bbdSTakashi Iwai int frame) 1761da177e4SLinus Torvalds { 1771da177e4SLinus Torvalds int err, state; 1781da177e4SLinus Torvalds struct urb *urb = playbacksubs->completed_urb; 1791da177e4SLinus Torvalds 1801da177e4SLinus Torvalds state = atomic_read(&playbacksubs->state); 1811da177e4SLinus Torvalds if (NULL != urb) { 1821da177e4SLinus Torvalds if (state == state_RUNNING) 1831da177e4SLinus Torvalds usX2Y_urb_play_retire(playbacksubs, urb); 184cb432379STakashi Iwai else if (state >= state_PRERUNNING) 1851da177e4SLinus Torvalds atomic_inc(&playbacksubs->state); 1861da177e4SLinus Torvalds } else { 1871da177e4SLinus Torvalds switch (state) { 1881da177e4SLinus Torvalds case state_STARTING1: 1891da177e4SLinus Torvalds urb = playbacksubs->urb[0]; 1901da177e4SLinus Torvalds atomic_inc(&playbacksubs->state); 1911da177e4SLinus Torvalds break; 1921da177e4SLinus Torvalds case state_STARTING2: 1931da177e4SLinus Torvalds urb = playbacksubs->urb[1]; 1941da177e4SLinus Torvalds atomic_inc(&playbacksubs->state); 1951da177e4SLinus Torvalds break; 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds if (urb) { 1991da177e4SLinus Torvalds if ((err = usX2Y_hwdep_urb_play_prepare(playbacksubs, urb)) || 2001da177e4SLinus Torvalds (err = usX2Y_urb_submit(playbacksubs, urb, frame))) { 2011da177e4SLinus Torvalds return err; 2021da177e4SLinus Torvalds } 2031da177e4SLinus Torvalds } 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds playbacksubs->completed_urb = NULL; 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds state = atomic_read(&capsubs->state); 2081da177e4SLinus Torvalds if (state >= state_PREPARED) { 2091da177e4SLinus Torvalds if (state == state_RUNNING) { 2101da177e4SLinus Torvalds if ((err = usX2Y_usbpcm_urb_capt_retire(capsubs))) 2111da177e4SLinus Torvalds return err; 212cb432379STakashi Iwai } else if (state >= state_PRERUNNING) 2131da177e4SLinus Torvalds atomic_inc(&capsubs->state); 2141da177e4SLinus Torvalds usX2Y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb); 2151da177e4SLinus Torvalds if (NULL != capsubs2) 2161da177e4SLinus Torvalds usX2Y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb); 2171da177e4SLinus Torvalds if ((err = usX2Y_urb_submit(capsubs, capsubs->completed_urb, frame))) 2181da177e4SLinus Torvalds return err; 2191da177e4SLinus Torvalds if (NULL != capsubs2) 2201da177e4SLinus Torvalds if ((err = usX2Y_urb_submit(capsubs2, capsubs2->completed_urb, frame))) 2211da177e4SLinus Torvalds return err; 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds capsubs->completed_urb = NULL; 2241da177e4SLinus Torvalds if (NULL != capsubs2) 2251da177e4SLinus Torvalds capsubs2->completed_urb = NULL; 2261da177e4SLinus Torvalds return 0; 2271da177e4SLinus Torvalds } 2281da177e4SLinus Torvalds 2291da177e4SLinus Torvalds 2307d12e780SDavid Howells static void i_usX2Y_usbpcm_urb_complete(struct urb *urb) 2311da177e4SLinus Torvalds { 232bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = urb->context; 233bbe85bbdSTakashi Iwai struct usX2Ydev *usX2Y = subs->usX2Y; 234bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *capsubs, *capsubs2, *playbacksubs; 2351da177e4SLinus Torvalds 2361da177e4SLinus Torvalds if (unlikely(atomic_read(&subs->state) < state_PREPARED)) { 237bbe85bbdSTakashi Iwai snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", 238a014bbadSClemens Ladisch usb_get_current_frame_number(usX2Y->dev), 239bbe85bbdSTakashi Iwai subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", 240bbe85bbdSTakashi Iwai urb->status, urb->start_frame); 2411da177e4SLinus Torvalds return; 2421da177e4SLinus Torvalds } 2431da177e4SLinus Torvalds if (unlikely(urb->status)) { 2441da177e4SLinus Torvalds usX2Y_error_urb_status(usX2Y, subs, urb); 2451da177e4SLinus Torvalds return; 2461da177e4SLinus Torvalds } 2471da177e4SLinus Torvalds 248a9d14bc0SDaniel Mack subs->completed_urb = urb; 2491da177e4SLinus Torvalds capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; 2501da177e4SLinus Torvalds capsubs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 2511da177e4SLinus Torvalds playbacksubs = usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 2521da177e4SLinus Torvalds if (capsubs->completed_urb && atomic_read(&capsubs->state) >= state_PREPARED && 2531da177e4SLinus Torvalds (NULL == capsubs2 || capsubs2->completed_urb) && 2541da177e4SLinus Torvalds (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < state_PREPARED)) { 255635bbb35SKarsten Wiese if (!usX2Y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame)) 2561da177e4SLinus Torvalds usX2Y->wait_iso_frame += nr_of_packs(); 257635bbb35SKarsten Wiese else { 2581da177e4SLinus Torvalds snd_printdd("\n"); 2591da177e4SLinus Torvalds usX2Y_clients_stop(usX2Y); 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds } 2621da177e4SLinus Torvalds } 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds 2651da177e4SLinus Torvalds static void usX2Y_hwdep_urb_release(struct urb **urb) 2661da177e4SLinus Torvalds { 2671da177e4SLinus Torvalds usb_kill_urb(*urb); 2681da177e4SLinus Torvalds usb_free_urb(*urb); 2691da177e4SLinus Torvalds *urb = NULL; 2701da177e4SLinus Torvalds } 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds /* 2731da177e4SLinus Torvalds * release a substream 2741da177e4SLinus Torvalds */ 275bbe85bbdSTakashi Iwai static void usX2Y_usbpcm_urbs_release(struct snd_usX2Y_substream *subs) 2761da177e4SLinus Torvalds { 2771da177e4SLinus Torvalds int i; 2781da177e4SLinus Torvalds snd_printdd("snd_usX2Y_urbs_release() %i\n", subs->endpoint); 2791da177e4SLinus Torvalds for (i = 0; i < NRURBS; i++) 2801da177e4SLinus Torvalds usX2Y_hwdep_urb_release(subs->urb + i); 2811da177e4SLinus Torvalds } 2821da177e4SLinus Torvalds 283bbe85bbdSTakashi Iwai static void usX2Y_usbpcm_subs_startup_finish(struct usX2Ydev * usX2Y) 2841da177e4SLinus Torvalds { 2851da177e4SLinus Torvalds usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_urb_complete); 2861da177e4SLinus Torvalds usX2Y->prepare_subs = NULL; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 2897d12e780SDavid Howells static void i_usX2Y_usbpcm_subs_startup(struct urb *urb) 2901da177e4SLinus Torvalds { 291bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = urb->context; 292bbe85bbdSTakashi Iwai struct usX2Ydev *usX2Y = subs->usX2Y; 293bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs; 2941da177e4SLinus Torvalds if (NULL != prepare_subs && 2951da177e4SLinus Torvalds urb->start_frame == prepare_subs->urb[0]->start_frame) { 2961da177e4SLinus Torvalds atomic_inc(&prepare_subs->state); 2971da177e4SLinus Torvalds if (prepare_subs == usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]) { 298bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 2991da177e4SLinus Torvalds if (cap_subs2 != NULL) 3001da177e4SLinus Torvalds atomic_inc(&cap_subs2->state); 3011da177e4SLinus Torvalds } 3021da177e4SLinus Torvalds usX2Y_usbpcm_subs_startup_finish(usX2Y); 3031da177e4SLinus Torvalds wake_up(&usX2Y->prepare_wait_queue); 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds 3067d12e780SDavid Howells i_usX2Y_usbpcm_urb_complete(urb); 3071da177e4SLinus Torvalds } 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds /* 3101da177e4SLinus Torvalds * initialize a substream's urbs 3111da177e4SLinus Torvalds */ 312bbe85bbdSTakashi Iwai static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs) 3131da177e4SLinus Torvalds { 3141da177e4SLinus Torvalds int i; 3151da177e4SLinus Torvalds unsigned int pipe; 3161da177e4SLinus Torvalds int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 317a014bbadSClemens Ladisch struct usb_device *dev = subs->usX2Y->dev; 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) : 3201da177e4SLinus Torvalds usb_rcvisocpipe(dev, subs->endpoint); 3211da177e4SLinus Torvalds subs->maxpacksize = usb_maxpacket(dev, pipe, is_playback); 3221da177e4SLinus Torvalds if (!subs->maxpacksize) 3231da177e4SLinus Torvalds return -EINVAL; 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds /* allocate and initialize data urbs */ 3261da177e4SLinus Torvalds for (i = 0; i < NRURBS; i++) { 3271da177e4SLinus Torvalds struct urb **purb = subs->urb + i; 3281da177e4SLinus Torvalds if (*purb) { 3291da177e4SLinus Torvalds usb_kill_urb(*purb); 3301da177e4SLinus Torvalds continue; 3311da177e4SLinus Torvalds } 3321da177e4SLinus Torvalds *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL); 3331da177e4SLinus Torvalds if (NULL == *purb) { 3341da177e4SLinus Torvalds usX2Y_usbpcm_urbs_release(subs); 3351da177e4SLinus Torvalds return -ENOMEM; 3361da177e4SLinus Torvalds } 3371da177e4SLinus Torvalds (*purb)->transfer_buffer = is_playback ? 3381da177e4SLinus Torvalds subs->usX2Y->hwdep_pcm_shm->playback : ( 3391da177e4SLinus Torvalds subs->endpoint == 0x8 ? 3401da177e4SLinus Torvalds subs->usX2Y->hwdep_pcm_shm->capture0x8 : 3411da177e4SLinus Torvalds subs->usX2Y->hwdep_pcm_shm->capture0xA); 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds (*purb)->dev = dev; 3441da177e4SLinus Torvalds (*purb)->pipe = pipe; 3451da177e4SLinus Torvalds (*purb)->number_of_packets = nr_of_packs(); 3461da177e4SLinus Torvalds (*purb)->context = subs; 3471da177e4SLinus Torvalds (*purb)->interval = 1; 3481da177e4SLinus Torvalds (*purb)->complete = i_usX2Y_usbpcm_subs_startup; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds return 0; 3511da177e4SLinus Torvalds } 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds /* 3541da177e4SLinus Torvalds * free the buffer 3551da177e4SLinus Torvalds */ 356bbe85bbdSTakashi Iwai static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream) 3571da177e4SLinus Torvalds { 358bbe85bbdSTakashi Iwai struct snd_pcm_runtime *runtime = substream->runtime; 359bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = runtime->private_data, 3601da177e4SLinus Torvalds *cap_subs2 = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 361e2439a54STakashi Iwai mutex_lock(&subs->usX2Y->pcm_mutex); 3621da177e4SLinus Torvalds snd_printdd("snd_usX2Y_usbpcm_hw_free(%p)\n", substream); 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) { 365bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; 3661da177e4SLinus Torvalds atomic_set(&subs->state, state_STOPPED); 3671da177e4SLinus Torvalds usX2Y_usbpcm_urbs_release(subs); 3681da177e4SLinus Torvalds if (!cap_subs->pcm_substream || 3691da177e4SLinus Torvalds !cap_subs->pcm_substream->runtime || 3701da177e4SLinus Torvalds !cap_subs->pcm_substream->runtime->status || 3711da177e4SLinus Torvalds cap_subs->pcm_substream->runtime->status->state < SNDRV_PCM_STATE_PREPARED) { 3721da177e4SLinus Torvalds atomic_set(&cap_subs->state, state_STOPPED); 3731da177e4SLinus Torvalds if (NULL != cap_subs2) 3741da177e4SLinus Torvalds atomic_set(&cap_subs2->state, state_STOPPED); 3751da177e4SLinus Torvalds usX2Y_usbpcm_urbs_release(cap_subs); 3761da177e4SLinus Torvalds if (NULL != cap_subs2) 3771da177e4SLinus Torvalds usX2Y_usbpcm_urbs_release(cap_subs2); 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds } else { 380bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 3811da177e4SLinus Torvalds if (atomic_read(&playback_subs->state) < state_PREPARED) { 3821da177e4SLinus Torvalds atomic_set(&subs->state, state_STOPPED); 3831da177e4SLinus Torvalds if (NULL != cap_subs2) 3841da177e4SLinus Torvalds atomic_set(&cap_subs2->state, state_STOPPED); 3851da177e4SLinus Torvalds usX2Y_usbpcm_urbs_release(subs); 3861da177e4SLinus Torvalds if (NULL != cap_subs2) 3871da177e4SLinus Torvalds usX2Y_usbpcm_urbs_release(cap_subs2); 3881da177e4SLinus Torvalds } 3891da177e4SLinus Torvalds } 390e2439a54STakashi Iwai mutex_unlock(&subs->usX2Y->pcm_mutex); 3911da177e4SLinus Torvalds return snd_pcm_lib_free_pages(substream); 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds 394bbe85bbdSTakashi Iwai static void usX2Y_usbpcm_subs_startup(struct snd_usX2Y_substream *subs) 3951da177e4SLinus Torvalds { 396bbe85bbdSTakashi Iwai struct usX2Ydev * usX2Y = subs->usX2Y; 3971da177e4SLinus Torvalds usX2Y->prepare_subs = subs; 3981da177e4SLinus Torvalds subs->urb[0]->start_frame = -1; 3997f927fccSAlexey Dobriyan smp_wmb(); // Make sure above modifications are seen by i_usX2Y_subs_startup() 4001da177e4SLinus Torvalds usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_subs_startup); 4011da177e4SLinus Torvalds } 4021da177e4SLinus Torvalds 403bbe85bbdSTakashi Iwai static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) 4041da177e4SLinus Torvalds { 4051da177e4SLinus Torvalds int p, u, err, 4061da177e4SLinus Torvalds stream = subs->pcm_substream->stream; 407bbe85bbdSTakashi Iwai struct usX2Ydev *usX2Y = subs->usX2Y; 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds if (SNDRV_PCM_STREAM_CAPTURE == stream) { 4101da177e4SLinus Torvalds usX2Y->hwdep_pcm_shm->captured_iso_head = -1; 4111da177e4SLinus Torvalds usX2Y->hwdep_pcm_shm->captured_iso_frames = 0; 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds for (p = 0; 3 >= (stream + p); p += 2) { 415bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p]; 4161da177e4SLinus Torvalds if (subs != NULL) { 4171da177e4SLinus Torvalds if ((err = usX2Y_usbpcm_urbs_allocate(subs)) < 0) 4181da177e4SLinus Torvalds return err; 4191da177e4SLinus Torvalds subs->completed_urb = NULL; 4201da177e4SLinus Torvalds } 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds for (p = 0; p < 4; p++) { 424bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = usX2Y->subs[p]; 4251da177e4SLinus Torvalds if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED) 4261da177e4SLinus Torvalds goto start; 4271da177e4SLinus Torvalds } 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds start: 4301da177e4SLinus Torvalds usX2Y_usbpcm_subs_startup(subs); 4311da177e4SLinus Torvalds for (u = 0; u < NRURBS; u++) { 4321da177e4SLinus Torvalds for (p = 0; 3 >= (stream + p); p += 2) { 433bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p]; 4341da177e4SLinus Torvalds if (subs != NULL) { 4351da177e4SLinus Torvalds struct urb *urb = subs->urb[u]; 4361da177e4SLinus Torvalds if (usb_pipein(urb->pipe)) { 4371da177e4SLinus Torvalds unsigned long pack; 4381da177e4SLinus Torvalds if (0 == u) 4391da177e4SLinus Torvalds atomic_set(&subs->state, state_STARTING3); 440a014bbadSClemens Ladisch urb->dev = usX2Y->dev; 4411da177e4SLinus Torvalds for (pack = 0; pack < nr_of_packs(); pack++) { 4421da177e4SLinus Torvalds urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs()); 4431da177e4SLinus Torvalds urb->iso_frame_desc[pack].length = subs->maxpacksize; 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs(); 4461da177e4SLinus Torvalds if ((err = usb_submit_urb(urb, GFP_KERNEL)) < 0) { 4471da177e4SLinus Torvalds snd_printk (KERN_ERR "cannot usb_submit_urb() for urb %d, err = %d\n", u, err); 4481da177e4SLinus Torvalds err = -EPIPE; 4491da177e4SLinus Torvalds goto cleanup; 4501da177e4SLinus Torvalds } else { 4511da177e4SLinus Torvalds snd_printdd("%i\n", urb->start_frame); 452635bbb35SKarsten Wiese if (u == 0) 4531da177e4SLinus Torvalds usX2Y->wait_iso_frame = urb->start_frame; 4541da177e4SLinus Torvalds } 4551da177e4SLinus Torvalds urb->transfer_flags = 0; 4561da177e4SLinus Torvalds } else { 4571da177e4SLinus Torvalds atomic_set(&subs->state, state_STARTING1); 4581da177e4SLinus Torvalds break; 4591da177e4SLinus Torvalds } 4601da177e4SLinus Torvalds } 4611da177e4SLinus Torvalds } 4621da177e4SLinus Torvalds } 4631da177e4SLinus Torvalds err = 0; 4641da177e4SLinus Torvalds wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs); 4651da177e4SLinus Torvalds if (atomic_read(&subs->state) != state_PREPARED) 4661da177e4SLinus Torvalds err = -EPIPE; 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds cleanup: 4691da177e4SLinus Torvalds if (err) { 4701da177e4SLinus Torvalds usX2Y_subs_startup_finish(usX2Y); // Call it now 4711da177e4SLinus Torvalds usX2Y_clients_stop(usX2Y); // something is completely wroong > stop evrything 4721da177e4SLinus Torvalds } 4731da177e4SLinus Torvalds return err; 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds /* 4771da177e4SLinus Torvalds * prepare callback 4781da177e4SLinus Torvalds * 4791da177e4SLinus Torvalds * set format and initialize urbs 4801da177e4SLinus Torvalds */ 481bbe85bbdSTakashi Iwai static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream) 4821da177e4SLinus Torvalds { 483bbe85bbdSTakashi Iwai struct snd_pcm_runtime *runtime = substream->runtime; 484bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = runtime->private_data; 485bbe85bbdSTakashi Iwai struct usX2Ydev *usX2Y = subs->usX2Y; 486bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; 4871da177e4SLinus Torvalds int err = 0; 4881da177e4SLinus Torvalds snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream); 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds if (NULL == usX2Y->hwdep_pcm_shm) { 491bbe85bbdSTakashi Iwai if (NULL == (usX2Y->hwdep_pcm_shm = snd_malloc_pages(sizeof(struct snd_usX2Y_hwdep_pcm_shm), GFP_KERNEL))) 4921da177e4SLinus Torvalds return -ENOMEM; 493bbe85bbdSTakashi Iwai memset(usX2Y->hwdep_pcm_shm, 0, sizeof(struct snd_usX2Y_hwdep_pcm_shm)); 4941da177e4SLinus Torvalds } 4951da177e4SLinus Torvalds 496e2439a54STakashi Iwai mutex_lock(&usX2Y->pcm_mutex); 4971da177e4SLinus Torvalds usX2Y_subs_prepare(subs); 4981da177e4SLinus Torvalds // Start hardware streams 4991da177e4SLinus Torvalds // SyncStream first.... 5001da177e4SLinus Torvalds if (atomic_read(&capsubs->state) < state_PREPARED) { 5011da177e4SLinus Torvalds if (usX2Y->format != runtime->format) 5021da177e4SLinus Torvalds if ((err = usX2Y_format_set(usX2Y, runtime->format)) < 0) 5031da177e4SLinus Torvalds goto up_prepare_mutex; 5041da177e4SLinus Torvalds if (usX2Y->rate != runtime->rate) 5051da177e4SLinus Torvalds if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0) 5061da177e4SLinus Torvalds goto up_prepare_mutex; 507bbe85bbdSTakashi Iwai snd_printdd("starting capture pipe for %s\n", subs == capsubs ? 508bbe85bbdSTakashi Iwai "self" : "playpipe"); 5091da177e4SLinus Torvalds if (0 > (err = usX2Y_usbpcm_urbs_start(capsubs))) 5101da177e4SLinus Torvalds goto up_prepare_mutex; 5111da177e4SLinus Torvalds } 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds if (subs != capsubs) { 5141da177e4SLinus Torvalds usX2Y->hwdep_pcm_shm->playback_iso_start = -1; 5151da177e4SLinus Torvalds if (atomic_read(&subs->state) < state_PREPARED) { 516bbe85bbdSTakashi Iwai while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) > 517bbe85bbdSTakashi Iwai usX2Y->hwdep_pcm_shm->captured_iso_frames) { 518bbe85bbdSTakashi Iwai snd_printdd("Wait: iso_frames_per_buffer=%i," 519bbe85bbdSTakashi Iwai "captured_iso_frames=%i\n", 520bbe85bbdSTakashi Iwai usX2Y_iso_frames_per_buffer(runtime, usX2Y), 521bbe85bbdSTakashi Iwai usX2Y->hwdep_pcm_shm->captured_iso_frames); 522b27c187fSNishanth Aravamudan if (msleep_interruptible(10)) { 5231da177e4SLinus Torvalds err = -ERESTARTSYS; 5241da177e4SLinus Torvalds goto up_prepare_mutex; 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds } 5271da177e4SLinus Torvalds if (0 > (err = usX2Y_usbpcm_urbs_start(subs))) 5281da177e4SLinus Torvalds goto up_prepare_mutex; 5291da177e4SLinus Torvalds } 530bbe85bbdSTakashi Iwai snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", 531bbe85bbdSTakashi Iwai usX2Y_iso_frames_per_buffer(runtime, usX2Y), 532bbe85bbdSTakashi Iwai usX2Y->hwdep_pcm_shm->captured_iso_frames); 5331da177e4SLinus Torvalds } else 5341da177e4SLinus Torvalds usX2Y->hwdep_pcm_shm->capture_iso_start = -1; 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds up_prepare_mutex: 537e2439a54STakashi Iwai mutex_unlock(&usX2Y->pcm_mutex); 5381da177e4SLinus Torvalds return err; 5391da177e4SLinus Torvalds } 5401da177e4SLinus Torvalds 541bbe85bbdSTakashi Iwai static struct snd_pcm_hardware snd_usX2Y_4c = 5421da177e4SLinus Torvalds { 5431da177e4SLinus Torvalds .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 5441da177e4SLinus Torvalds SNDRV_PCM_INFO_BLOCK_TRANSFER | 5451da177e4SLinus Torvalds SNDRV_PCM_INFO_MMAP_VALID), 5461da177e4SLinus Torvalds .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE, 5471da177e4SLinus Torvalds .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, 5481da177e4SLinus Torvalds .rate_min = 44100, 5491da177e4SLinus Torvalds .rate_max = 48000, 5501da177e4SLinus Torvalds .channels_min = 2, 5511da177e4SLinus Torvalds .channels_max = 4, 5521da177e4SLinus Torvalds .buffer_bytes_max = (2*128*1024), 5531da177e4SLinus Torvalds .period_bytes_min = 64, 5541da177e4SLinus Torvalds .period_bytes_max = (128*1024), 5551da177e4SLinus Torvalds .periods_min = 2, 5561da177e4SLinus Torvalds .periods_max = 1024, 5571da177e4SLinus Torvalds .fifo_size = 0 5581da177e4SLinus Torvalds }; 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds 562bbe85bbdSTakashi Iwai static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream) 5631da177e4SLinus Torvalds { 564bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = ((struct snd_usX2Y_substream **) 5651da177e4SLinus Torvalds snd_pcm_substream_chip(substream))[substream->stream]; 566bbe85bbdSTakashi Iwai struct snd_pcm_runtime *runtime = substream->runtime; 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds if (!(subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)) 5691da177e4SLinus Torvalds return -EBUSY; 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds runtime->hw = SNDRV_PCM_STREAM_PLAYBACK == substream->stream ? snd_usX2Y_2c : 5721da177e4SLinus Torvalds (subs->usX2Y->subs[3] ? snd_usX2Y_4c : snd_usX2Y_2c); 5731da177e4SLinus Torvalds runtime->private_data = subs; 5741da177e4SLinus Torvalds subs->pcm_substream = substream; 5751da177e4SLinus Torvalds snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000); 5761da177e4SLinus Torvalds return 0; 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds 580bbe85bbdSTakashi Iwai static int snd_usX2Y_usbpcm_close(struct snd_pcm_substream *substream) 5811da177e4SLinus Torvalds { 582bbe85bbdSTakashi Iwai struct snd_pcm_runtime *runtime = substream->runtime; 583bbe85bbdSTakashi Iwai struct snd_usX2Y_substream *subs = runtime->private_data; 584cb432379STakashi Iwai 5851da177e4SLinus Torvalds subs->pcm_substream = NULL; 586cb432379STakashi Iwai return 0; 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds 590bbe85bbdSTakashi Iwai static struct snd_pcm_ops snd_usX2Y_usbpcm_ops = 5911da177e4SLinus Torvalds { 5921da177e4SLinus Torvalds .open = snd_usX2Y_usbpcm_open, 5931da177e4SLinus Torvalds .close = snd_usX2Y_usbpcm_close, 5941da177e4SLinus Torvalds .ioctl = snd_pcm_lib_ioctl, 5951da177e4SLinus Torvalds .hw_params = snd_usX2Y_pcm_hw_params, 5961da177e4SLinus Torvalds .hw_free = snd_usX2Y_usbpcm_hw_free, 5971da177e4SLinus Torvalds .prepare = snd_usX2Y_usbpcm_prepare, 5981da177e4SLinus Torvalds .trigger = snd_usX2Y_pcm_trigger, 5991da177e4SLinus Torvalds .pointer = snd_usX2Y_pcm_pointer, 6001da177e4SLinus Torvalds }; 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds 603e2439a54STakashi Iwai static int usX2Y_pcms_busy_check(struct snd_card *card) 6041da177e4SLinus Torvalds { 605e2439a54STakashi Iwai struct usX2Ydev *dev = usX2Y(card); 606e2439a54STakashi Iwai int i; 6071da177e4SLinus Torvalds 608e2439a54STakashi Iwai for (i = 0; i < dev->pcm_devs * 2; i++) { 609e2439a54STakashi Iwai struct snd_usX2Y_substream *subs = dev->subs[i]; 610e2439a54STakashi Iwai if (subs && subs->pcm_substream && 611e2439a54STakashi Iwai SUBSTREAM_BUSY(subs->pcm_substream)) 612e2439a54STakashi Iwai return -EBUSY; 6131da177e4SLinus Torvalds } 614e2439a54STakashi Iwai return 0; 6151da177e4SLinus Torvalds } 6161da177e4SLinus Torvalds 617bbe85bbdSTakashi Iwai static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file) 6181da177e4SLinus Torvalds { 619bbe85bbdSTakashi Iwai struct snd_card *card = hw->card; 620e2439a54STakashi Iwai int err; 621e2439a54STakashi Iwai 622e2439a54STakashi Iwai mutex_lock(&usX2Y(card)->pcm_mutex); 623e2439a54STakashi Iwai err = usX2Y_pcms_busy_check(card); 624e2439a54STakashi Iwai if (!err) 6251da177e4SLinus Torvalds usX2Y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS; 626e2439a54STakashi Iwai mutex_unlock(&usX2Y(card)->pcm_mutex); 6271da177e4SLinus Torvalds return err; 6281da177e4SLinus Torvalds } 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds 631bbe85bbdSTakashi Iwai static int snd_usX2Y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file) 6321da177e4SLinus Torvalds { 633bbe85bbdSTakashi Iwai struct snd_card *card = hw->card; 634e2439a54STakashi Iwai int err; 635e2439a54STakashi Iwai 636e2439a54STakashi Iwai mutex_lock(&usX2Y(card)->pcm_mutex); 637e2439a54STakashi Iwai err = usX2Y_pcms_busy_check(card); 638e2439a54STakashi Iwai if (!err) 6391da177e4SLinus Torvalds usX2Y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS; 640e2439a54STakashi Iwai mutex_unlock(&usX2Y(card)->pcm_mutex); 6411da177e4SLinus Torvalds return err; 6421da177e4SLinus Torvalds } 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds static void snd_usX2Y_hwdep_pcm_vm_open(struct vm_area_struct *area) 6461da177e4SLinus Torvalds { 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds static void snd_usX2Y_hwdep_pcm_vm_close(struct vm_area_struct *area) 6511da177e4SLinus Torvalds { 6521da177e4SLinus Torvalds } 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds 655eb415b8fSNick Piggin static int snd_usX2Y_hwdep_pcm_vm_fault(struct vm_area_struct *area, 656eb415b8fSNick Piggin struct vm_fault *vmf) 6571da177e4SLinus Torvalds { 6581da177e4SLinus Torvalds unsigned long offset; 6591da177e4SLinus Torvalds void *vaddr; 6601da177e4SLinus Torvalds 661eb415b8fSNick Piggin offset = vmf->pgoff << PAGE_SHIFT; 662bbe85bbdSTakashi Iwai vaddr = (char*)((struct usX2Ydev *)area->vm_private_data)->hwdep_pcm_shm + offset; 663eb415b8fSNick Piggin vmf->page = virt_to_page(vaddr); 664eb415b8fSNick Piggin get_page(vmf->page); 665eb415b8fSNick Piggin return 0; 6661da177e4SLinus Torvalds } 6671da177e4SLinus Torvalds 6681da177e4SLinus Torvalds 669f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct snd_usX2Y_hwdep_pcm_vm_ops = { 6701da177e4SLinus Torvalds .open = snd_usX2Y_hwdep_pcm_vm_open, 6711da177e4SLinus Torvalds .close = snd_usX2Y_hwdep_pcm_vm_close, 672eb415b8fSNick Piggin .fault = snd_usX2Y_hwdep_pcm_vm_fault, 6731da177e4SLinus Torvalds }; 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds 676bbe85bbdSTakashi Iwai static int snd_usX2Y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) 6771da177e4SLinus Torvalds { 6781da177e4SLinus Torvalds unsigned long size = (unsigned long)(area->vm_end - area->vm_start); 679bbe85bbdSTakashi Iwai struct usX2Ydev *usX2Y = hw->private_data; 6801da177e4SLinus Torvalds 681cb432379STakashi Iwai if (!(usX2Y->chip_status & USX2Y_STAT_CHIP_INIT)) 6821da177e4SLinus Torvalds return -EBUSY; 6831da177e4SLinus Torvalds 6841da177e4SLinus Torvalds /* if userspace tries to mmap beyond end of our buffer, fail */ 685bbe85bbdSTakashi Iwai if (size > PAGE_ALIGN(sizeof(struct snd_usX2Y_hwdep_pcm_shm))) { 686bbe85bbdSTakashi Iwai snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(struct snd_usX2Y_hwdep_pcm_shm)); 6871da177e4SLinus Torvalds return -EINVAL; 6881da177e4SLinus Torvalds } 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds if (!usX2Y->hwdep_pcm_shm) { 6911da177e4SLinus Torvalds return -ENODEV; 6921da177e4SLinus Torvalds } 6931da177e4SLinus Torvalds area->vm_ops = &snd_usX2Y_hwdep_pcm_vm_ops; 694314e51b9SKonstantin Khlebnikov area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; 6951da177e4SLinus Torvalds area->vm_private_data = hw->private_data; 6961da177e4SLinus Torvalds return 0; 6971da177e4SLinus Torvalds } 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds 700bbe85bbdSTakashi Iwai static void snd_usX2Y_hwdep_pcm_private_free(struct snd_hwdep *hwdep) 7011da177e4SLinus Torvalds { 702bbe85bbdSTakashi Iwai struct usX2Ydev *usX2Y = hwdep->private_data; 7031da177e4SLinus Torvalds if (NULL != usX2Y->hwdep_pcm_shm) 704bbe85bbdSTakashi Iwai snd_free_pages(usX2Y->hwdep_pcm_shm, sizeof(struct snd_usX2Y_hwdep_pcm_shm)); 7051da177e4SLinus Torvalds } 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds 708bbe85bbdSTakashi Iwai int usX2Y_hwdep_pcm_new(struct snd_card *card) 7091da177e4SLinus Torvalds { 7101da177e4SLinus Torvalds int err; 711bbe85bbdSTakashi Iwai struct snd_hwdep *hw; 712bbe85bbdSTakashi Iwai struct snd_pcm *pcm; 713a014bbadSClemens Ladisch struct usb_device *dev = usX2Y(card)->dev; 7141da177e4SLinus Torvalds if (1 != nr_of_packs()) 7151da177e4SLinus Torvalds return 0; 7161da177e4SLinus Torvalds 717cb432379STakashi Iwai if ((err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw)) < 0) 7181da177e4SLinus Torvalds return err; 719cb432379STakashi Iwai 7201da177e4SLinus Torvalds hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM; 7211da177e4SLinus Torvalds hw->private_data = usX2Y(card); 7221da177e4SLinus Torvalds hw->private_free = snd_usX2Y_hwdep_pcm_private_free; 7231da177e4SLinus Torvalds hw->ops.open = snd_usX2Y_hwdep_pcm_open; 7241da177e4SLinus Torvalds hw->ops.release = snd_usX2Y_hwdep_pcm_release; 7251da177e4SLinus Torvalds hw->ops.mmap = snd_usX2Y_hwdep_pcm_mmap; 7261da177e4SLinus Torvalds hw->exclusive = 1; 7271da177e4SLinus Torvalds sprintf(hw->name, "/proc/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum); 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds err = snd_pcm_new(card, NAME_ALLCAPS" hwdep Audio", 2, 1, 1, &pcm); 7301da177e4SLinus Torvalds if (err < 0) { 7311da177e4SLinus Torvalds return err; 7321da177e4SLinus Torvalds } 7331da177e4SLinus Torvalds snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usX2Y_usbpcm_ops); 7341da177e4SLinus Torvalds snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_usbpcm_ops); 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds pcm->private_data = usX2Y(card)->subs; 7371da177e4SLinus Torvalds pcm->info_flags = 0; 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio"); 7401da177e4SLinus Torvalds if (0 > (err = snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream, 7411da177e4SLinus Torvalds SNDRV_DMA_TYPE_CONTINUOUS, 7421da177e4SLinus Torvalds snd_dma_continuous_data(GFP_KERNEL), 7431da177e4SLinus Torvalds 64*1024, 128*1024)) || 7441da177e4SLinus Torvalds 0 > (err = snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, 7451da177e4SLinus Torvalds SNDRV_DMA_TYPE_CONTINUOUS, 7461da177e4SLinus Torvalds snd_dma_continuous_data(GFP_KERNEL), 7471da177e4SLinus Torvalds 64*1024, 128*1024))) { 7481da177e4SLinus Torvalds return err; 7491da177e4SLinus Torvalds } 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds return 0; 7531da177e4SLinus Torvalds } 7541da177e4SLinus Torvalds 7551da177e4SLinus Torvalds #else 7561da177e4SLinus Torvalds 757bbe85bbdSTakashi Iwai int usX2Y_hwdep_pcm_new(struct snd_card *card) 7581da177e4SLinus Torvalds { 7591da177e4SLinus Torvalds return 0; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds #endif 763