1 files changed, 102 insertions, 104 deletions

diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c
index c9136a98755f..796a7dcef09d 100644
--- a/sound/usb/usx2y/usx2yhwdeppcm.c
+++ b/sound/usb/usx2y/usx2yhwdeppcm.c
@@ -58,12 +58,12 @@
 #include <sound/hwdep.h>
 
 
-static int usX2Y_usbpcm_urb_capt_retire(snd_usX2Y_substream_t *subs)
+static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs)
 {
         struct urb      *urb = subs->completed_urb;
-        snd_pcm_runtime_t *runtime = subs->pcm_substream->runtime;
+        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
         int             i, lens = 0, hwptr_done = subs->hwptr_done;
-        usX2Ydev_t      *usX2Y = subs->usX2Y;
+        struct usX2Ydev *usX2Y = subs->usX2Y;
         if (0 > usX2Y->hwdep_pcm_shm->capture_iso_start) { //FIXME
                 int head = usX2Y->hwdep_pcm_shm->captured_iso_head + 1;
                 if (head >= ARRAY_SIZE(usX2Y->hwdep_pcm_shm->captured_iso))
@@ -90,7 +90,8 @@ static int usX2Y_usbpcm_urb_capt_retire(snd_usX2Y_substream_t *subs)
         return 0;
 }
 
-static inline int usX2Y_iso_frames_per_buffer(snd_pcm_runtime_t *runtime, usX2Ydev_t * usX2Y)
+static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime,
+                                              struct usX2Ydev * usX2Y)
 {
         return (runtime->buffer_size * 1000) / usX2Y->rate + 1; //FIXME: so far only correct period_size == 2^x ?
 }
