]> nv-tegra.nvidia Code Review - linux-3.10.git/commitdiff
Merge git://git.kernel.org/pub/scm/linux/kernel/git/perex/alsa
authorLinus Torvalds <torvalds@g5.osdl.org>
Thu, 5 Jan 2006 00:38:36 +0000 (16:38 -0800)
committerLinus Torvalds <torvalds@g5.osdl.org>
Thu, 5 Jan 2006 00:38:36 +0000 (16:38 -0800)
1  2 
MAINTAINERS
include/linux/pci_ids.h
sound/usb/usbaudio.c
sound/usb/usx2y/usbusx2y.c

diff --combined MAINTAINERS
index b524ca363081a167e82cab87b6da596d16f51ac4,93f97b3afac501e144e89389ee1e7d38e1fe0324..1e59d39660128571019911431840acb2c06dd757
@@@ -650,6 -650,11 +650,11 @@@ L:       linux-crypto@vger.kernel.or
  T:    git kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6.git
  S:    Maintained
  
+ CS5535 Audio ALSA driver
+ P:    Jaya Kumar
+ M:    jayakumar.alsa@gmail.com
+ S:    Maintained
  CYBERPRO FB DRIVER
  P:    Russell King
  M:    rmk@arm.linux.org.uk
@@@ -1465,6 -1470,7 +1470,6 @@@ P:      Severa
  L:    kernel-janitors@osdl.org
  W:    http://www.kerneljanitors.org/
  W:    http://sf.net/projects/kernel-janitor/
 -W:    http://developer.osdl.org/rddunlap/kj-patches/
  S:    Maintained
  
  KERNEL NFSD
@@@ -1485,7 -1491,7 +1490,7 @@@ KEXE
  P:    Eric Biederman
  P:    Randy Dunlap
  M:    ebiederm@xmission.com
 -M:    rddunlap@osdl.org
 +M:    rdunlap@xenotime.net
  W:    http://www.xmission.com/~ebiederm/files/kexec/
  L:    linux-kernel@vger.kernel.org
  L:    fastboot@osdl.org
@@@ -2586,6 -2592,7 +2591,6 @@@ S:      Maintaine
  UDF FILESYSTEM
  P:    Ben Fennema
  M:    bfennema@falcon.csc.calpoly.edu
 -L:    linux_udf@hpesjro.fc.hp.com
  W:    http://linux-udf.sourceforge.net
  S:    Maintained
  
@@@ -2638,12 -2645,6 +2643,12 @@@ L:    linux-usb-users@lists.sourceforge.ne
  L:    linux-usb-devel@lists.sourceforge.net
  S:    Maintained
  
 +USB ISP116X DRIVER
 +P:    Olav Kongas
 +M:    ok@artecdesign.ee
 +L:    linux-usb-devel@lists.sourceforge.net
 +S:    Maintained
 +
  USB KAWASAKI LSI DRIVER
  P:    Oliver Neukum
  M:    oliver@neukum.name
@@@ -2655,7 -2656,7 +2660,7 @@@ USB MASS STORAGE DRIVE
  P:    Matthew Dharm
  M:    mdharm-usb@one-eyed-alien.net
  L:    linux-usb-users@lists.sourceforge.net
 -L:    linux-usb-devel@lists.sourceforge.net
 +L:    usb-storage@lists.one-eyed-alien.net
  S:    Maintained
  W:    http://www.one-eyed-alien.net/~mdharm/linux-usb/
  
diff --combined include/linux/pci_ids.h
index a17e171384ef77828a38a20ca3cc0ef451e0fb26,9093f118f99d0ff809bb8a3ac423f3ffddc82aef..4f01710485cd98fb725704823c980b1eaf771c9a
@@@ -15,7 -15,6 +15,7 @@@
  #define PCI_CLASS_STORAGE_FLOPPY      0x0102
  #define PCI_CLASS_STORAGE_IPI         0x0103
  #define PCI_CLASS_STORAGE_RAID                0x0104
 +#define PCI_CLASS_STORAGE_SAS         0x0107
  #define PCI_CLASS_STORAGE_OTHER               0x0180
  
  #define PCI_BASE_CLASS_NETWORK                0x02
  #define PCI_DEVICE_ID_NS_87560_USB    0x0012
  #define PCI_DEVICE_ID_NS_83815                0x0020
  #define PCI_DEVICE_ID_NS_83820                0x0022
+ #define PCI_DEVICE_ID_NS_CS5535_IDE   0x002d
+ #define PCI_DEVICE_ID_NS_CS5535_AUDIO 0x002e
+ #define PCI_DEVICE_ID_NS_CS5535_USB   0x002f
+ #define PCI_DEVICE_ID_NS_CS5535_VIDEO 0x0030
  #define PCI_DEVICE_ID_NS_SATURN               0x0035
  #define PCI_DEVICE_ID_NS_SCx200_BRIDGE        0x0500
  #define PCI_DEVICE_ID_NS_SCx200_SMI   0x0501
diff --combined sound/usb/usbaudio.c
index 22f8bb612bffb2599bb8a88103008623e55cceb1,e1326704c0c5b4842f31c43844db1092b92ee7a5..a1bd8040dea441a06a487ef9943a8e31997bb457
@@@ -102,10 -102,6 +102,6 @@@ MODULE_PARM_DESC(async_unlink, "Use asy
  #define SYNC_URBS     4       /* always four urbs for sync */
  #define MIN_PACKS_URB 1       /* minimum 1 packet per urb */
  
- typedef struct snd_usb_substream snd_usb_substream_t;
- typedef struct snd_usb_stream snd_usb_stream_t;
- typedef struct snd_urb_ctx snd_urb_ctx_t;
  struct audioformat {
        struct list_head list;
        snd_pcm_format_t format;        /* format type */
        unsigned int *rate_table;       /* rate table */
  };
  
+ struct snd_usb_substream;
  struct snd_urb_ctx {
        struct urb *urb;
        unsigned int buffer_size;       /* size of data buffer, if data URB */
-       snd_usb_substream_t *subs;
+       struct snd_usb_substream *subs;
        int index;      /* index for urb array */
        int packets;    /* number of packets per urb */
  };
  
  struct snd_urb_ops {
-       int (*prepare)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
-       int (*retire)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
-       int (*prepare_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
-       int (*retire_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
+       int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
+       int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
+       int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
+       int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
  };
  
  struct snd_usb_substream {
-       snd_usb_stream_t *stream;
+       struct snd_usb_stream *stream;
        struct usb_device *dev;
-       snd_pcm_substream_t *pcm_substream;
+       struct snd_pcm_substream *pcm_substream;
        int direction;  /* playback or capture */
        int interface;  /* current interface */
        int endpoint;   /* assigned endpoint */
        unsigned long unlink_mask;      /* bitmask of unlinked urbs */
  
        unsigned int nurbs;                     /* # urbs */
-       snd_urb_ctx_t dataurb[MAX_URBS];        /* data urb table */
-       snd_urb_ctx_t syncurb[SYNC_URBS];       /* sync urb table */
+       struct snd_urb_ctx dataurb[MAX_URBS];   /* data urb table */
+       struct snd_urb_ctx syncurb[SYNC_URBS];  /* sync urb table */
        char *syncbuf;                          /* sync buffer for all sync URBs */
        dma_addr_t sync_dma;                    /* DMA address of syncbuf */
  
  
  
  struct snd_usb_stream {
-       snd_usb_audio_t *chip;
-       snd_pcm_t *pcm;
+       struct snd_usb_audio *chip;
+       struct snd_pcm *pcm;
        int pcm_index;
        unsigned int fmt_type;          /* USB audio format type (1-3) */
-       snd_usb_substream_t substream[2];
+       struct snd_usb_substream substream[2];
        struct list_head list;
  };
  
   */
  
  static DECLARE_MUTEX(register_mutex);
- static snd_usb_audio_t *usb_chip[SNDRV_CARDS];
+ static struct snd_usb_audio *usb_chip[SNDRV_CARDS];
  
  
  /*
@@@ -245,12 -243,12 +243,12 @@@ static inline unsigned get_high_speed_h
   * fill the length and offset of each urb descriptor.
   * the fixed 10.14 frequency is passed through the pipe.
   */
- static int prepare_capture_sync_urb(snd_usb_substream_t *subs,
-                                   snd_pcm_runtime_t *runtime,
+ static int prepare_capture_sync_urb(struct snd_usb_substream *subs,
+                                   struct snd_pcm_runtime *runtime,
                                    struct urb *urb)
  {
        unsigned char *cp = urb->transfer_buffer;
-       snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
+       struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
  
        urb->dev = ctx->subs->dev; /* we need to set this at each time */
        urb->iso_frame_desc[0].length = 3;
   * fill the length and offset of each urb descriptor.
   * the fixed 12.13 frequency is passed as 16.16 through the pipe.
   */
- static int prepare_capture_sync_urb_hs(snd_usb_substream_t *subs,
-                                      snd_pcm_runtime_t *runtime,
+ static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs,
+                                      struct snd_pcm_runtime *runtime,
                                       struct urb *urb)
  {
        unsigned char *cp = urb->transfer_buffer;
-       snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
+       struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
  
        urb->dev = ctx->subs->dev; /* we need to set this at each time */
        urb->iso_frame_desc[0].length = 4;
   * process after capture sync complete
   * - nothing to do
   */
- static int retire_capture_sync_urb(snd_usb_substream_t *subs,
-                                  snd_pcm_runtime_t *runtime,
+ static int retire_capture_sync_urb(struct snd_usb_substream *subs,
+                                  struct snd_pcm_runtime *runtime,
                                   struct urb *urb)
  {
        return 0;
   * write onto the pcm buffer directly...  the data is thus copied
   * later at complete callback to the global buffer.
   */
- static int prepare_capture_urb(snd_usb_substream_t *subs,
-                              snd_pcm_runtime_t *runtime,
+ static int prepare_capture_urb(struct snd_usb_substream *subs,
+                              struct snd_pcm_runtime *runtime,
                               struct urb *urb)
  {
        int i, offs;
-       snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
+       struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
  
        offs = 0;
        urb->dev = ctx->subs->dev; /* we need to set this at each time */
   * copy the data from each desctiptor to the pcm buffer, and
   * update the current position.
   */
- static int retire_capture_urb(snd_usb_substream_t *subs,
-                             snd_pcm_runtime_t *runtime,
+ static int retire_capture_urb(struct snd_usb_substream *subs,
+                             struct snd_pcm_runtime *runtime,
                              struct urb *urb)
  {
        unsigned long flags;
   * set up the offset and length to receive the current frequency.
   */
  
- static int prepare_playback_sync_urb(snd_usb_substream_t *subs,
-                                    snd_pcm_runtime_t *runtime,
+ static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
+                                    struct snd_pcm_runtime *runtime,
                                     struct urb *urb)
  {
-       snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
+       struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
  
        urb->dev = ctx->subs->dev; /* we need to set this at each time */
        urb->iso_frame_desc[0].length = 3;
   * set up the offset and length to receive the current frequency.
   */
  
- static int prepare_playback_sync_urb_hs(snd_usb_substream_t *subs,
-                                       snd_pcm_runtime_t *runtime,
+ static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs,
+                                       struct snd_pcm_runtime *runtime,
                                        struct urb *urb)
  {
-       snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
+       struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
  
        urb->dev = ctx->subs->dev; /* we need to set this at each time */
        urb->iso_frame_desc[0].length = 4;
   * retrieve the current 10.14 frequency from pipe, and set it.
   * the value is referred in prepare_playback_urb().
   */
- static int retire_playback_sync_urb(snd_usb_substream_t *subs,
-                                   snd_pcm_runtime_t *runtime,
+ static int retire_playback_sync_urb(struct snd_usb_substream *subs,
+                                   struct snd_pcm_runtime *runtime,
                                    struct urb *urb)
  {
        unsigned int f;
   * retrieve the current 12.13 frequency from pipe, and set it.
   * the value is referred in prepare_playback_urb().
   */
- static int retire_playback_sync_urb_hs(snd_usb_substream_t *subs,
-                                      snd_pcm_runtime_t *runtime,
+ static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs,
+                                      struct snd_pcm_runtime *runtime,
                                       struct urb *urb)
  {
        unsigned int f;
   *
   * We don't care about (or have) any data, so we just send a transfer delimiter.
   */
- static int prepare_startup_playback_urb(snd_usb_substream_t *subs,
-                                       snd_pcm_runtime_t *runtime,
+ static int prepare_startup_playback_urb(struct snd_usb_substream *subs,
+                                       struct snd_pcm_runtime *runtime,
                                        struct urb *urb)
  {
        unsigned int i;
-       snd_urb_ctx_t *ctx = urb->context;
+       struct snd_urb_ctx *ctx = urb->context;
  
        urb->dev = ctx->subs->dev;
        urb->number_of_packets = subs->packs_per_ms;
   * To avoid inconsistencies when updating hwptr_done, we use double buffering
   * for all URBs.
   */
- static int prepare_playback_urb(snd_usb_substream_t *subs,
-                               snd_pcm_runtime_t *runtime,
+ static int prepare_playback_urb(struct snd_usb_substream *subs,
+                               struct snd_pcm_runtime *runtime,
                                struct urb *urb)
  {
        int i, stride, offs;
        unsigned int counts;
        unsigned long flags;
        int period_elapsed = 0;
-       snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
+       struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
  
        stride = runtime->frame_bits >> 3;
  
   * process after playback data complete
   * - nothing to do
   */
- static int retire_playback_urb(snd_usb_substream_t *subs,
-                              snd_pcm_runtime_t *runtime,
+ static int retire_playback_urb(struct snd_usb_substream *subs,
+                              struct snd_pcm_runtime *runtime,
                               struct urb *urb)
  {
        return 0;
@@@ -642,9 -640,9 +640,9 @@@ static struct snd_urb_ops audio_urb_ops
   */
  static void snd_complete_urb(struct urb *urb, struct pt_regs *regs)
  {
-       snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
-       snd_usb_substream_t *subs = ctx->subs;
-       snd_pcm_substream_t *substream = ctx->subs->pcm_substream;
+       struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
+       struct snd_usb_substream *subs = ctx->subs;
+       struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
        int err = 0;
  
        if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
   */
  static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs)
  {
-       snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
-       snd_usb_substream_t *subs = ctx->subs;
-       snd_pcm_substream_t *substream = ctx->subs->pcm_substream;
+       struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
+       struct snd_usb_substream *subs = ctx->subs;
+       struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
        int err = 0;
  
        if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
  
  
  /* get the physical page pointer at the given offset */
- static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs,
+ static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
                                             unsigned long offset)
  {
        void *pageptr = subs->runtime->dma_area + offset;
  }
  
  /* allocate virtual buffer; may be called more than once */
- static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
+ static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
  {
-       snd_pcm_runtime_t *runtime = subs->runtime;
+       struct snd_pcm_runtime *runtime = subs->runtime;
        if (runtime->dma_area) {
                if (runtime->dma_bytes >= size)
                        return 0; /* already large enough */
  }
  
  /* free virtual buffer; may be called more than once */
- static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs)
+ static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs)
  {
-       snd_pcm_runtime_t *runtime = subs->runtime;
+       struct snd_pcm_runtime *runtime = subs->runtime;
        if (runtime->dma_area) {
                vfree(runtime->dma_area);
                runtime->dma_area = NULL;
  /*
   * unlink active urbs.
   */
- static int deactivate_urbs(snd_usb_substream_t *subs, int force, int can_sleep)
+ static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sleep)
  {
        unsigned int i;
        int async;
  /*
   * set up and start data/sync urbs
   */
- static int start_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
+ static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime)
  {
        unsigned int i;
        int err;
  /*
   *  wait until all urbs are processed.
   */
- static int wait_clear_urbs(snd_usb_substream_t *subs)
+ static int wait_clear_urbs(struct snd_usb_substream *subs)
  {
        unsigned long end_time = jiffies + msecs_to_jiffies(1000);
        unsigned int i;
  /*
   * return the current pcm pointer.  just return the hwptr_done value.
   */
- static snd_pcm_uframes_t snd_usb_pcm_pointer(snd_pcm_substream_t *substream)
+ static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
  {
-       snd_usb_substream_t *subs;
+       struct snd_usb_substream *subs;
        snd_pcm_uframes_t hwptr_done;
        
-       subs = (snd_usb_substream_t *)substream->runtime->private_data;
+       subs = (struct snd_usb_substream *)substream->runtime->private_data;
        spin_lock(&subs->lock);
        hwptr_done = subs->hwptr_done;
        spin_unlock(&subs->lock);
  /*
   * start/stop playback substream
   */
- static int snd_usb_pcm_playback_trigger(snd_pcm_substream_t *substream,
+ static int snd_usb_pcm_playback_trigger(struct snd_pcm_substream *substream,
                                        int cmd)
  {
-       snd_usb_substream_t *subs = substream->runtime->private_data;
+       struct snd_usb_substream *subs = substream->runtime->private_data;
  
        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
  /*
   * start/stop capture substream
   */
- static int snd_usb_pcm_capture_trigger(snd_pcm_substream_t *substream,
+ static int snd_usb_pcm_capture_trigger(struct snd_pcm_substream *substream,
                                       int cmd)
  {
-       snd_usb_substream_t *subs = substream->runtime->private_data;
+       struct snd_usb_substream *subs = substream->runtime->private_data;
  
        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
  /*
   * release a urb data
   */
- static void release_urb_ctx(snd_urb_ctx_t *u)
+ static void release_urb_ctx(struct snd_urb_ctx *u)
  {
        if (u->urb) {
                if (u->buffer_size)
  /*
   * release a substream
   */
- static void release_substream_urbs(snd_usb_substream_t *subs, int force)
+ static void release_substream_urbs(struct snd_usb_substream *subs, int force)
  {
        int i;
  
  /*
   * initialize a substream for plaback/capture
   */
- static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_bytes,
+ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int period_bytes,
                               unsigned int rate, unsigned int frame_bits)
  {
        unsigned int maxsize, n, i;
  
        /* allocate and initialize data urbs */
        for (i = 0; i < subs->nurbs; i++) {
-               snd_urb_ctx_t *u = &subs->dataurb[i];
+               struct snd_urb_ctx *u = &subs->dataurb[i];
                u->index = i;
                u->subs = subs;
                u->packets = npacks[i];
                if (! subs->syncbuf)
                        goto out_of_memory;
                for (i = 0; i < SYNC_URBS; i++) {
-                       snd_urb_ctx_t *u = &subs->syncurb[i];
+                       struct snd_urb_ctx *u = &subs->syncurb[i];
                        u->index = i;
                        u->subs = subs;
                        u->packets = 1;
@@@ -1104,7 -1102,7 +1102,7 @@@ out_of_memory
  /*
   * find a matching audio format
   */
- static struct audioformat *find_format(snd_usb_substream_t *subs, unsigned int format,
+ static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format,
                                       unsigned int rate, unsigned int channels)
  {
        struct list_head *p;
@@@ -1229,7 -1227,7 +1227,7 @@@ static int init_usb_sample_rate(struct 
  /*
   * find a matching format and set up the interface
   */
- static int set_format(snd_usb_substream_t *subs, struct audioformat *fmt)
+ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
  {
        struct usb_device *dev = subs->dev;
        struct usb_host_interface *alts;
   * if sg buffer is supported on the later version of alsa, we'll follow
   * that.
   */
- static int snd_usb_hw_params(snd_pcm_substream_t *substream,
-                            snd_pcm_hw_params_t *hw_params)
+ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *hw_params)
  {
-       snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
+       struct snd_usb_substream *subs = (struct snd_usb_substream *)substream->runtime->private_data;
        struct audioformat *fmt;
        unsigned int channels, rate, format;
        int ret, changed;
   *
   * reset the audio format and release the buffer
   */
- static int snd_usb_hw_free(snd_pcm_substream_t *substream)
+ static int snd_usb_hw_free(struct snd_pcm_substream *substream)
  {
-       snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
+       struct snd_usb_substream *subs = (struct snd_usb_substream *)substream->runtime->private_data;
  
        subs->cur_audiofmt = NULL;
        subs->cur_rate = 0;
   *
   * only a few subtle things...
   */
- static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream)
+ static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
  {
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_usb_substream_t *subs = runtime->private_data;
+       struct snd_pcm_runtime *runtime = substream->runtime;
+       struct snd_usb_substream *subs = runtime->private_data;
  
        if (! subs->cur_audiofmt) {
                snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
                return 0;
  }
  
- static snd_pcm_hardware_t snd_usb_playback =
+ static struct snd_pcm_hardware snd_usb_playback =
  {
        .info =                 SNDRV_PCM_INFO_MMAP |
                                SNDRV_PCM_INFO_MMAP_VALID |
        .periods_max =          1024,
  };
  
- static snd_pcm_hardware_t snd_usb_capture =
+ static struct snd_pcm_hardware snd_usb_capture =
  {
        .info =                 SNDRV_PCM_INFO_MMAP |
                                SNDRV_PCM_INFO_MMAP_VALID |
  #define hwc_debug(fmt, args...) /**/
  #endif
  
- static int hw_check_valid_format(snd_pcm_hw_params_t *params, struct audioformat *fp)
+ static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audioformat *fp)
  {
-       snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
-       snd_interval_t *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
-       snd_mask_t *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+       struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+       struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+       struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
  
        /* check the format */
        if (! snd_mask_test(fmts, fp->format)) {
        return 1;
  }
  
- static int hw_rule_rate(snd_pcm_hw_params_t *params,
-                       snd_pcm_hw_rule_t *rule)
+ static int hw_rule_rate(struct snd_pcm_hw_params *params,
+                       struct snd_pcm_hw_rule *rule)
  {
-       snd_usb_substream_t *subs = rule->private;
+       struct snd_usb_substream *subs = rule->private;
        struct list_head *p;
-       snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+       struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
        unsigned int rmin, rmax;
        int changed;
  
  }
  
  
- static int hw_rule_channels(snd_pcm_hw_params_t *params,
-                           snd_pcm_hw_rule_t *rule)
+ static int hw_rule_channels(struct snd_pcm_hw_params *params,
+                           struct snd_pcm_hw_rule *rule)
  {
-       snd_usb_substream_t *subs = rule->private;
+       struct snd_usb_substream *subs = rule->private;
        struct list_head *p;
-       snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+       struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
        unsigned int rmin, rmax;
        int changed;
  
        return changed;
  }
  
- static int hw_rule_format(snd_pcm_hw_params_t *params,
-                         snd_pcm_hw_rule_t *rule)
+ static int hw_rule_format(struct snd_pcm_hw_params *params,
+                         struct snd_pcm_hw_rule *rule)
  {
-       snd_usb_substream_t *subs = rule->private;
+       struct snd_usb_substream *subs = rule->private;
        struct list_head *p;
-       snd_mask_t *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+       struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
        u64 fbits;
        u32 oldbits[2];
        int changed;
  /*
   * check whether the registered audio formats need special hw-constraints
   */
- static int check_hw_params_convention(snd_usb_substream_t *subs)
+ static int check_hw_params_convention(struct snd_usb_substream *subs)
  {
        int i;
        u32 *channels;
   * set up the runtime hardware information.
   */
  
- static int setup_hw_info(snd_pcm_runtime_t *runtime, snd_usb_substream_t *subs)
+ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
  {
        struct list_head *p;
        int err;
        return 0;
  }
  
- static int snd_usb_pcm_open(snd_pcm_substream_t *substream, int direction,
-                           snd_pcm_hardware_t *hw)
+ static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction,
+                           struct snd_pcm_hardware *hw)
  {
-       snd_usb_stream_t *as = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_usb_substream_t *subs = &as->substream[direction];
+       struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
+       struct snd_pcm_runtime *runtime = substream->runtime;
+       struct snd_usb_substream *subs = &as->substream[direction];
  
        subs->interface = -1;
        subs->format = 0;
        return setup_hw_info(runtime, subs);
  }
  
- static int snd_usb_pcm_close(snd_pcm_substream_t *substream, int direction)
+ static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
  {
-       snd_usb_stream_t *as = snd_pcm_substream_chip(substream);
-       snd_usb_substream_t *subs = &as->substream[direction];
+       struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
+       struct snd_usb_substream *subs = &as->substream[direction];
  
        if (subs->interface >= 0) {
                usb_set_interface(subs->dev, subs->interface, 0);
        return 0;
  }
  
- static int snd_usb_playback_open(snd_pcm_substream_t *substream)
+ static int snd_usb_playback_open(struct snd_pcm_substream *substream)
  {
        return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_playback);
  }
  
- static int snd_usb_playback_close(snd_pcm_substream_t *substream)
+ static int snd_usb_playback_close(struct snd_pcm_substream *substream)
  {
        return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
  }
  
- static int snd_usb_capture_open(snd_pcm_substream_t *substream)
+ static int snd_usb_capture_open(struct snd_pcm_substream *substream)
  {
        return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_capture);
  }
  
- static int snd_usb_capture_close(snd_pcm_substream_t *substream)
+ static int snd_usb_capture_close(struct snd_pcm_substream *substream)
  {
        return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
  }
  
- static snd_pcm_ops_t snd_usb_playback_ops = {
+ static struct snd_pcm_ops snd_usb_playback_ops = {
        .open =         snd_usb_playback_open,
        .close =        snd_usb_playback_close,
        .ioctl =        snd_pcm_lib_ioctl,
        .page =         snd_pcm_get_vmalloc_page,
  };
  
- static snd_pcm_ops_t snd_usb_capture_ops = {
+ static struct snd_pcm_ops snd_usb_capture_ops = {
        .open =         snd_usb_capture_open,
        .close =        snd_usb_capture_close,
        .ioctl =        snd_pcm_lib_ioctl,
@@@ -1996,6 -1994,7 +1994,6 @@@ static struct usb_device_id usb_audio_i
  MODULE_DEVICE_TABLE (usb, usb_audio_ids);
  
  static struct usb_driver usb_audio_driver = {
 -      .owner =        THIS_MODULE,
        .name =         "snd-usb-audio",
        .probe =        usb_audio_probe,
        .disconnect =   usb_audio_disconnect,
  /*
   * proc interface for list the supported pcm formats
   */
- static void proc_dump_substream_formats(snd_usb_substream_t *subs, snd_info_buffer_t *buffer)
+ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
  {
        struct list_head *p;
        static char *sync_types[4] = {
        }
  }
  
- static void proc_dump_substream_status(snd_usb_substream_t *subs, snd_info_buffer_t *buffer)
+ static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
  {
        if (subs->running) {
                unsigned int i;
        }
  }
  
- static void proc_pcm_format_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
+ static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
  {
-       snd_usb_stream_t *stream = entry->private_data;
+       struct snd_usb_stream *stream = entry->private_data;
  
        snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
  
        }
  }
  
- static void proc_pcm_format_add(snd_usb_stream_t *stream)
+ static void proc_pcm_format_add(struct snd_usb_stream *stream)
  {
-       snd_info_entry_t *entry;
+       struct snd_info_entry *entry;
        char name[32];
-       snd_card_t *card = stream->chip->card;
+       struct snd_card *card = stream->chip->card;
  
        sprintf(name, "stream%d", stream->pcm_index);
        if (! snd_card_proc_new(card, name, &entry))
   * initialize the substream instance.
   */
  
- static void init_substream(snd_usb_stream_t *as, int stream, struct audioformat *fp)
+ static void init_substream(struct snd_usb_stream *as, int stream, struct audioformat *fp)
  {
-       snd_usb_substream_t *subs = &as->substream[stream];
+       struct snd_usb_substream *subs = &as->substream[stream];
  
        INIT_LIST_HEAD(&subs->fmt_list);
        spin_lock_init(&subs->lock);
  /*
   * free a substream
   */
- static void free_substream(snd_usb_substream_t *subs)
+ static void free_substream(struct snd_usb_substream *subs)
  {
        struct list_head *p, *n;
  
  /*
   * free a usb stream instance
   */
- static void snd_usb_audio_stream_free(snd_usb_stream_t *stream)
+ static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
  {
        free_substream(&stream->substream[0]);
        free_substream(&stream->substream[1]);
        kfree(stream);
  }
  
- static void snd_usb_audio_pcm_free(snd_pcm_t *pcm)
+ static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
  {
-       snd_usb_stream_t *stream = pcm->private_data;
+       struct snd_usb_stream *stream = pcm->private_data;
        if (stream) {
                stream->pcm = NULL;
                snd_usb_audio_stream_free(stream);
   * if a stream with the same endpoint already exists, append to it.
   * if not, create a new pcm stream.
   */
- static int add_audio_endpoint(snd_usb_audio_t *chip, int stream, struct audioformat *fp)
+ static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp)
  {
        struct list_head *p;
-       snd_usb_stream_t *as;
-       snd_usb_substream_t *subs;
-       snd_pcm_t *pcm;
+       struct snd_usb_stream *as;
+       struct snd_usb_substream *subs;
+       struct snd_pcm *pcm;
        int err;
  
        list_for_each(p, &chip->pcm_list) {
-               as = list_entry(p, snd_usb_stream_t, list);
+               as = list_entry(p, struct snd_usb_stream, list);
                if (as->fmt_type != fp->fmt_type)
                        continue;
                subs = &as->substream[stream];
        }
        /* look for an empty stream */
        list_for_each(p, &chip->pcm_list) {
-               as = list_entry(p, snd_usb_stream_t, list);
+               as = list_entry(p, struct snd_usb_stream, list);
                if (as->fmt_type != fp->fmt_type)
                        continue;
                subs = &as->substream[stream];
  /*
   * check if the device uses big-endian samples
   */
- static int is_big_endian_format(snd_usb_audio_t *chip, struct audioformat *fp)
+ static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
  {
        switch (chip->usb_id) {
        case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
   * @format: the format tag (wFormatTag)
   * @fmt: the format type descriptor
   */
- static int parse_audio_format_i_type(snd_usb_audio_t *chip, struct audioformat *fp,
+ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp,
                                     int format, unsigned char *fmt)
  {
        int pcm_format;
   * @offset: the start offset of descriptor pointing the rate type
   *          (7 for type I and II, 8 for type II)
   */
- static int parse_audio_format_rates(snd_usb_audio_t *chip, struct audioformat *fp,
+ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioformat *fp,
                                    unsigned char *fmt, int offset)
  {
        int nr_rates = fmt[offset];
  /*
   * parse the format type I and III descriptors
   */
- static int parse_audio_format_i(snd_usb_audio_t *chip, struct audioformat *fp,
+ static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp,
                                int format, unsigned char *fmt)
  {
        int pcm_format;
  /*
   * prase the format type II descriptor
   */
- static int parse_audio_format_ii(snd_usb_audio_t *chip, struct audioformat *fp,
+ static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp,
                                 int format, unsigned char *fmt)
  {
        int brate, framesize;
        return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */
  }
  
- static int parse_audio_format(snd_usb_audio_t *chip, struct audioformat *fp,
+ static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
                              int format, unsigned char *fmt, int stream)
  {
        int err;
        return 0;
  }
  
- static int parse_audio_endpoints(snd_usb_audio_t *chip, int iface_no)
+ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
  {
        struct usb_device *dev;
        struct usb_interface *iface;
  static void snd_usb_stream_disconnect(struct list_head *head)
  {
        int idx;
-       snd_usb_stream_t *as;
-       snd_usb_substream_t *subs;
+       struct snd_usb_stream *as;
+       struct snd_usb_substream *subs;
  
-       as = list_entry(head, snd_usb_stream_t, list);
+       as = list_entry(head, struct snd_usb_stream, list);
        for (idx = 0; idx < 2; idx++) {
                subs = &as->substream[idx];
                if (!subs->num_formats)
  /*
   * parse audio control descriptor and create pcm/midi streams
   */
- static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif)
+ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
  {
        struct usb_device *dev = chip->dev;
        struct usb_host_interface *host_iface;
  /*
   * create a stream for an endpoint/altsetting without proper descriptors
   */
- static int create_fixed_stream_quirk(snd_usb_audio_t *chip,
+ static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
                                     struct usb_interface *iface,
-                                    const snd_usb_audio_quirk_t *quirk)
+                                    const struct snd_usb_audio_quirk *quirk)
  {
        struct audioformat *fp;
        struct usb_host_interface *alts;
  /*
   * create a stream for an interface with proper descriptors
   */
- static int create_standard_audio_quirk(snd_usb_audio_t *chip,
+ static int create_standard_audio_quirk(struct snd_usb_audio *chip,
                                       struct usb_interface *iface,
-                                      const snd_usb_audio_quirk_t *quirk)
+                                      const struct snd_usb_audio_quirk *quirk)
  {
        struct usb_host_interface *alts;
        struct usb_interface_descriptor *altsd;
   * Create a stream for an Edirol UA-700/UA-25 interface.  The only way
   * to detect the sample rate is by looking at wMaxPacketSize.
   */
- static int create_ua700_ua25_quirk(snd_usb_audio_t *chip,
+ static int create_ua700_ua25_quirk(struct snd_usb_audio *chip,
                                   struct usb_interface *iface,
-                                  const snd_usb_audio_quirk_t *quirk)
+                                  const struct snd_usb_audio_quirk *quirk)
  {
        static const struct audioformat ua_format = {
                .format = SNDRV_PCM_FORMAT_S24_3LE,
        altsd = get_iface_desc(alts);
  
        if (altsd->bNumEndpoints == 2) {
-               static const snd_usb_midi_endpoint_info_t ua700_ep = {
+               static const struct snd_usb_midi_endpoint_info ua700_ep = {
                        .out_cables = 0x0003,
                        .in_cables  = 0x0003
                };
-               static const snd_usb_audio_quirk_t ua700_quirk = {
+               static const struct snd_usb_audio_quirk ua700_quirk = {
                        .type = QUIRK_MIDI_FIXED_ENDPOINT,
                        .data = &ua700_ep
                };
-               static const snd_usb_midi_endpoint_info_t ua25_ep = {
+               static const struct snd_usb_midi_endpoint_info ua25_ep = {
                        .out_cables = 0x0001,
                        .in_cables  = 0x0001
                };
-               static const snd_usb_audio_quirk_t ua25_quirk = {
+               static const struct snd_usb_audio_quirk ua25_quirk = {
                        .type = QUIRK_MIDI_FIXED_ENDPOINT,
                        .data = &ua25_ep
                };
  /*
   * Create a stream for an Edirol UA-1000 interface.
   */
- static int create_ua1000_quirk(snd_usb_audio_t *chip,
+ static int create_ua1000_quirk(struct snd_usb_audio *chip,
                               struct usb_interface *iface,
-                              const snd_usb_audio_quirk_t *quirk)
+                              const struct snd_usb_audio_quirk *quirk)
  {
        static const struct audioformat ua1000_format = {
                .format = SNDRV_PCM_FORMAT_S32_LE,
        return 0;
  }
  
- static int snd_usb_create_quirk(snd_usb_audio_t *chip,
+ static int snd_usb_create_quirk(struct snd_usb_audio *chip,
                                struct usb_interface *iface,
-                               const snd_usb_audio_quirk_t *quirk);
+                               const struct snd_usb_audio_quirk *quirk);
  
  /*
   * handle the quirks for the contained interfaces
   */
- static int create_composite_quirk(snd_usb_audio_t *chip,
+ static int create_composite_quirk(struct snd_usb_audio *chip,
                                  struct usb_interface *iface,
-                                 const snd_usb_audio_quirk_t *quirk)
+                                 const struct snd_usb_audio_quirk *quirk)
  {
        int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
        int err;
        return 0;
  }
  
- static int ignore_interface_quirk(snd_usb_audio_t *chip,
+ static int ignore_interface_quirk(struct snd_usb_audio *chip,
                                  struct usb_interface *iface,
-                                 const snd_usb_audio_quirk_t *quirk)
+                                 const struct snd_usb_audio_quirk *quirk)
  {
        return 0;
  }
@@@ -3039,12 -3038,12 +3037,12 @@@ static int snd_usb_audigy2nx_boot_quirk
   * after this.
   * returns a negative value at error.
   */
- static int snd_usb_create_quirk(snd_usb_audio_t *chip,
+ static int snd_usb_create_quirk(struct snd_usb_audio *chip,
                                struct usb_interface *iface,
-                               const snd_usb_audio_quirk_t *quirk)
+                               const struct snd_usb_audio_quirk *quirk)
  {
-       typedef int (*quirk_func_t)(snd_usb_audio_t *, struct usb_interface *,
-                                   const snd_usb_audio_quirk_t *);
+       typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *,
+                                   const struct snd_usb_audio_quirk *);
        static const quirk_func_t quirk_funcs[] = {
                [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
                [QUIRK_COMPOSITE] = create_composite_quirk,
  /*
   * common proc files to show the usb device info
   */
- static void proc_audio_usbbus_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
+ static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
  {
-       snd_usb_audio_t *chip = entry->private_data;
+       struct snd_usb_audio *chip = entry->private_data;
        if (! chip->shutdown)
                snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
  }
  
- static void proc_audio_usbid_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
+ static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
  {
-       snd_usb_audio_t *chip = entry->private_data;
+       struct snd_usb_audio *chip = entry->private_data;
        if (! chip->shutdown)
                snd_iprintf(buffer, "%04x:%04x\n", 
                            USB_ID_VENDOR(chip->usb_id),
                            USB_ID_PRODUCT(chip->usb_id));
  }
  
- static void snd_usb_audio_create_proc(snd_usb_audio_t *chip)
+ static void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
  {
-       snd_info_entry_t *entry;
+       struct snd_info_entry *entry;
        if (! snd_card_proc_new(chip->card, "usbbus", &entry))
                snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbbus_read);
        if (! snd_card_proc_new(chip->card, "usbid", &entry))
   *
   */
  
- static int snd_usb_audio_free(snd_usb_audio_t *chip)
+ static int snd_usb_audio_free(struct snd_usb_audio *chip)
  {
        kfree(chip);
        return 0;
  }
  
- static int snd_usb_audio_dev_free(snd_device_t *device)
+ static int snd_usb_audio_dev_free(struct snd_device *device)
  {
-       snd_usb_audio_t *chip = device->device_data;
+       struct snd_usb_audio *chip = device->device_data;
        return snd_usb_audio_free(chip);
  }
  
   * create a chip instance and set its names.
   */
  static int snd_usb_audio_create(struct usb_device *dev, int idx,
-                               const snd_usb_audio_quirk_t *quirk,
-                               snd_usb_audio_t **rchip)
+                               const struct snd_usb_audio_quirk *quirk,
+                               struct snd_usb_audio **rchip)
  {
-       snd_card_t *card;
-       snd_usb_audio_t *chip;
+       struct snd_card *card;
+       struct snd_usb_audio *chip;
        int err, len;
        char component[14];
-       static snd_device_ops_t ops = {
+       static struct snd_device_ops ops = {
                .dev_free =     snd_usb_audio_dev_free,
        };
  
@@@ -3234,9 -3233,9 +3232,9 @@@ static void *snd_usb_audio_probe(struc
                                 struct usb_interface *intf,
                                 const struct usb_device_id *usb_id)
  {
-       const snd_usb_audio_quirk_t *quirk = (const snd_usb_audio_quirk_t *)usb_id->driver_info;
+       const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info;
        int i, err;
-       snd_usb_audio_t *chip;
+       struct snd_usb_audio *chip;
        struct usb_host_interface *alts;
        int ifnum;
        u32 id;
   */
  static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
  {
-       snd_usb_audio_t *chip;
-       snd_card_t *card;
+       struct snd_usb_audio *chip;
+       struct snd_card *card;
        struct list_head *p;
  
        if (ptr == (void *)-1L)
index a3967f72ab4efc2c5c3a5acb187c989c21a76bfb,9807c3d7b1a4e4ef24afb00fa81e0cb73fef18dc..e0abb56bbe492084d565a9c56b17c71b8ed47a60
@@@ -167,28 -167,28 +167,28 @@@ MODULE_PARM_DESC(enable, "Enable "NAME_
  static int snd_usX2Y_card_used[SNDRV_CARDS];
  
  static void usX2Y_usb_disconnect(struct usb_device* usb_device, void* ptr);
- static void snd_usX2Y_card_private_free(snd_card_t *card);
+ static void snd_usX2Y_card_private_free(struct snd_card *card);
  
  /* 
   * pipe 4 is used for switching the lamps, setting samplerate, volumes ....   
   */
- static void i_usX2Y_Out04Int(struct urburb, struct pt_regs *regs)
+ static void i_usX2Y_Out04Int(struct urb *urb, struct pt_regs *regs)
  {
  #ifdef CONFIG_SND_DEBUG
        if (urb->status) {
                int             i;
-               usX2Ydev_t*     usX2Y = urb->context;
+               struct usX2Ydev *usX2Y = urb->context;
                for (i = 0; i < 10 && usX2Y->AS04.urb[i] != urb; i++);
                snd_printdd("i_usX2Y_Out04Int() urb %i status=%i\n", i, urb->status);
        }
  #endif
  }
  
- static void i_usX2Y_In04Int(struct urburb, struct pt_regs *regs)
+ static void i_usX2Y_In04Int(struct urb *urb, struct pt_regs *regs)
  {
        int                     err = 0;
-       usX2Ydev_t              *usX2Y = urb->context;
-       us428ctls_sharedmem_t   *us428ctls = usX2Y->us428ctls_sharedmem;
+       struct usX2Ydev         *usX2Y = urb->context;
+       struct us428ctls_sharedmem      *us428ctls = usX2Y->us428ctls_sharedmem;
  
        usX2Y->In04IntCalls++;
  
                                        send = 0;
                                for (j = 0; j < URBS_AsyncSeq  &&  !err; ++j)
                                        if (0 == usX2Y->AS04.urb[j]->status) {
-                                               us428_p4out_t *p4out = us428ctls->p4out + send; // FIXME if more then 1 p4out is new, 1 gets lost.
+                                               struct us428_p4out *p4out = us428ctls->p4out + send;    // FIXME if more then 1 p4out is new, 1 gets lost.
                                                usb_fill_bulk_urb(usX2Y->AS04.urb[j], usX2Y->chip.dev,
                                                                  usb_sndbulkpipe(usX2Y->chip.dev, 0x04), &p4out->val.vol, 
-                                                                 p4out->type == eLT_Light ? sizeof(us428_lights_t) : 5,
+                                                                 p4out->type == eLT_Light ? sizeof(struct us428_lights) : 5,
                                                                  i_usX2Y_Out04Int, usX2Y);
                                                err = usb_submit_urb(usX2Y->AS04.urb[j], GFP_ATOMIC);
                                                us428ctls->p4outSent = send;
  /*
   * Prepare some urbs
   */
- int usX2Y_AsyncSeq04_init(usX2Ydev_t* usX2Y)
+ int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y)
  {
        int     err = 0,
                i;
        return err;
  }
  
- int usX2Y_In04_init(usX2Ydev_t* usX2Y)
+ int usX2Y_In04_init(struct usX2Ydev *usX2Y)
  {
-       int     err = 0;
        if (! (usX2Y->In04urb = usb_alloc_urb(0, GFP_KERNEL)))
                return -ENOMEM;
  
                         usX2Y->In04Buf, 21,
                         i_usX2Y_In04Int, usX2Y,
                         10);
-       err = usb_submit_urb(usX2Y->In04urb, GFP_KERNEL);
-       return err;
+       return usb_submit_urb(usX2Y->In04urb, GFP_KERNEL);
  }
  
- static void usX2Y_unlinkSeq(snd_usX2Y_AsyncSeq_t* S)
+ static void usX2Y_unlinkSeq(struct snd_usX2Y_AsyncSeq *S)
  {
        int     i;
        for (i = 0; i < URBS_AsyncSeq; ++i) {
@@@ -336,16 -334,16 +334,16 @@@ static struct usb_device_id snd_usX2Y_u
        { /* terminator */ }
  };
  
- static snd_card_t* usX2Y_create_card(struct usb_device* device)
+ static struct snd_card *usX2Y_create_card(struct usb_device *device)
  {
        int             dev;
-       snd_card_t*     card;
+       struct snd_card *       card;
        for (dev = 0; dev < SNDRV_CARDS; ++dev)
                if (enable[dev] && !snd_usX2Y_card_used[dev])
                        break;
        if (dev >= SNDRV_CARDS)
                return NULL;
-       card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(usX2Ydev_t));
+       card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct usX2Ydev));
        if (!card)
                return NULL;
        snd_usX2Y_card_used[usX2Y(card)->chip.index = dev] = 1;
  }
  
  
- static void* usX2Y_usb_probe(struct usb_device* device, struct usb_interface *intf, const struct usb_device_id* device_id)
+ static void *usX2Y_usb_probe(struct usb_device *device, struct usb_interface *intf, const struct usb_device_id *device_id)
  {
        int             err;
-       snd_card_t*     card;
+       struct snd_card *       card;
        if (le16_to_cpu(device->descriptor.idVendor) != 0x1604 ||
            (le16_to_cpu(device->descriptor.idProduct) != USB_ID_US122 &&
             le16_to_cpu(device->descriptor.idProduct) != USB_ID_US224 &&
@@@ -409,13 -407,14 +407,13 @@@ static void snd_usX2Y_disconnect(struc
  
  MODULE_DEVICE_TABLE(usb, snd_usX2Y_usb_id_table);
  static struct usb_driver snd_usX2Y_usb_driver = {
 -      .owner =        THIS_MODULE,
        .name =         "snd-usb-usx2y",
        .probe =        snd_usX2Y_probe,
        .disconnect =   snd_usX2Y_disconnect,
        .id_table =     snd_usX2Y_usb_id_table,
  };
  
- static void snd_usX2Y_card_private_free(snd_card_t *card)
+ static void snd_usX2Y_card_private_free(struct snd_card *card)
  {
        kfree(usX2Y(card)->In04Buf);
        usb_free_urb(usX2Y(card)->In04urb);
  /*
   * Frees the device.
   */
- static void usX2Y_usb_disconnect(struct usb_devicedevice, void* ptr)
+ static void usX2Y_usb_disconnect(struct usb_device *device, void* ptr)
  {
        if (ptr) {
-               usX2Ydev_t* usX2Y = usX2Y((snd_card_t*)ptr);
-               struct list_head* p;
+               struct snd_card *card = ptr;
+               struct usX2Ydev *usX2Y = usX2Y(card);
+               struct list_head *p;
                usX2Y->chip.shutdown = 1;
                usX2Y->chip_status = USX2Y_STAT_CHIP_HUP;
                usX2Y_unlinkSeq(&usX2Y->AS04);
                usb_kill_urb(usX2Y->In04urb);
-               snd_card_disconnect((snd_card_t*)ptr);
+               snd_card_disconnect(card);
                /* release the midi resources */
                list_for_each(p, &usX2Y->chip.midi_list) {
                        snd_usbmidi_disconnect(p);
                }
                if (usX2Y->us428ctls_sharedmem) 
                        wake_up(&usX2Y->us428ctls_wait_queue_head);
-               snd_card_free((snd_card_t*)ptr);
+               snd_card_free(card);
        }
  }