@@ -105,13 +106,13 @@ static inline int usX2Y_iso_frames_per_buffer(snd_pcm_runtime_t *runtime, usX2Yd
  * it directly from the buffer.  thus the data is once copied to
  * a temporary buffer and urb points to that.
  */
-static int usX2Y_hwdep_urb_play_prepare(snd_usX2Y_substream_t *subs,
-                                  struct urb *urb)
+static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs,
+                                        struct urb *urb)
 {
         int count, counts, pack;
-        usX2Ydev_t *usX2Y = subs->usX2Y;
+        struct usX2Ydev *usX2Y = subs->usX2Y;
         struct snd_usX2Y_hwdep_pcm_shm *shm = usX2Y->hwdep_pcm_shm;
-        snd_pcm_runtime_t *runtime = subs->pcm_substream->runtime;
+        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
 
         if (0 > shm->playback_iso_start) {
                 shm->playback_iso_start = shm->captured_iso_head -
@@ -144,13 +145,14 @@ static int usX2Y_hwdep_urb_play_prepare(snd_usX2Y_substream_t *subs,
 }
 
 
-static inline void usX2Y_usbpcm_urb_capt_iso_advance(snd_usX2Y_substream_t *subs, struct urb *urb)
+static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream *subs,
+                                                     struct urb *urb)
 {
         int pack;
         for (pack = 0; pack < nr_of_packs(); ++pack) {
                 struct usb_iso_packet_descriptor *desc = urb->iso_frame_desc + pack;
                 if (NULL != subs) {
-                        snd_usX2Y_hwdep_pcm_shm_t *shm = subs->usX2Y->hwdep_pcm_shm;
+                        struct snd_usX2Y_hwdep_pcm_shm *shm = subs->usX2Y->hwdep_pcm_shm;
                         int head = shm->captured_iso_head + 1;
                         if (head >= ARRAY_SIZE(shm->captured_iso))
                                 head = 0;
@@ -166,9 +168,10 @@ static inline void usX2Y_usbpcm_urb_capt_iso_advance(snd_usX2Y_substream_t *subs
         }
 }
 
-static inline int usX2Y_usbpcm_usbframe_complete(snd_usX2Y_substream_t *capsubs,
-                                           snd_usX2Y_substream_t *capsubs2,
-                                           snd_usX2Y_substream_t *playbacksubs, int frame)
+static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *capsubs,
+                                                 struct snd_usX2Y_substream *capsubs2,
+                                                 struct snd_usX2Y_substream *playbacksubs,
+                                                 int frame)
 {
         int err, state;
         struct urb *urb = playbacksubs->completed_urb;
@@ -177,10 +180,8 @@ static inline int usX2Y_usbpcm_usbframe_complete(snd_usX2Y_substream_t *capsubs,
         if (NULL != urb) {
                 if (state == state_RUNNING)
                         usX2Y_urb_play_retire(playbacksubs, urb);
-                else
-                        if (state >= state_PRERUNNING) {
-                                atomic_inc(&playbacksubs->state);
-                        }
+                else if (state >= state_PRERUNNING)
+                        atomic_inc(&playbacksubs->state);
         } else {
                 switch (state) {
                 case state_STARTING1:
@@ -207,10 +208,8 @@ static inline int usX2Y_usbpcm_usbframe_complete(snd_usX2Y_substream_t *capsubs,
                 if (state == state_RUNNING) {
                         if ((err = usX2Y_usbpcm_urb_capt_retire(capsubs)))
                                 return err;
-                } else {
-                        if (state >= state_PRERUNNING)
-                                atomic_inc(&capsubs->state);
-                }
+                } else if (state >= state_PRERUNNING)
+                        atomic_inc(&capsubs->state);
                 usX2Y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb);
                 if (NULL != capsubs2)
                         usX2Y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb);
@@ -229,12 +228,15 @@ static inline int usX2Y_usbpcm_usbframe_complete(snd_usX2Y_substream_t *capsubs,
 
 static void i_usX2Y_usbpcm_urb_complete(struct urb *urb, struct pt_regs *regs)
 {
-        snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t*)urb->context;
-        usX2Ydev_t *usX2Y = subs->usX2Y;
-        snd_usX2Y_substream_t *capsubs, *capsubs2, *playbacksubs;
+        struct snd_usX2Y_substream *subs = urb->context;
+        struct usX2Ydev *usX2Y = subs->usX2Y;
+        struct snd_usX2Y_substream *capsubs, *capsubs2, *playbacksubs;
 
         if (unlikely(atomic_read(&subs->state) < state_PREPARED)) {
-                snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", usb_get_current_frame_number(usX2Y->chip.dev), subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", urb->status, urb->start_frame);
+                snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
+                            usb_get_current_frame_number(usX2Y->chip.dev),
+                            subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
+                            urb->status, urb->start_frame);
                 return;
         }
         if (unlikely(urb->status)) {
@@ -268,7 +270,7 @@ static void i_usX2Y_usbpcm_urb_complete(struct urb *urb, struct pt_regs *regs)
 }
 
 
-static void usX2Y_hwdep_urb_release(struct urb** urb)
+static void usX2Y_hwdep_urb_release(struct urb **urb)
 {
         usb_kill_urb(*urb);
         usb_free_urb(*urb);
@@ -278,7 +280,7 @@ static void usX2Y_hwdep_urb_release(struct urb** urb)
 /*
  * release a substream
  */
-static void usX2Y_usbpcm_urbs_release(snd_usX2Y_substream_t *subs)
+static void usX2Y_usbpcm_urbs_release(struct snd_usX2Y_substream *subs)
 {
         int i;
         snd_printdd("snd_usX2Y_urbs_release() %i\n", subs->endpoint);
@@ -286,7 +288,7 @@ static void usX2Y_usbpcm_urbs_release(snd_usX2Y_substream_t *subs)
                 usX2Y_hwdep_urb_release(subs->urb + i);
 }
 
-static void usX2Y_usbpcm_subs_startup_finish(usX2Ydev_t * usX2Y)
+static void usX2Y_usbpcm_subs_startup_finish(struct usX2Ydev * usX2Y)
 {
         usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_urb_complete);
         usX2Y->prepare_subs = NULL;
@@ -294,14 +296,14 @@ static void usX2Y_usbpcm_subs_startup_finish(usX2Ydev_t * usX2Y)
 
 static void i_usX2Y_usbpcm_subs_startup(struct urb *urb, struct pt_regs *regs)
 {
-        snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t*)urb->context;
-        usX2Ydev_t *usX2Y = subs->usX2Y;
-        snd_usX2Y_substream_t *prepare_subs = usX2Y->prepare_subs;
+        struct snd_usX2Y_substream *subs = urb->context;
+        struct usX2Ydev *usX2Y = subs->usX2Y;
+        struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs;
         if (NULL != prepare_subs &&
             urb->start_frame == prepare_subs->urb[0]->start_frame) {
                 atomic_inc(&prepare_subs->state);
                 if (prepare_subs == usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]) {
-                        snd_usX2Y_substream_t *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
+                        struct snd_usX2Y_substream *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
                         if (cap_subs2 != NULL)
                                 atomic_inc(&cap_subs2->state);
                 }
@@ -315,7 +317,7 @@ static void i_usX2Y_usbpcm_subs_startup(struct urb *urb, struct pt_regs *regs)
 /*
  * initialize a substream's urbs
  */
-static int usX2Y_usbpcm_urbs_allocate(snd_usX2Y_substream_t *subs)
+static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs)
 {
         int i;
         unsigned int pipe;
@@ -330,7 +332,7 @@ static int usX2Y_usbpcm_urbs_allocate(snd_usX2Y_substream_t *subs)
 
         /* allocate and initialize data urbs */
         for (i = 0; i < NRURBS; i++) {
-                struct urb** purb = subs->urb + i;
+                struct urb **purb = subs->urb + i;
                 if (*purb) {
                         usb_kill_urb(*purb);
                         continue;
@@ -359,16 +361,16 @@ static int usX2Y_usbpcm_urbs_allocate(snd_usX2Y_substream_t *subs)
 /*
  * free the buffer
  */
-static int snd_usX2Y_usbpcm_hw_free(snd_pcm_substream_t *substream)
+static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data,
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_usX2Y_substream *subs = runtime->private_data,
                 *cap_subs2 = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
         down(&subs->usX2Y->prepare_mutex);
         snd_printdd("snd_usX2Y_usbpcm_hw_free(%p)\n", substream);
 
         if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) {
-                snd_usX2Y_substream_t *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
+                struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
                 atomic_set(&subs->state, state_STOPPED);
                 usX2Y_usbpcm_urbs_release(subs);
                 if (!cap_subs->pcm_substream ||
@@ -383,7 +385,7 @@ static int snd_usX2Y_usbpcm_hw_free(snd_pcm_substream_t *substream)
                                 usX2Y_usbpcm_urbs_release(cap_subs2);
                 }
         } else {
-                snd_usX2Y_substream_t *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
+                struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
                 if (atomic_read(&playback_subs->state) < state_PREPARED) {
                         atomic_set(&subs->state, state_STOPPED);
                         if (NULL != cap_subs2)
@@ -397,20 +399,20 @@ static int snd_usX2Y_usbpcm_hw_free(snd_pcm_substream_t *substream)
         return snd_pcm_lib_free_pages(substream);
 }
 
-static void usX2Y_usbpcm_subs_startup(snd_usX2Y_substream_t *subs)
+static void usX2Y_usbpcm_subs_startup(struct snd_usX2Y_substream *subs)
 {
-        usX2Ydev_t * usX2Y = subs->usX2Y;
+        struct usX2Ydev * usX2Y = subs->usX2Y;
         usX2Y->prepare_subs = subs;
         subs->urb[0]->start_frame = -1;
         smp_wmb();      // Make shure above modifications are seen by i_usX2Y_subs_startup()
         usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_subs_startup);
 }
 
-static int usX2Y_usbpcm_urbs_start(snd_usX2Y_substream_t *subs)
+static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs)
 {
         int     p, u, err,
                 stream = subs->pcm_substream->stream;
-        usX2Ydev_t *usX2Y = subs->usX2Y;
+        struct usX2Ydev *usX2Y = subs->usX2Y;
 
         if (SNDRV_PCM_STREAM_CAPTURE == stream) {
                 usX2Y->hwdep_pcm_shm->captured_iso_head = -1;
@@ -418,7 +420,7 @@ static int usX2Y_usbpcm_urbs_start(snd_usX2Y_substream_t *subs)
         }
 
         for (p = 0; 3 >= (stream + p); p += 2) {
-                snd_usX2Y_substream_t *subs = usX2Y->subs[stream + p];
+                struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p];
                 if (subs != NULL) {
                         if ((err = usX2Y_usbpcm_urbs_allocate(subs)) < 0)
                                 return err;
@@ -427,7 +429,7 @@ static int usX2Y_usbpcm_urbs_start(snd_usX2Y_substream_t *subs)
         }
 
         for (p = 0; p < 4; p++) {
-                snd_usX2Y_substream_t *subs = usX2Y->subs[p];
+                struct snd_usX2Y_substream *subs = usX2Y->subs[p];
                 if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED)
                         goto start;
         }
@@ -437,7 +439,7 @@ static int usX2Y_usbpcm_urbs_start(snd_usX2Y_substream_t *subs)
         usX2Y_usbpcm_subs_startup(subs);
         for (u = 0; u < NRURBS; u++) {
                 for (p = 0; 3 >= (stream + p); p += 2) {
-                        snd_usX2Y_substream_t *subs = usX2Y->subs[stream + p];
+                        struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p];
                         if (subs != NULL) {
                                 struct urb *urb = subs->urb[u];
                                 if (usb_pipein(urb->pipe)) {
@@ -486,19 +488,19 @@ static int usX2Y_usbpcm_urbs_start(snd_usX2Y_substream_t *subs)
  *
  * set format and initialize urbs
  */
-static int snd_usX2Y_usbpcm_prepare(snd_pcm_substream_t *substream)
+static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data;
-        usX2Ydev_t *usX2Y = subs->usX2Y;
-        snd_usX2Y_substream_t *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_usX2Y_substream *subs = runtime->private_data;
+        struct usX2Ydev *usX2Y = subs->usX2Y;
+        struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
         int err = 0;
         snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream);
 
         if (NULL == usX2Y->hwdep_pcm_shm) {
-                if (NULL == (usX2Y->hwdep_pcm_shm = snd_malloc_pages(sizeof(snd_usX2Y_hwdep_pcm_shm_t), GFP_KERNEL)))
+                if (NULL == (usX2Y->hwdep_pcm_shm = snd_malloc_pages(sizeof(struct snd_usX2Y_hwdep_pcm_shm), GFP_KERNEL)))
                         return -ENOMEM;
-                memset(usX2Y->hwdep_pcm_shm, 0, sizeof(snd_usX2Y_hwdep_pcm_shm_t));
+                memset(usX2Y->hwdep_pcm_shm, 0, sizeof(struct snd_usX2Y_hwdep_pcm_shm));
         }
 
         down(&usX2Y->prepare_mutex);
@@ -512,7 +514,8 @@ static int snd_usX2Y_usbpcm_prepare(snd_pcm_substream_t *substream)
                 if (usX2Y->rate != runtime->rate)
                         if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0)
                                 goto up_prepare_mutex;
-                snd_printdd("starting capture pipe for %s\n", subs == capsubs ? "self" : "playpipe");
+                snd_printdd("starting capture pipe for %s\n", subs == capsubs ?
+                            "self" : "playpipe");
                 if (0 > (err = usX2Y_usbpcm_urbs_start(capsubs)))
                         goto up_prepare_mutex;
         }
@@ -520,8 +523,12 @@ static int snd_usX2Y_usbpcm_prepare(snd_pcm_substream_t *substream)
         if (subs != capsubs) {
                 usX2Y->hwdep_pcm_shm->playback_iso_start = -1;
                 if (atomic_read(&subs->state) < state_PREPARED) {
-                        while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) > usX2Y->hwdep_pcm_shm->captured_iso_frames) {
-                                snd_printd("Wait: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", usX2Y_iso_frames_per_buffer(runtime, usX2Y), usX2Y->hwdep_pcm_shm->captured_iso_frames);
+                        while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) >
+                               usX2Y->hwdep_pcm_shm->captured_iso_frames) {
+                                snd_printdd("Wait: iso_frames_per_buffer=%i,"
+                                            "captured_iso_frames=%i\n",
+                                            usX2Y_iso_frames_per_buffer(runtime, usX2Y),
+                                            usX2Y->hwdep_pcm_shm->captured_iso_frames);
                                 if (msleep_interruptible(10)) {
                                         err = -ERESTARTSYS;
                                         goto up_prepare_mutex;
@@ -530,7 +537,9 @@ static int snd_usX2Y_usbpcm_prepare(snd_pcm_substream_t *substream)
                         if (0 > (err = usX2Y_usbpcm_urbs_start(subs)))
                                 goto up_prepare_mutex;
                 }
-                snd_printd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", usX2Y_iso_frames_per_buffer(runtime, usX2Y), usX2Y->hwdep_pcm_shm->captured_iso_frames);
+                snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n",
+                            usX2Y_iso_frames_per_buffer(runtime, usX2Y),
+                            usX2Y->hwdep_pcm_shm->captured_iso_frames);
         } else
                 usX2Y->hwdep_pcm_shm->capture_iso_start = -1;
 
@@ -539,7 +548,7 @@ static int snd_usX2Y_usbpcm_prepare(snd_pcm_substream_t *substream)
         return err;
 }
 
-static snd_pcm_hardware_t snd_usX2Y_4c =
+static struct snd_pcm_hardware snd_usX2Y_4c =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -560,11 +569,11 @@ static snd_pcm_hardware_t snd_usX2Y_4c =
 
 
 
-static int snd_usX2Y_usbpcm_open(snd_pcm_substream_t *substream)
+static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream)
 {
-        snd_usX2Y_substream_t   *subs = ((snd_usX2Y_substream_t **)
+        struct snd_usX2Y_substream      *subs = ((struct snd_usX2Y_substream **)
                                          snd_pcm_substream_chip(substream))[substream->stream];
-        snd_pcm_runtime_t       *runtime = substream->runtime;
+        struct snd_pcm_runtime  *runtime = substream->runtime;
 
         if (!(subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS))
                 return -EBUSY;
@@ -578,18 +587,17 @@ static int snd_usX2Y_usbpcm_open(snd_pcm_substream_t *substream)
 }
 
 
-static int snd_usX2Y_usbpcm_close(snd_pcm_substream_t *substream)
+static int snd_usX2Y_usbpcm_close(struct snd_pcm_substream *substream)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data;
-        int err = 0;
-        snd_printd("\n");
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_usX2Y_substream *subs = runtime->private_data;
+
         subs->pcm_substream = NULL;
-        return err;
+        return 0;
 }
 
 
-static snd_pcm_ops_t snd_usX2Y_usbpcm_ops = 
+static struct snd_pcm_ops snd_usX2Y_usbpcm_ops = 
 {
         .open =         snd_usX2Y_usbpcm_open,
         .close =        snd_usX2Y_usbpcm_close,
@@ -602,11 +610,11 @@ static snd_pcm_ops_t snd_usX2Y_usbpcm_ops =
 };
 
 
-static int usX2Y_pcms_lock_check(snd_card_t *card)
+static int usX2Y_pcms_lock_check(struct snd_card *card)
 {
         struct list_head *list;
-        snd_device_t *dev;
-        snd_pcm_t *pcm;
+        struct snd_device *dev;
+        struct snd_pcm *pcm;
         int err = 0;
         list_for_each(list, &card->devices) {
                 dev = snd_device(list);
@@ -622,7 +630,7 @@ static int usX2Y_pcms_lock_check(snd_card_t *card)
                         continue;
                 pcm = dev->device_data;
                 for (s = 0; s < 2; ++s) {
-                        snd_pcm_substream_t *substream;
+                        struct snd_pcm_substream *substream;
                         substream = pcm->streams[s].substream;
                         if (substream && substream->ffile != NULL)
                                 err = -EBUSY;
@@ -632,11 +640,11 @@ static int usX2Y_pcms_lock_check(snd_card_t *card)
 }
 
 
-static void usX2Y_pcms_unlock(snd_card_t *card)
+static void usX2Y_pcms_unlock(struct snd_card *card)
 {
         struct list_head *list;
-        snd_device_t *dev;
-        snd_pcm_t *pcm;
+        struct snd_device *dev;
+        struct snd_pcm *pcm;
         list_for_each(list, &card->devices) {
                 dev = snd_device(list);
                 if (dev->type != SNDRV_DEV_PCM)
@@ -647,10 +655,10 @@ static void usX2Y_pcms_unlock(snd_card_t *card)
 }
 
 
-static int snd_usX2Y_hwdep_pcm_open(snd_hwdep_t *hw, struct file *file)
+static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file)
 {
         // we need to be the first 
-        snd_card_t *card = hw->card;
+        struct snd_card *card = hw->card;
         int err = usX2Y_pcms_lock_check(card);
         if (0 == err)
                 usX2Y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS;
@@ -659,9 +667,9 @@ static int snd_usX2Y_hwdep_pcm_open(snd_hwdep_t *hw, struct file *file)
 }
 
 
-static int snd_usX2Y_hwdep_pcm_release(snd_hwdep_t *hw, struct file *file)
+static int snd_usX2Y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file)
 {
-        snd_card_t *card = hw->card;
+        struct snd_card *card = hw->card;
         int err = usX2Y_pcms_lock_check(card);
         if (0 == err)
                 usX2Y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS;
@@ -689,7 +697,7 @@ static struct page * snd_usX2Y_hwdep_pcm_vm_nopage(struct vm_area_struct *area,
         offset = area->vm_pgoff << PAGE_SHIFT;
         offset += address - area->vm_start;
         snd_assert((offset % PAGE_SIZE) == 0, return NOPAGE_OOM);
-        vaddr = (char*)((usX2Ydev_t*)area->vm_private_data)->hwdep_pcm_shm + offset;
+        vaddr = (char*)((struct usX2Ydev *)area->vm_private_data)->hwdep_pcm_shm + offset;
         page = virt_to_page(vaddr);
         get_page(page);
 
@@ -707,17 +715,17 @@ static struct vm_operations_struct snd_usX2Y_hwdep_pcm_vm_ops = {
 };
 
 
-static int snd_usX2Y_hwdep_pcm_mmap(snd_hwdep_t * hw, struct file *filp, struct vm_area_struct *area)
+static int snd_usX2Y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area)
 {
         unsigned long   size = (unsigned long)(area->vm_end - area->vm_start);
-        usX2Ydev_t      *usX2Y = (usX2Ydev_t*)hw->private_data;
+        struct usX2Ydev *usX2Y = hw->private_data;
 
-        if (!(((usX2Ydev_t*)hw->private_data)->chip_status & USX2Y_STAT_CHIP_INIT))
+        if (!(usX2Y->chip_status & USX2Y_STAT_CHIP_INIT))
                 return -EBUSY;
 
         /* if userspace tries to mmap beyond end of our buffer, fail */ 
-        if (size > PAGE_ALIGN(sizeof(snd_usX2Y_hwdep_pcm_shm_t))) {
-                snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(snd_usX2Y_hwdep_pcm_shm_t)); 
+        if (size > PAGE_ALIGN(sizeof(struct snd_usX2Y_hwdep_pcm_shm))) {
+                snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(struct snd_usX2Y_hwdep_pcm_shm)); 
                 return -EINVAL;
         }
 
@@ -726,39 +734,31 @@ static int snd_usX2Y_hwdep_pcm_mmap(snd_hwdep_t * hw, struct file *filp, struct
         }
         area->vm_ops = &snd_usX2Y_hwdep_pcm_vm_ops;
         area->vm_flags |= VM_RESERVED;
-        snd_printd("vm_flags=0x%lX\n", area->vm_flags);
         area->vm_private_data = hw->private_data;
         return 0;
 }
 
 
-static void snd_usX2Y_hwdep_pcm_private_free(snd_hwdep_t *hwdep)
+static void snd_usX2Y_hwdep_pcm_private_free(struct snd_hwdep *hwdep)
 {
-        usX2Ydev_t *usX2Y = (usX2Ydev_t *)hwdep->private_data;
+        struct usX2Ydev *usX2Y = hwdep->private_data;
         if (NULL != usX2Y->hwdep_pcm_shm)
-                snd_free_pages(usX2Y->hwdep_pcm_shm, sizeof(snd_usX2Y_hwdep_pcm_shm_t));
+                snd_free_pages(usX2Y->hwdep_pcm_shm, sizeof(struct snd_usX2Y_hwdep_pcm_shm));
 }
 
 
-static void snd_usX2Y_usbpcm_private_free(snd_pcm_t *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
-
-int usX2Y_hwdep_pcm_new(snd_card_t* card)
+int usX2Y_hwdep_pcm_new(struct snd_card *card)
 {
         int err;
-        snd_hwdep_t *hw;
-        snd_pcm_t *pcm;
+        struct snd_hwdep *hw;
+        struct snd_pcm *pcm;
         struct usb_device *dev = usX2Y(card)->chip.dev;
         if (1 != nr_of_packs())
                 return 0;
 
-        if ((err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw)) < 0) {
-                snd_printd("\n");
+        if ((err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw)) < 0)
                 return err;
-        }
+
         hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM;
         hw->private_data = usX2Y(card);
         hw->private_free = snd_usX2Y_hwdep_pcm_private_free;
@@ -776,7 +776,6 @@ int usX2Y_hwdep_pcm_new(snd_card_t* card)
         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_usbpcm_ops);
 
         pcm->private_data = usX2Y(card)->subs;
-        pcm->private_free = snd_usX2Y_usbpcm_private_free;
         pcm->info_flags = 0;
 
         sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio");
@@ -788,7 +787,6 @@ int usX2Y_hwdep_pcm_new(snd_card_t* card)
                                                      SNDRV_DMA_TYPE_CONTINUOUS,
                                                      snd_dma_continuous_data(GFP_KERNEL),
                                                      64*1024, 128*1024))) {
-                snd_usX2Y_usbpcm_private_free(pcm);
                 return err;
         }
 
@@ -798,7 +796,7 @@ int usX2Y_hwdep_pcm_new(snd_card_t* card)
 
 #else
 
-int usX2Y_hwdep_pcm_new(snd_card_t* card)
+int usX2Y_hwdep_pcm_new(struct snd_card *card)
 {
         return 0;
 }