lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[ALSA] Remove xxx_t typedefs: USB-Audio

Browse Source 
Modules: USB generic driver

Remove xxx_t typedefs from the USB-Audio driver.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai
2005-11-17 15:08:02 +01:00
committed by Jaroslav Kysela
parent db13154843
commit 86e07d3465
5 changed files with 521 additions and 533 deletions
Download Patch File Download Diff File Expand all files Collapse all files

374
sound/usb/usbaudio.c
View File

@@ -102,10 +102,6 @@ MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
#define SYNC_URBS 4 /* always four urbs for sync */ #define SYNC_URBS 4 /* always four urbs for sync */
#define MIN_PACKS_URB 1 /* minimum 1 packet per urb */ #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 audioformat {
struct list_head list; struct list_head list;
snd_pcm_format_t format; /* format type */ snd_pcm_format_t format; /* format type */
@@ -125,25 +121,27 @@ struct audioformat {
unsigned int *rate_table; /* rate table */ unsigned int *rate_table; /* rate table */
}; };
struct snd_usb_substream;
struct snd_urb_ctx { struct snd_urb_ctx {
struct urb *urb; struct urb *urb;
unsigned int buffer_size; /* size of data buffer, if data 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 index; /* index for urb array */
int packets; /* number of packets per urb */ int packets; /* number of packets per urb */
}; };
struct snd_urb_ops { struct snd_urb_ops {
int (*prepare)(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)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u); int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
int (*prepare_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u); int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
int (*retire_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u); int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
}; };
struct snd_usb_substream { struct snd_usb_substream {
snd_usb_stream_t *stream; struct snd_usb_stream *stream;
struct usb_device *dev; struct usb_device *dev;
snd_pcm_substream_t *pcm_substream; struct snd_pcm_substream *pcm_substream;
int direction; /* playback or capture */ int direction; /* playback or capture */
int interface; /* current interface */ int interface; /* current interface */
int endpoint; /* assigned endpoint */ int endpoint; /* assigned endpoint */
@@ -175,8 +173,8 @@ struct snd_usb_substream {
unsigned long unlink_mask; /* bitmask of unlinked urbs */ unsigned long unlink_mask; /* bitmask of unlinked urbs */
unsigned int nurbs; /* # urbs */ unsigned int nurbs; /* # urbs */
snd_urb_ctx_t dataurb[MAX_URBS]; /* data urb table */ struct snd_urb_ctx dataurb[MAX_URBS]; /* data urb table */
snd_urb_ctx_t syncurb[SYNC_URBS]; /* sync urb table */ struct snd_urb_ctx syncurb[SYNC_URBS]; /* sync urb table */
char *syncbuf; /* sync buffer for all sync URBs */ char *syncbuf; /* sync buffer for all sync URBs */
dma_addr_t sync_dma; /* DMA address of syncbuf */ dma_addr_t sync_dma; /* DMA address of syncbuf */
@@ -190,11 +188,11 @@ struct snd_usb_substream {
struct snd_usb_stream { struct snd_usb_stream {
snd_usb_audio_t *chip; struct snd_usb_audio *chip;
snd_pcm_t *pcm; struct snd_pcm *pcm;
int pcm_index; int pcm_index;
unsigned int fmt_type; /* USB audio format type (1-3) */ 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; struct list_head list;
}; };
@@ -205,7 +203,7 @@ struct snd_usb_stream {
*/ */
static DECLARE_MUTEX(register_mutex); 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 @@ static inline unsigned get_high_speed_hz(unsigned int usb_rate)
* fill the length and offset of each urb descriptor. * fill the length and offset of each urb descriptor.
* the fixed 10.14 frequency is passed through the pipe. * the fixed 10.14 frequency is passed through the pipe.
*/ */
static int prepare_capture_sync_urb(snd_usb_substream_t *subs, static int prepare_capture_sync_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
unsigned char *cp = urb->transfer_buffer; 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->dev = ctx->subs->dev; /* we need to set this at each time */
urb->iso_frame_desc[0].length = 3; urb->iso_frame_desc[0].length = 3;
@@ -267,12 +265,12 @@ static int prepare_capture_sync_urb(snd_usb_substream_t *subs,
* fill the length and offset of each urb descriptor. * fill the length and offset of each urb descriptor.
* the fixed 12.13 frequency is passed as 16.16 through the pipe. * 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, static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
unsigned char *cp = urb->transfer_buffer; 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->dev = ctx->subs->dev; /* we need to set this at each time */
urb->iso_frame_desc[0].length = 4; urb->iso_frame_desc[0].length = 4;
@@ -288,8 +286,8 @@ static int prepare_capture_sync_urb_hs(snd_usb_substream_t *subs,
* process after capture sync complete * process after capture sync complete
* - nothing to do * - nothing to do
*/ */
static int retire_capture_sync_urb(snd_usb_substream_t *subs, static int retire_capture_sync_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
return 0; return 0;
@@ -305,12 +303,12 @@ static int retire_capture_sync_urb(snd_usb_substream_t *subs,
* write onto the pcm buffer directly... the data is thus copied * write onto the pcm buffer directly... the data is thus copied
* later at complete callback to the global buffer. * later at complete callback to the global buffer.
*/ */
static int prepare_capture_urb(snd_usb_substream_t *subs, static int prepare_capture_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
int i, offs; 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; offs = 0;
urb->dev = ctx->subs->dev; /* we need to set this at each time */ urb->dev = ctx->subs->dev; /* we need to set this at each time */
@@ -340,8 +338,8 @@ static int prepare_capture_urb(snd_usb_substream_t *subs,
* copy the data from each desctiptor to the pcm buffer, and * copy the data from each desctiptor to the pcm buffer, and
* update the current position. * update the current position.
*/ */
static int retire_capture_urb(snd_usb_substream_t *subs, static int retire_capture_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
unsigned long flags; unsigned long flags;
@@ -395,11 +393,11 @@ static int retire_capture_urb(snd_usb_substream_t *subs,
* set up the offset and length to receive the current frequency. * set up the offset and length to receive the current frequency.
*/ */
static int prepare_playback_sync_urb(snd_usb_substream_t *subs, static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) 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->dev = ctx->subs->dev; /* we need to set this at each time */
urb->iso_frame_desc[0].length = 3; urb->iso_frame_desc[0].length = 3;
@@ -413,11 +411,11 @@ static int prepare_playback_sync_urb(snd_usb_substream_t *subs,
* set up the offset and length to receive the current frequency. * set up the offset and length to receive the current frequency.
*/ */
static int prepare_playback_sync_urb_hs(snd_usb_substream_t *subs, static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) 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->dev = ctx->subs->dev; /* we need to set this at each time */
urb->iso_frame_desc[0].length = 4; urb->iso_frame_desc[0].length = 4;
@@ -431,8 +429,8 @@ static int prepare_playback_sync_urb_hs(snd_usb_substream_t *subs,
* retrieve the current 10.14 frequency from pipe, and set it. * retrieve the current 10.14 frequency from pipe, and set it.
* the value is referred in prepare_playback_urb(). * the value is referred in prepare_playback_urb().
*/ */
static int retire_playback_sync_urb(snd_usb_substream_t *subs, static int retire_playback_sync_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
unsigned int f; unsigned int f;
@@ -457,8 +455,8 @@ static int retire_playback_sync_urb(snd_usb_substream_t *subs,
* retrieve the current 12.13 frequency from pipe, and set it. * retrieve the current 12.13 frequency from pipe, and set it.
* the value is referred in prepare_playback_urb(). * the value is referred in prepare_playback_urb().
*/ */
static int retire_playback_sync_urb_hs(snd_usb_substream_t *subs, static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
unsigned int f; unsigned int f;
@@ -482,12 +480,12 @@ static int retire_playback_sync_urb_hs(snd_usb_substream_t *subs,
* *
* We don't care about (or have) any data, so we just send a transfer delimiter. * 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, static int prepare_startup_playback_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
unsigned int i; unsigned int i;
snd_urb_ctx_t *ctx = urb->context; struct snd_urb_ctx *ctx = urb->context;
urb->dev = ctx->subs->dev; urb->dev = ctx->subs->dev;
urb->number_of_packets = subs->packs_per_ms; urb->number_of_packets = subs->packs_per_ms;
@@ -507,15 +505,15 @@ static int prepare_startup_playback_urb(snd_usb_substream_t *subs,
* To avoid inconsistencies when updating hwptr_done, we use double buffering * To avoid inconsistencies when updating hwptr_done, we use double buffering
* for all URBs. * for all URBs.
*/ */
static int prepare_playback_urb(snd_usb_substream_t *subs, static int prepare_playback_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
int i, stride, offs; int i, stride, offs;
unsigned int counts; unsigned int counts;
unsigned long flags; unsigned long flags;
int period_elapsed = 0; 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; stride = runtime->frame_bits >> 3;
@@ -597,8 +595,8 @@ static int prepare_playback_urb(snd_usb_substream_t *subs,
* process after playback data complete * process after playback data complete
* - nothing to do * - nothing to do
*/ */
static int retire_playback_urb(snd_usb_substream_t *subs, static int retire_playback_urb(struct snd_usb_substream *subs,
snd_pcm_runtime_t *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
return 0; return 0;
@@ -642,9 +640,9 @@ static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
*/ */
static void snd_complete_urb(struct urb *urb, struct pt_regs *regs) static void snd_complete_urb(struct urb *urb, struct pt_regs *regs)
{ {
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
snd_usb_substream_t *subs = ctx->subs; struct snd_usb_substream *subs = ctx->subs;
snd_pcm_substream_t *substream = ctx->subs->pcm_substream; struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
int err = 0; int err = 0;
if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) || if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
@@ -665,9 +663,9 @@ static void snd_complete_urb(struct urb *urb, struct pt_regs *regs)
*/ */
static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs) static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs)
{ {
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
snd_usb_substream_t *subs = ctx->subs; struct snd_usb_substream *subs = ctx->subs;
snd_pcm_substream_t *substream = ctx->subs->pcm_substream; struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
int err = 0; int err = 0;
if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) || if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
@@ -684,7 +682,7 @@ static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs)
/* get the physical page pointer at the given offset */ /* 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) unsigned long offset)
{ {
void *pageptr = subs->runtime->dma_area + offset; void *pageptr = subs->runtime->dma_area + offset;
@@ -692,9 +690,9 @@ static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs,
} }
/* allocate virtual buffer; may be called more than once */ /* 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_area) {
if (runtime->dma_bytes >= size) if (runtime->dma_bytes >= size)
return 0; /* already large enough */ return 0; /* already large enough */
@@ -708,9 +706,9 @@ static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
} }
/* free virtual buffer; may be called more than once */ /* 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) { if (runtime->dma_area) {
vfree(runtime->dma_area); vfree(runtime->dma_area);
runtime->dma_area = NULL; runtime->dma_area = NULL;
@@ -722,7 +720,7 @@ static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs)
/* /*
* unlink active urbs. * 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; unsigned int i;
int async; int async;
@@ -768,7 +766,7 @@ static int deactivate_urbs(snd_usb_substream_t *subs, int force, int can_sleep)
/* /*
* set up and start data/sync urbs * 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; unsigned int i;
int err; int err;
@@ -824,7 +822,7 @@ static int start_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
/* /*
* wait until all urbs are processed. * 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 long end_time = jiffies + msecs_to_jiffies(1000);
unsigned int i; unsigned int i;
@@ -855,12 +853,12 @@ static int wait_clear_urbs(snd_usb_substream_t *subs)
/* /*
* return the current pcm pointer. just return the hwptr_done value. * 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; 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); spin_lock(&subs->lock);
hwptr_done = subs->hwptr_done; hwptr_done = subs->hwptr_done;
spin_unlock(&subs->lock); spin_unlock(&subs->lock);
@@ -871,10 +869,10 @@ static snd_pcm_uframes_t snd_usb_pcm_pointer(snd_pcm_substream_t *substream)
/* /*
* start/stop playback substream * 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) int cmd)
{ {
snd_usb_substream_t *subs = substream->runtime->private_data; struct snd_usb_substream *subs = substream->runtime->private_data;
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
@@ -890,10 +888,10 @@ static int snd_usb_pcm_playback_trigger(snd_pcm_substream_t *substream,
/* /*
* start/stop capture substream * 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) int cmd)
{ {
snd_usb_substream_t *subs = substream->runtime->private_data; struct snd_usb_substream *subs = substream->runtime->private_data;
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
@@ -909,7 +907,7 @@ static int snd_usb_pcm_capture_trigger(snd_pcm_substream_t *substream,
/* /*
* release a urb data * 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->urb) {
if (u->buffer_size) if (u->buffer_size)
@@ -924,7 +922,7 @@ static void release_urb_ctx(snd_urb_ctx_t *u)
/* /*
* release a substream * 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; int i;
@@ -945,7 +943,7 @@ static void release_substream_urbs(snd_usb_substream_t *subs, int force)
/* /*
* initialize a substream for plaback/capture * 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 rate, unsigned int frame_bits)
{ {
unsigned int maxsize, n, i; unsigned int maxsize, n, i;
@@ -1045,7 +1043,7 @@ static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_by
/* allocate and initialize data urbs */ /* allocate and initialize data urbs */
for (i = 0; i < subs->nurbs; i++) { 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->index = i;
u->subs = subs; u->subs = subs;
u->packets = npacks[i]; u->packets = npacks[i];
@@ -1074,7 +1072,7 @@ static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_by
if (! subs->syncbuf) if (! subs->syncbuf)
goto out_of_memory; goto out_of_memory;
for (i = 0; i < SYNC_URBS; i++) { 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->index = i;
u->subs = subs; u->subs = subs;
u->packets = 1; u->packets = 1;
@@ -1104,7 +1102,7 @@ out_of_memory:
/* /*
* find a matching audio format * 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) unsigned int rate, unsigned int channels)
{ {
struct list_head *p; struct list_head *p;
@@ -1229,7 +1227,7 @@ static int init_usb_sample_rate(struct usb_device *dev, int iface,
/* /*
* find a matching format and set up the interface * 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_device *dev = subs->dev;
struct usb_host_interface *alts; struct usb_host_interface *alts;
@@ -1358,10 +1356,10 @@ static int set_format(snd_usb_substream_t *subs, struct audioformat *fmt)
* if sg buffer is supported on the later version of alsa, we'll follow * if sg buffer is supported on the later version of alsa, we'll follow
* that. * that.
*/ */
static int snd_usb_hw_params(snd_pcm_substream_t *substream, static int snd_usb_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t *hw_params) 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; struct audioformat *fmt;
unsigned int channels, rate, format; unsigned int channels, rate, format;
int ret, changed; int ret, changed;
@@ -1415,9 +1413,9 @@ static int snd_usb_hw_params(snd_pcm_substream_t *substream,
* *
* reset the audio format and release the buffer * 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_audiofmt = NULL;
subs->cur_rate = 0; subs->cur_rate = 0;
@@ -1431,10 +1429,10 @@ static int snd_usb_hw_free(snd_pcm_substream_t *substream)
* *
* only a few subtle things... * 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; struct snd_pcm_runtime *runtime = substream->runtime;
snd_usb_substream_t *subs = runtime->private_data; struct snd_usb_substream *subs = runtime->private_data;
if (! subs->cur_audiofmt) { if (! subs->cur_audiofmt) {
snd_printk(KERN_ERR "usbaudio: no format is specified!\n"); snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
@@ -1463,7 +1461,7 @@ static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream)
return 0; return 0;
} }
static snd_pcm_hardware_t snd_usb_playback = static struct snd_pcm_hardware snd_usb_playback =
{ {
.info = SNDRV_PCM_INFO_MMAP | .info = SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_MMAP_VALID |
@@ -1477,7 +1475,7 @@ static snd_pcm_hardware_t snd_usb_playback =
.periods_max = 1024, .periods_max = 1024,
}; };
static snd_pcm_hardware_t snd_usb_capture = static struct snd_pcm_hardware snd_usb_capture =
{ {
.info = SNDRV_PCM_INFO_MMAP | .info = SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_MMAP_VALID |
@@ -1501,11 +1499,11 @@ static snd_pcm_hardware_t snd_usb_capture =
#define hwc_debug(fmt, args...) /**/ #define hwc_debug(fmt, args...) /**/
#endif #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); struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
snd_interval_t *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); struct snd_interval *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_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
/* check the format */ /* check the format */
if (! snd_mask_test(fmts, fp->format)) { if (! snd_mask_test(fmts, fp->format)) {
@@ -1529,12 +1527,12 @@ static int hw_check_valid_format(snd_pcm_hw_params_t *params, struct audioformat
return 1; return 1;
} }
static int hw_rule_rate(snd_pcm_hw_params_t *params, static int hw_rule_rate(struct snd_pcm_hw_params *params,
snd_pcm_hw_rule_t *rule) struct snd_pcm_hw_rule *rule)
{ {
snd_usb_substream_t *subs = rule->private; struct snd_usb_substream *subs = rule->private;
struct list_head *p; 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; unsigned int rmin, rmax;
int changed; int changed;
@@ -1583,12 +1581,12 @@ static int hw_rule_rate(snd_pcm_hw_params_t *params,
} }
static int hw_rule_channels(snd_pcm_hw_params_t *params, static int hw_rule_channels(struct snd_pcm_hw_params *params,
snd_pcm_hw_rule_t *rule) struct snd_pcm_hw_rule *rule)
{ {
snd_usb_substream_t *subs = rule->private; struct snd_usb_substream *subs = rule->private;
struct list_head *p; 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; unsigned int rmin, rmax;
int changed; int changed;
@@ -1636,12 +1634,12 @@ static int hw_rule_channels(snd_pcm_hw_params_t *params,
return changed; return changed;
} }
static int hw_rule_format(snd_pcm_hw_params_t *params, static int hw_rule_format(struct snd_pcm_hw_params *params,
snd_pcm_hw_rule_t *rule) struct snd_pcm_hw_rule *rule)
{ {
snd_usb_substream_t *subs = rule->private; struct snd_usb_substream *subs = rule->private;
struct list_head *p; 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; u64 fbits;
u32 oldbits[2]; u32 oldbits[2];
int changed; int changed;
@@ -1674,7 +1672,7 @@ static int hw_rule_format(snd_pcm_hw_params_t *params,
/* /*
* check whether the registered audio formats need special hw-constraints * 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; int i;
u32 *channels; u32 *channels;
@@ -1758,7 +1756,7 @@ static int check_hw_params_convention(snd_usb_substream_t *subs)
* set up the runtime hardware information. * 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; struct list_head *p;
int err; int err;
@@ -1819,12 +1817,12 @@ static int setup_hw_info(snd_pcm_runtime_t *runtime, snd_usb_substream_t *subs)
return 0; return 0;
} }
static int snd_usb_pcm_open(snd_pcm_substream_t *substream, int direction, static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction,
snd_pcm_hardware_t *hw) struct snd_pcm_hardware *hw)
{ {
snd_usb_stream_t *as = snd_pcm_substream_chip(substream); struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_usb_substream_t *subs = &as->substream[direction]; struct snd_usb_substream *subs = &as->substream[direction];
subs->interface = -1; subs->interface = -1;
subs->format = 0; subs->format = 0;
@@ -1834,10 +1832,10 @@ static int snd_usb_pcm_open(snd_pcm_substream_t *substream, int direction,
return setup_hw_info(runtime, subs); 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); struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
snd_usb_substream_t *subs = &as->substream[direction]; struct snd_usb_substream *subs = &as->substream[direction];
if (subs->interface >= 0) { if (subs->interface >= 0) {
usb_set_interface(subs->dev, subs->interface, 0); usb_set_interface(subs->dev, subs->interface, 0);
@@ -1847,27 +1845,27 @@ static int snd_usb_pcm_close(snd_pcm_substream_t *substream, int direction)
return 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); 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); 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); 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); 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, .open = snd_usb_playback_open,
.close = snd_usb_playback_close, .close = snd_usb_playback_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
@@ -1879,7 +1877,7 @@ static snd_pcm_ops_t snd_usb_playback_ops = {
.page = snd_pcm_get_vmalloc_page, .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, .open = snd_usb_capture_open,
.close = snd_usb_capture_close, .close = snd_usb_capture_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
@@ -2007,7 +2005,7 @@ static struct usb_driver usb_audio_driver = {
/* /*
* proc interface for list the supported pcm formats * 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; struct list_head *p;
static char *sync_types[4] = { static char *sync_types[4] = {
@@ -2043,7 +2041,7 @@ static void proc_dump_substream_formats(snd_usb_substream_t *subs, snd_info_buff
} }
} }
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) { if (subs->running) {
unsigned int i; unsigned int i;
@@ -2065,9 +2063,9 @@ static void proc_dump_substream_status(snd_usb_substream_t *subs, snd_info_buffe
} }
} }
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); snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
@@ -2083,11 +2081,11 @@ static void proc_pcm_format_read(snd_info_entry_t *entry, snd_info_buffer_t *buf
} }
} }
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]; char name[32];
snd_card_t *card = stream->chip->card; struct snd_card *card = stream->chip->card;
sprintf(name, "stream%d", stream->pcm_index); sprintf(name, "stream%d", stream->pcm_index);
if (! snd_card_proc_new(card, name, &entry)) if (! snd_card_proc_new(card, name, &entry))
@@ -2099,9 +2097,9 @@ static void proc_pcm_format_add(snd_usb_stream_t *stream)
* initialize the substream instance. * 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); INIT_LIST_HEAD(&subs->fmt_list);
spin_lock_init(&subs->lock); spin_lock_init(&subs->lock);
@@ -2128,7 +2126,7 @@ static void init_substream(snd_usb_stream_t *as, int stream, struct audioformat
/* /*
* free a substream * 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; struct list_head *p, *n;
@@ -2145,7 +2143,7 @@ static void free_substream(snd_usb_substream_t *subs)
/* /*
* free a usb stream instance * 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[0]);
free_substream(&stream->substream[1]); free_substream(&stream->substream[1]);
@@ -2153,9 +2151,9 @@ static void snd_usb_audio_stream_free(snd_usb_stream_t *stream)
kfree(stream); 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) { if (stream) {
stream->pcm = NULL; stream->pcm = NULL;
snd_usb_audio_stream_free(stream); snd_usb_audio_stream_free(stream);
@@ -2168,16 +2166,16 @@ static void snd_usb_audio_pcm_free(snd_pcm_t *pcm)
* if a stream with the same endpoint already exists, append to it. * if a stream with the same endpoint already exists, append to it.
* if not, create a new pcm stream. * 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; struct list_head *p;
snd_usb_stream_t *as; struct snd_usb_stream *as;
snd_usb_substream_t *subs; struct snd_usb_substream *subs;
snd_pcm_t *pcm; struct snd_pcm *pcm;
int err; int err;
list_for_each(p, &chip->pcm_list) { 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) if (as->fmt_type != fp->fmt_type)
continue; continue;
subs = &as->substream[stream]; subs = &as->substream[stream];
@@ -2192,7 +2190,7 @@ static int add_audio_endpoint(snd_usb_audio_t *chip, int stream, struct audiofor
} }
/* look for an empty stream */ /* look for an empty stream */
list_for_each(p, &chip->pcm_list) { 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) if (as->fmt_type != fp->fmt_type)
continue; continue;
subs = &as->substream[stream]; subs = &as->substream[stream];
@@ -2244,7 +2242,7 @@ static int add_audio_endpoint(snd_usb_audio_t *chip, int stream, struct audiofor
/* /*
* check if the device uses big-endian samples * 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) { switch (chip->usb_id) {
case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */ case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
@@ -2266,7 +2264,7 @@ static int is_big_endian_format(snd_usb_audio_t *chip, struct audioformat *fp)
* @format: the format tag (wFormatTag) * @format: the format tag (wFormatTag)
* @fmt: the format type descriptor * @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 format, unsigned char *fmt)
{ {
int pcm_format; int pcm_format;
@@ -2349,7 +2347,7 @@ static int parse_audio_format_i_type(snd_usb_audio_t *chip, struct audioformat *
* @offset: the start offset of descriptor pointing the rate type * @offset: the start offset of descriptor pointing the rate type
* (7 for type I and II, 8 for type II) * (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) unsigned char *fmt, int offset)
{ {
int nr_rates = fmt[offset]; int nr_rates = fmt[offset];
@@ -2402,7 +2400,7 @@ static int parse_audio_format_rates(snd_usb_audio_t *chip, struct audioformat *f
/* /*
* parse the format type I and III descriptors * 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 format, unsigned char *fmt)
{ {
int pcm_format; int pcm_format;
@@ -2431,7 +2429,7 @@ static int parse_audio_format_i(snd_usb_audio_t *chip, struct audioformat *fp,
/* /*
* prase the format type II descriptor * 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 format, unsigned char *fmt)
{ {
int brate, framesize; int brate, framesize;
@@ -2458,7 +2456,7 @@ static int parse_audio_format_ii(snd_usb_audio_t *chip, struct audioformat *fp,
return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */ 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 format, unsigned char *fmt, int stream)
{ {
int err; int err;
@@ -2495,7 +2493,7 @@ static int parse_audio_format(snd_usb_audio_t *chip, struct audioformat *fp,
return 0; 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_device *dev;
struct usb_interface *iface; struct usb_interface *iface;
@@ -2646,10 +2644,10 @@ static int parse_audio_endpoints(snd_usb_audio_t *chip, int iface_no)
static void snd_usb_stream_disconnect(struct list_head *head) static void snd_usb_stream_disconnect(struct list_head *head)
{ {
int idx; int idx;
snd_usb_stream_t *as; struct snd_usb_stream *as;
snd_usb_substream_t *subs; 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++) { for (idx = 0; idx < 2; idx++) {
subs = &as->substream[idx]; subs = &as->substream[idx];
if (!subs->num_formats) if (!subs->num_formats)
@@ -2662,7 +2660,7 @@ static void snd_usb_stream_disconnect(struct list_head *head)
/* /*
* parse audio control descriptor and create pcm/midi streams * 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_device *dev = chip->dev;
struct usb_host_interface *host_iface; struct usb_host_interface *host_iface;
@@ -2729,9 +2727,9 @@ static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif)
/* /*
* create a stream for an endpoint/altsetting without proper descriptors * 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, struct usb_interface *iface,
const snd_usb_audio_quirk_t *quirk) const struct snd_usb_audio_quirk *quirk)
{ {
struct audioformat *fp; struct audioformat *fp;
struct usb_host_interface *alts; struct usb_host_interface *alts;
@@ -2778,9 +2776,9 @@ static int create_fixed_stream_quirk(snd_usb_audio_t *chip,
/* /*
* create a stream for an interface with proper descriptors * 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, 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_host_interface *alts;
struct usb_interface_descriptor *altsd; struct usb_interface_descriptor *altsd;
@@ -2803,9 +2801,9 @@ static int create_standard_audio_quirk(snd_usb_audio_t *chip,
* Create a stream for an Edirol UA-700/UA-25 interface. The only way * Create a stream for an Edirol UA-700/UA-25 interface. The only way
* to detect the sample rate is by looking at wMaxPacketSize. * 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, struct usb_interface *iface,
const snd_usb_audio_quirk_t *quirk) const struct snd_usb_audio_quirk *quirk)
{ {
static const struct audioformat ua_format = { static const struct audioformat ua_format = {
.format = SNDRV_PCM_FORMAT_S24_3LE, .format = SNDRV_PCM_FORMAT_S24_3LE,
@@ -2827,19 +2825,19 @@ static int create_ua700_ua25_quirk(snd_usb_audio_t *chip,
altsd = get_iface_desc(alts); altsd = get_iface_desc(alts);
if (altsd->bNumEndpoints == 2) { 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, .out_cables = 0x0003,
.in_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, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = &ua700_ep .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, .out_cables = 0x0001,
.in_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, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = &ua25_ep .data = &ua25_ep
}; };
@@ -2896,9 +2894,9 @@ static int create_ua700_ua25_quirk(snd_usb_audio_t *chip,
/* /*
* Create a stream for an Edirol UA-1000 interface. * 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, struct usb_interface *iface,
const snd_usb_audio_quirk_t *quirk) const struct snd_usb_audio_quirk *quirk)
{ {
static const struct audioformat ua1000_format = { static const struct audioformat ua1000_format = {
.format = SNDRV_PCM_FORMAT_S32_LE, .format = SNDRV_PCM_FORMAT_S32_LE,
@@ -2945,16 +2943,16 @@ static int create_ua1000_quirk(snd_usb_audio_t *chip,
return 0; 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, 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 * 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, 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 probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
int err; int err;
@@ -2975,9 +2973,9 @@ static int create_composite_quirk(snd_usb_audio_t *chip,
return 0; 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, struct usb_interface *iface,
const snd_usb_audio_quirk_t *quirk) const struct snd_usb_audio_quirk *quirk)
{ {
return 0; return 0;
} }
@@ -3040,12 +3038,12 @@ static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
* after this. * after this.
* returns a negative value at error. * 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, 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 *, typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *,
const snd_usb_audio_quirk_t *); const struct snd_usb_audio_quirk *);
static const quirk_func_t quirk_funcs[] = { static const quirk_func_t quirk_funcs[] = {
[QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk, [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
[QUIRK_COMPOSITE] = create_composite_quirk, [QUIRK_COMPOSITE] = create_composite_quirk,
@@ -3075,25 +3073,25 @@ static int snd_usb_create_quirk(snd_usb_audio_t *chip,
/* /*
* common proc files to show the usb device info * 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) if (! chip->shutdown)
snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum); 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) if (! chip->shutdown)
snd_iprintf(buffer, "%04x:%04x\n", snd_iprintf(buffer, "%04x:%04x\n",
USB_ID_VENDOR(chip->usb_id), USB_ID_VENDOR(chip->usb_id),
USB_ID_PRODUCT(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)) if (! snd_card_proc_new(chip->card, "usbbus", &entry))
snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbbus_read); snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbbus_read);
if (! snd_card_proc_new(chip->card, "usbid", &entry)) if (! snd_card_proc_new(chip->card, "usbid", &entry))
@@ -3107,15 +3105,15 @@ static void snd_usb_audio_create_proc(snd_usb_audio_t *chip)
* *
*/ */
static int snd_usb_audio_free(snd_usb_audio_t *chip) static int snd_usb_audio_free(struct snd_usb_audio *chip)
{ {
kfree(chip); kfree(chip);
return 0; 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); return snd_usb_audio_free(chip);
} }
@@ -3124,14 +3122,14 @@ static int snd_usb_audio_dev_free(snd_device_t *device)
* create a chip instance and set its names. * create a chip instance and set its names.
*/ */
static int snd_usb_audio_create(struct usb_device *dev, int idx, static int snd_usb_audio_create(struct usb_device *dev, int idx,
const snd_usb_audio_quirk_t *quirk, const struct snd_usb_audio_quirk *quirk,
snd_usb_audio_t **rchip) struct snd_usb_audio **rchip)
{ {
snd_card_t *card; struct snd_card *card;
snd_usb_audio_t *chip; struct snd_usb_audio *chip;
int err, len; int err, len;
char component[14]; char component[14];
static snd_device_ops_t ops = { static struct snd_device_ops ops = {
.dev_free = snd_usb_audio_dev_free, .dev_free = snd_usb_audio_dev_free,
}; };
@@ -3235,9 +3233,9 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
struct usb_interface *intf, struct usb_interface *intf,
const struct usb_device_id *usb_id) 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; int i, err;
snd_usb_audio_t *chip; struct snd_usb_audio *chip;
struct usb_host_interface *alts; struct usb_host_interface *alts;
int ifnum; int ifnum;
u32 id; u32 id;
@@ -3338,8 +3336,8 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
*/ */
static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr) static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
{ {
snd_usb_audio_t *chip; struct snd_usb_audio *chip;
snd_card_t *card; struct snd_card *card;
struct list_head *p; struct list_head *p;
if (ptr == (void *)-1L) if (ptr == (void *)-1L)

16
sound/usb/usbaudio.h
View File

@@ -126,12 +126,10 @@
/* /*
*/ */
typedef struct snd_usb_audio snd_usb_audio_t;
struct snd_usb_audio { struct snd_usb_audio {
int index; int index;
struct usb_device *dev; struct usb_device *dev;
snd_card_t *card; struct snd_card *card;
u32 usb_id; u32 usb_id;
int shutdown; int shutdown;
int num_interfaces; int num_interfaces;
@@ -172,9 +170,6 @@ enum quirk_type {
QUIRK_TYPE_COUNT QUIRK_TYPE_COUNT
}; };
typedef struct snd_usb_audio_quirk snd_usb_audio_quirk_t;
typedef struct snd_usb_midi_endpoint_info snd_usb_midi_endpoint_info_t;
struct snd_usb_audio_quirk { struct snd_usb_audio_quirk {
const char *vendor_name; const char *vendor_name;
const char *product_name; const char *product_name;
@@ -228,12 +223,15 @@ unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size);
void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype); void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype);
void *snd_usb_find_csint_desc(void *descstart, int desclen, void *after, u8 dsubtype); void *snd_usb_find_csint_desc(void *descstart, int desclen, void *after, u8 dsubtype);
int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype, __u16 value, __u16 index, void *data, __u16 size, int timeout); int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe,
__u8 request, __u8 requesttype, __u16 value, __u16 index,
void *data, __u16 size, int timeout);
int snd_usb_create_mixer(snd_usb_audio_t *chip, int ctrlif); int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif);
void snd_usb_mixer_disconnect(struct list_head *p); void snd_usb_mixer_disconnect(struct list_head *p);
int snd_usb_create_midi_interface(snd_usb_audio_t *chip, struct usb_interface *iface, const snd_usb_audio_quirk_t *quirk); int snd_usb_create_midi_interface(struct snd_usb_audio *chip, struct usb_interface *iface,
const struct snd_usb_audio_quirk *quirk);
void snd_usbmidi_input_stop(struct list_head* p); void snd_usbmidi_input_stop(struct list_head* p);
void snd_usbmidi_input_start(struct list_head* p); void snd_usbmidi_input_start(struct list_head* p);
void snd_usbmidi_disconnect(struct list_head *p); void snd_usbmidi_disconnect(struct list_head *p);

211
sound/usb/usbmidi.c
View File

@@ -84,39 +84,36 @@ struct usb_ms_endpoint_descriptor {
__u8 baAssocJackID[0]; __u8 baAssocJackID[0];
} __attribute__ ((packed)); } __attribute__ ((packed));
typedef struct snd_usb_midi snd_usb_midi_t; struct snd_usb_midi_in_endpoint;
typedef struct snd_usb_midi_endpoint snd_usb_midi_endpoint_t; struct snd_usb_midi_out_endpoint;
typedef struct snd_usb_midi_out_endpoint snd_usb_midi_out_endpoint_t; struct snd_usb_midi_endpoint;
typedef struct snd_usb_midi_in_endpoint snd_usb_midi_in_endpoint_t;
typedef struct usbmidi_out_port usbmidi_out_port_t;
typedef struct usbmidi_in_port usbmidi_in_port_t;
struct usb_protocol_ops { struct usb_protocol_ops {
void (*input)(snd_usb_midi_in_endpoint_t*, uint8_t*, int); void (*input)(struct snd_usb_midi_in_endpoint*, uint8_t*, int);
void (*output)(snd_usb_midi_out_endpoint_t*); void (*output)(struct snd_usb_midi_out_endpoint*);
void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t); void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t);
void (*init_out_endpoint)(snd_usb_midi_out_endpoint_t*); void (*init_out_endpoint)(struct snd_usb_midi_out_endpoint*);
void (*finish_out_endpoint)(snd_usb_midi_out_endpoint_t*); void (*finish_out_endpoint)(struct snd_usb_midi_out_endpoint*);
}; };
struct snd_usb_midi { struct snd_usb_midi {
snd_usb_audio_t *chip; struct snd_usb_audio *chip;
struct usb_interface *iface; struct usb_interface *iface;
const snd_usb_audio_quirk_t *quirk; const struct snd_usb_audio_quirk *quirk;
snd_rawmidi_t* rmidi; struct snd_rawmidi *rmidi;
struct usb_protocol_ops* usb_protocol_ops; struct usb_protocol_ops* usb_protocol_ops;
struct list_head list; struct list_head list;
struct timer_list error_timer; struct timer_list error_timer;
struct snd_usb_midi_endpoint { struct snd_usb_midi_endpoint {
snd_usb_midi_out_endpoint_t *out; struct snd_usb_midi_out_endpoint *out;
snd_usb_midi_in_endpoint_t *in; struct snd_usb_midi_in_endpoint *in;
} endpoints[MIDI_MAX_ENDPOINTS]; } endpoints[MIDI_MAX_ENDPOINTS];
unsigned long input_triggered; unsigned long input_triggered;
}; };
struct snd_usb_midi_out_endpoint { struct snd_usb_midi_out_endpoint {
snd_usb_midi_t* umidi; struct snd_usb_midi* umidi;
struct urb* urb; struct urb* urb;
int urb_active; int urb_active;
int max_transfer; /* size of urb buffer */ int max_transfer; /* size of urb buffer */
@@ -125,8 +122,8 @@ struct snd_usb_midi_out_endpoint {
spinlock_t buffer_lock; spinlock_t buffer_lock;
struct usbmidi_out_port { struct usbmidi_out_port {
snd_usb_midi_out_endpoint_t* ep; struct snd_usb_midi_out_endpoint* ep;
snd_rawmidi_substream_t* substream; struct snd_rawmidi_substream *substream;
int active; int active;
uint8_t cable; /* cable number << 4 */ uint8_t cable; /* cable number << 4 */
uint8_t state; uint8_t state;
@@ -143,17 +140,17 @@ struct snd_usb_midi_out_endpoint {
}; };
struct snd_usb_midi_in_endpoint { struct snd_usb_midi_in_endpoint {
snd_usb_midi_t* umidi; struct snd_usb_midi* umidi;
struct urb* urb; struct urb* urb;
struct usbmidi_in_port { struct usbmidi_in_port {
snd_rawmidi_substream_t* substream; struct snd_rawmidi_substream *substream;
} ports[0x10]; } ports[0x10];
u8 seen_f5; u8 seen_f5;
u8 error_resubmit; u8 error_resubmit;
int current_port; int current_port;
}; };
static void snd_usbmidi_do_output(snd_usb_midi_out_endpoint_t* ep); static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep);
static const uint8_t snd_usbmidi_cin_length[] = { static const uint8_t snd_usbmidi_cin_length[] = {
0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
@@ -196,10 +193,10 @@ static int snd_usbmidi_urb_error(int status)
/* /*
* Receives a chunk of MIDI data. * Receives a chunk of MIDI data.
*/ */
static void snd_usbmidi_input_data(snd_usb_midi_in_endpoint_t* ep, int portidx, static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint* ep, int portidx,
uint8_t* data, int length) uint8_t* data, int length)
{ {
usbmidi_in_port_t* port = &ep->ports[portidx]; struct usbmidi_in_port* port = &ep->ports[portidx];
if (!port->substream) { if (!port->substream) {
snd_printd("unexpected port %d!\n", portidx); snd_printd("unexpected port %d!\n", portidx);
@@ -227,7 +224,7 @@ static void dump_urb(const char *type, const u8 *data, int length)
*/ */
static void snd_usbmidi_in_urb_complete(struct urb* urb, struct pt_regs *regs) static void snd_usbmidi_in_urb_complete(struct urb* urb, struct pt_regs *regs)
{ {
snd_usb_midi_in_endpoint_t* ep = urb->context; struct snd_usb_midi_in_endpoint* ep = urb->context;
if (urb->status == 0) { if (urb->status == 0) {
dump_urb("received", urb->transfer_buffer, urb->actual_length); dump_urb("received", urb->transfer_buffer, urb->actual_length);
@@ -251,7 +248,7 @@ static void snd_usbmidi_in_urb_complete(struct urb* urb, struct pt_regs *regs)
static void snd_usbmidi_out_urb_complete(struct urb* urb, struct pt_regs *regs) static void snd_usbmidi_out_urb_complete(struct urb* urb, struct pt_regs *regs)
{ {
snd_usb_midi_out_endpoint_t* ep = urb->context; struct snd_usb_midi_out_endpoint* ep = urb->context;
spin_lock(&ep->buffer_lock); spin_lock(&ep->buffer_lock);
ep->urb_active = 0; ep->urb_active = 0;
@@ -272,7 +269,7 @@ static void snd_usbmidi_out_urb_complete(struct urb* urb, struct pt_regs *regs)
* This is called when some data should be transferred to the device * This is called when some data should be transferred to the device
* (from one or more substreams). * (from one or more substreams).
*/ */
static void snd_usbmidi_do_output(snd_usb_midi_out_endpoint_t* ep) static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep)
{ {
struct urb* urb = ep->urb; struct urb* urb = ep->urb;
unsigned long flags; unsigned long flags;
@@ -297,7 +294,7 @@ static void snd_usbmidi_do_output(snd_usb_midi_out_endpoint_t* ep)
static void snd_usbmidi_out_tasklet(unsigned long data) static void snd_usbmidi_out_tasklet(unsigned long data)
{ {
snd_usb_midi_out_endpoint_t* ep = (snd_usb_midi_out_endpoint_t *) data; struct snd_usb_midi_out_endpoint* ep = (struct snd_usb_midi_out_endpoint *) data;
snd_usbmidi_do_output(ep); snd_usbmidi_do_output(ep);
} }
@@ -305,11 +302,11 @@ static void snd_usbmidi_out_tasklet(unsigned long data)
/* called after transfers had been interrupted due to some USB error */ /* called after transfers had been interrupted due to some USB error */
static void snd_usbmidi_error_timer(unsigned long data) static void snd_usbmidi_error_timer(unsigned long data)
{ {
snd_usb_midi_t *umidi = (snd_usb_midi_t *)data; struct snd_usb_midi *umidi = (struct snd_usb_midi *)data;
int i; int i;
for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
snd_usb_midi_in_endpoint_t *in = umidi->endpoints[i].in; struct snd_usb_midi_in_endpoint *in = umidi->endpoints[i].in;
if (in && in->error_resubmit) { if (in && in->error_resubmit) {
in->error_resubmit = 0; in->error_resubmit = 0;
in->urb->dev = umidi->chip->dev; in->urb->dev = umidi->chip->dev;
@@ -321,7 +318,7 @@ static void snd_usbmidi_error_timer(unsigned long data)
} }
/* helper function to send static data that may not DMA-able */ /* helper function to send static data that may not DMA-able */
static int send_bulk_static_data(snd_usb_midi_out_endpoint_t* ep, static int send_bulk_static_data(struct snd_usb_midi_out_endpoint* ep,
const void *data, int len) const void *data, int len)
{ {
int err; int err;
@@ -342,7 +339,7 @@ static int send_bulk_static_data(snd_usb_midi_out_endpoint_t* ep,
* fourth byte in each packet, and uses length instead of CIN. * fourth byte in each packet, and uses length instead of CIN.
*/ */
static void snd_usbmidi_standard_input(snd_usb_midi_in_endpoint_t* ep, static void snd_usbmidi_standard_input(struct snd_usb_midi_in_endpoint* ep,
uint8_t* buffer, int buffer_length) uint8_t* buffer, int buffer_length)
{ {
int i; int i;
@@ -355,7 +352,7 @@ static void snd_usbmidi_standard_input(snd_usb_midi_in_endpoint_t* ep,
} }
} }
static void snd_usbmidi_midiman_input(snd_usb_midi_in_endpoint_t* ep, static void snd_usbmidi_midiman_input(struct snd_usb_midi_in_endpoint* ep,
uint8_t* buffer, int buffer_length) uint8_t* buffer, int buffer_length)
{ {
int i; int i;
@@ -401,7 +398,7 @@ static void snd_usbmidi_output_midiman_packet(struct urb* urb, uint8_t p0,
/* /*
* Converts MIDI commands to USB MIDI packets. * Converts MIDI commands to USB MIDI packets.
*/ */
static void snd_usbmidi_transmit_byte(usbmidi_out_port_t* port, static void snd_usbmidi_transmit_byte(struct usbmidi_out_port* port,
uint8_t b, struct urb* urb) uint8_t b, struct urb* urb)
{ {
uint8_t p0 = port->cable; uint8_t p0 = port->cable;
@@ -495,14 +492,14 @@ static void snd_usbmidi_transmit_byte(usbmidi_out_port_t* port,
} }
} }
static void snd_usbmidi_standard_output(snd_usb_midi_out_endpoint_t* ep) static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint* ep)
{ {
struct urb* urb = ep->urb; struct urb* urb = ep->urb;
int p; int p;
/* FIXME: lower-numbered ports can starve higher-numbered ports */ /* FIXME: lower-numbered ports can starve higher-numbered ports */
for (p = 0; p < 0x10; ++p) { for (p = 0; p < 0x10; ++p) {
usbmidi_out_port_t* port = &ep->ports[p]; struct usbmidi_out_port* port = &ep->ports[p];
if (!port->active) if (!port->active)
continue; continue;
while (urb->transfer_buffer_length + 3 < ep->max_transfer) { while (urb->transfer_buffer_length + 3 < ep->max_transfer) {
@@ -534,7 +531,7 @@ static struct usb_protocol_ops snd_usbmidi_midiman_ops = {
* at the third byte. * at the third byte.
*/ */
static void snd_usbmidi_novation_input(snd_usb_midi_in_endpoint_t* ep, static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint* ep,
uint8_t* buffer, int buffer_length) uint8_t* buffer, int buffer_length)
{ {
if (buffer_length < 2 || !buffer[0] || buffer_length < buffer[0] + 1) if (buffer_length < 2 || !buffer[0] || buffer_length < buffer[0] + 1)
@@ -542,7 +539,7 @@ static void snd_usbmidi_novation_input(snd_usb_midi_in_endpoint_t* ep,
snd_usbmidi_input_data(ep, 0, &buffer[2], buffer[0] - 1); snd_usbmidi_input_data(ep, 0, &buffer[2], buffer[0] - 1);
} }
static void snd_usbmidi_novation_output(snd_usb_midi_out_endpoint_t* ep) static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint* ep)
{ {
uint8_t* transfer_buffer; uint8_t* transfer_buffer;
int count; int count;
@@ -571,13 +568,13 @@ static struct usb_protocol_ops snd_usbmidi_novation_ops = {
* "raw" protocol: used by the MOTU FastLane. * "raw" protocol: used by the MOTU FastLane.
*/ */
static void snd_usbmidi_raw_input(snd_usb_midi_in_endpoint_t* ep, static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint* ep,
uint8_t* buffer, int buffer_length) uint8_t* buffer, int buffer_length)
{ {
snd_usbmidi_input_data(ep, 0, buffer, buffer_length); snd_usbmidi_input_data(ep, 0, buffer, buffer_length);
} }
static void snd_usbmidi_raw_output(snd_usb_midi_out_endpoint_t* ep) static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint* ep)
{ {
int count; int count;
@@ -602,7 +599,7 @@ static struct usb_protocol_ops snd_usbmidi_raw_ops = {
* Emagic USB MIDI protocol: raw MIDI with "F5 xx" port switching. * Emagic USB MIDI protocol: raw MIDI with "F5 xx" port switching.
*/ */
static void snd_usbmidi_emagic_init_out(snd_usb_midi_out_endpoint_t* ep) static void snd_usbmidi_emagic_init_out(struct snd_usb_midi_out_endpoint* ep)
{ {
static const u8 init_data[] = { static const u8 init_data[] = {
/* initialization magic: "get version" */ /* initialization magic: "get version" */
@@ -619,7 +616,7 @@ static void snd_usbmidi_emagic_init_out(snd_usb_midi_out_endpoint_t* ep)
send_bulk_static_data(ep, init_data, sizeof(init_data)); send_bulk_static_data(ep, init_data, sizeof(init_data));
} }
static void snd_usbmidi_emagic_finish_out(snd_usb_midi_out_endpoint_t* ep) static void snd_usbmidi_emagic_finish_out(struct snd_usb_midi_out_endpoint* ep)
{ {
static const u8 finish_data[] = { static const u8 finish_data[] = {
/* switch to patch mode with last preset */ /* switch to patch mode with last preset */
@@ -635,7 +632,7 @@ static void snd_usbmidi_emagic_finish_out(snd_usb_midi_out_endpoint_t* ep)
send_bulk_static_data(ep, finish_data, sizeof(finish_data)); send_bulk_static_data(ep, finish_data, sizeof(finish_data));
} }
static void snd_usbmidi_emagic_input(snd_usb_midi_in_endpoint_t* ep, static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint* ep,
uint8_t* buffer, int buffer_length) uint8_t* buffer, int buffer_length)
{ {
int i; int i;
@@ -679,7 +676,7 @@ static void snd_usbmidi_emagic_input(snd_usb_midi_in_endpoint_t* ep,
} }
} }
static void snd_usbmidi_emagic_output(snd_usb_midi_out_endpoint_t* ep) static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint* ep)
{ {
int port0 = ep->current_port; int port0 = ep->current_port;
uint8_t* buf = ep->urb->transfer_buffer; uint8_t* buf = ep->urb->transfer_buffer;
@@ -689,7 +686,7 @@ static void snd_usbmidi_emagic_output(snd_usb_midi_out_endpoint_t* ep)
for (i = 0; i < 0x10; ++i) { for (i = 0; i < 0x10; ++i) {
/* round-robin, starting at the last current port */ /* round-robin, starting at the last current port */
int portnum = (port0 + i) & 15; int portnum = (port0 + i) & 15;
usbmidi_out_port_t* port = &ep->ports[portnum]; struct usbmidi_out_port* port = &ep->ports[portnum];
if (!port->active) if (!port->active)
continue; continue;
@@ -733,10 +730,10 @@ static struct usb_protocol_ops snd_usbmidi_emagic_ops = {
}; };
static int snd_usbmidi_output_open(snd_rawmidi_substream_t* substream) static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream)
{ {
snd_usb_midi_t* umidi = substream->rmidi->private_data; struct snd_usb_midi* umidi = substream->rmidi->private_data;
usbmidi_out_port_t* port = NULL; struct usbmidi_out_port* port = NULL;
int i, j; int i, j;
for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i)
@@ -755,14 +752,14 @@ static int snd_usbmidi_output_open(snd_rawmidi_substream_t* substream)
return 0; return 0;
} }
static int snd_usbmidi_output_close(snd_rawmidi_substream_t* substream) static int snd_usbmidi_output_close(struct snd_rawmidi_substream *substream)
{ {
return 0; return 0;
} }
static void snd_usbmidi_output_trigger(snd_rawmidi_substream_t* substream, int up) static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream, int up)
{ {
usbmidi_out_port_t* port = (usbmidi_out_port_t*)substream->runtime->private_data; struct usbmidi_out_port* port = (struct usbmidi_out_port*)substream->runtime->private_data;
port->active = up; port->active = up;
if (up) { if (up) {
@@ -777,19 +774,19 @@ static void snd_usbmidi_output_trigger(snd_rawmidi_substream_t* substream, int u
} }
} }
static int snd_usbmidi_input_open(snd_rawmidi_substream_t* substream) static int snd_usbmidi_input_open(struct snd_rawmidi_substream *substream)
{ {
return 0; return 0;
} }
static int snd_usbmidi_input_close(snd_rawmidi_substream_t* substream) static int snd_usbmidi_input_close(struct snd_rawmidi_substream *substream)
{ {
return 0; return 0;
} }
static void snd_usbmidi_input_trigger(snd_rawmidi_substream_t* substream, int up) static void snd_usbmidi_input_trigger(struct snd_rawmidi_substream *substream, int up)
{ {
snd_usb_midi_t* umidi = substream->rmidi->private_data; struct snd_usb_midi* umidi = substream->rmidi->private_data;
if (up) if (up)
set_bit(substream->number, &umidi->input_triggered); set_bit(substream->number, &umidi->input_triggered);
@@ -797,13 +794,13 @@ static void snd_usbmidi_input_trigger(snd_rawmidi_substream_t* substream, int up
clear_bit(substream->number, &umidi->input_triggered); clear_bit(substream->number, &umidi->input_triggered);
} }
static snd_rawmidi_ops_t snd_usbmidi_output_ops = { static struct snd_rawmidi_ops snd_usbmidi_output_ops = {
.open = snd_usbmidi_output_open, .open = snd_usbmidi_output_open,
.close = snd_usbmidi_output_close, .close = snd_usbmidi_output_close,
.trigger = snd_usbmidi_output_trigger, .trigger = snd_usbmidi_output_trigger,
}; };
static snd_rawmidi_ops_t snd_usbmidi_input_ops = { static struct snd_rawmidi_ops snd_usbmidi_input_ops = {
.open = snd_usbmidi_input_open, .open = snd_usbmidi_input_open,
.close = snd_usbmidi_input_close, .close = snd_usbmidi_input_close,
.trigger = snd_usbmidi_input_trigger .trigger = snd_usbmidi_input_trigger
@@ -813,7 +810,7 @@ static snd_rawmidi_ops_t snd_usbmidi_input_ops = {
* Frees an input endpoint. * Frees an input endpoint.
* May be called when ep hasn't been initialized completely. * May be called when ep hasn't been initialized completely.
*/ */
static void snd_usbmidi_in_endpoint_delete(snd_usb_midi_in_endpoint_t* ep) static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint* ep)
{ {
if (ep->urb) { if (ep->urb) {
usb_buffer_free(ep->umidi->chip->dev, usb_buffer_free(ep->umidi->chip->dev,
@@ -828,11 +825,11 @@ static void snd_usbmidi_in_endpoint_delete(snd_usb_midi_in_endpoint_t* ep)
/* /*
* Creates an input endpoint. * Creates an input endpoint.
*/ */
static int snd_usbmidi_in_endpoint_create(snd_usb_midi_t* umidi, static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi,
snd_usb_midi_endpoint_info_t* ep_info, struct snd_usb_midi_endpoint_info* ep_info,
snd_usb_midi_endpoint_t* rep) struct snd_usb_midi_endpoint* rep)
{ {
snd_usb_midi_in_endpoint_t* ep; struct snd_usb_midi_in_endpoint* ep;
void* buffer; void* buffer;
unsigned int pipe; unsigned int pipe;
int length; int length;
@@ -885,7 +882,7 @@ static unsigned int snd_usbmidi_count_bits(unsigned int x)
* Frees an output endpoint. * Frees an output endpoint.
* May be called when ep hasn't been initialized completely. * May be called when ep hasn't been initialized completely.
*/ */
static void snd_usbmidi_out_endpoint_delete(snd_usb_midi_out_endpoint_t* ep) static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint* ep)
{ {
if (ep->urb) { if (ep->urb) {
usb_buffer_free(ep->umidi->chip->dev, ep->max_transfer, usb_buffer_free(ep->umidi->chip->dev, ep->max_transfer,
@@ -899,11 +896,11 @@ static void snd_usbmidi_out_endpoint_delete(snd_usb_midi_out_endpoint_t* ep)
/* /*
* Creates an output endpoint, and initializes output ports. * Creates an output endpoint, and initializes output ports.
*/ */
static int snd_usbmidi_out_endpoint_create(snd_usb_midi_t* umidi, static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
snd_usb_midi_endpoint_info_t* ep_info, struct snd_usb_midi_endpoint_info* ep_info,
snd_usb_midi_endpoint_t* rep) struct snd_usb_midi_endpoint* rep)
{ {
snd_usb_midi_out_endpoint_t* ep; struct snd_usb_midi_out_endpoint* ep;
int i; int i;
unsigned int pipe; unsigned int pipe;
void* buffer; void* buffer;
@@ -951,12 +948,12 @@ static int snd_usbmidi_out_endpoint_create(snd_usb_midi_t* umidi,
/* /*
* Frees everything. * Frees everything.
*/ */
static void snd_usbmidi_free(snd_usb_midi_t* umidi) static void snd_usbmidi_free(struct snd_usb_midi* umidi)
{ {
int i; int i;
for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
snd_usb_midi_endpoint_t* ep = &umidi->endpoints[i]; struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i];
if (ep->out) if (ep->out)
snd_usbmidi_out_endpoint_delete(ep->out); snd_usbmidi_out_endpoint_delete(ep->out);
if (ep->in) if (ep->in)
@@ -970,13 +967,13 @@ static void snd_usbmidi_free(snd_usb_midi_t* umidi)
*/ */
void snd_usbmidi_disconnect(struct list_head* p) void snd_usbmidi_disconnect(struct list_head* p)
{ {
snd_usb_midi_t* umidi; struct snd_usb_midi* umidi;
int i; int i;
umidi = list_entry(p, snd_usb_midi_t, list); umidi = list_entry(p, struct snd_usb_midi, list);
del_timer_sync(&umidi->error_timer); del_timer_sync(&umidi->error_timer);
for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
snd_usb_midi_endpoint_t* ep = &umidi->endpoints[i]; struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i];
if (ep->out) if (ep->out)
tasklet_kill(&ep->out->tasklet); tasklet_kill(&ep->out->tasklet);
if (ep->out && ep->out->urb) { if (ep->out && ep->out->urb) {
@@ -989,19 +986,19 @@ void snd_usbmidi_disconnect(struct list_head* p)
} }
} }
static void snd_usbmidi_rawmidi_free(snd_rawmidi_t* rmidi) static void snd_usbmidi_rawmidi_free(struct snd_rawmidi *rmidi)
{ {
snd_usb_midi_t* umidi = rmidi->private_data; struct snd_usb_midi* umidi = rmidi->private_data;
snd_usbmidi_free(umidi); snd_usbmidi_free(umidi);
} }
static snd_rawmidi_substream_t* snd_usbmidi_find_substream(snd_usb_midi_t* umidi, static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_midi* umidi,
int stream, int number) int stream, int number)
{ {
struct list_head* list; struct list_head* list;
list_for_each(list, &umidi->rmidi->streams[stream].substreams) { list_for_each(list, &umidi->rmidi->streams[stream].substreams) {
snd_rawmidi_substream_t* substream = list_entry(list, snd_rawmidi_substream_t, list); struct snd_rawmidi_substream *substream = list_entry(list, struct snd_rawmidi_substream, list);
if (substream->number == number) if (substream->number == number)
return substream; return substream;
} }
@@ -1097,14 +1094,14 @@ static struct {
{ USB_ID(0x086a, 0x0003), 4, "%s Broadcast" }, { USB_ID(0x086a, 0x0003), 4, "%s Broadcast" },
}; };
static void snd_usbmidi_init_substream(snd_usb_midi_t* umidi, static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi,
int stream, int number, int stream, int number,
snd_rawmidi_substream_t** rsubstream) struct snd_rawmidi_substream ** rsubstream)
{ {
int i; int i;
const char *name_format; const char *name_format;
snd_rawmidi_substream_t* substream = snd_usbmidi_find_substream(umidi, stream, number); struct snd_rawmidi_substream *substream = snd_usbmidi_find_substream(umidi, stream, number);
if (!substream) { if (!substream) {
snd_printd(KERN_ERR "substream %d:%d not found\n", stream, number); snd_printd(KERN_ERR "substream %d:%d not found\n", stream, number);
return; return;
@@ -1128,8 +1125,8 @@ static void snd_usbmidi_init_substream(snd_usb_midi_t* umidi,
/* /*
* Creates the endpoints and their ports. * Creates the endpoints and their ports.
*/ */
static int snd_usbmidi_create_endpoints(snd_usb_midi_t* umidi, static int snd_usbmidi_create_endpoints(struct snd_usb_midi* umidi,
snd_usb_midi_endpoint_info_t* endpoints) struct snd_usb_midi_endpoint_info* endpoints)
{ {
int i, j, err; int i, j, err;
int out_ports = 0, in_ports = 0; int out_ports = 0, in_ports = 0;
@@ -1169,8 +1166,8 @@ static int snd_usbmidi_create_endpoints(snd_usb_midi_t* umidi,
/* /*
* Returns MIDIStreaming device capabilities. * Returns MIDIStreaming device capabilities.
*/ */
static int snd_usbmidi_get_ms_info(snd_usb_midi_t* umidi, static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
snd_usb_midi_endpoint_info_t* endpoints) struct snd_usb_midi_endpoint_info* endpoints)
{ {
struct usb_interface* intf; struct usb_interface* intf;
struct usb_host_interface *hostif; struct usb_host_interface *hostif;
@@ -1244,7 +1241,7 @@ static int snd_usbmidi_get_ms_info(snd_usb_midi_t* umidi,
* On Roland devices, use the second alternate setting to be able to use * On Roland devices, use the second alternate setting to be able to use
* the interrupt input endpoint. * the interrupt input endpoint.
*/ */
static void snd_usbmidi_switch_roland_altsetting(snd_usb_midi_t* umidi) static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi* umidi)
{ {
struct usb_interface* intf; struct usb_interface* intf;
struct usb_host_interface *hostif; struct usb_host_interface *hostif;
@@ -1270,8 +1267,8 @@ static void snd_usbmidi_switch_roland_altsetting(snd_usb_midi_t* umidi)
/* /*
* Try to find any usable endpoints in the interface. * Try to find any usable endpoints in the interface.
*/ */
static int snd_usbmidi_detect_endpoints(snd_usb_midi_t* umidi, static int snd_usbmidi_detect_endpoints(struct snd_usb_midi* umidi,
snd_usb_midi_endpoint_info_t* endpoint, struct snd_usb_midi_endpoint_info* endpoint,
int max_endpoints) int max_endpoints)
{ {
struct usb_interface* intf; struct usb_interface* intf;
@@ -1318,8 +1315,8 @@ static int snd_usbmidi_detect_endpoints(snd_usb_midi_t* umidi,
/* /*
* Detects the endpoints for one-port-per-endpoint protocols. * Detects the endpoints for one-port-per-endpoint protocols.
*/ */
static int snd_usbmidi_detect_per_port_endpoints(snd_usb_midi_t* umidi, static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi* umidi,
snd_usb_midi_endpoint_info_t* endpoints) struct snd_usb_midi_endpoint_info* endpoints)
{ {
int err, i; int err, i;
@@ -1336,8 +1333,8 @@ static int snd_usbmidi_detect_per_port_endpoints(snd_usb_midi_t* umidi,
/* /*
* Detects the endpoints and ports of Yamaha devices. * Detects the endpoints and ports of Yamaha devices.
*/ */
static int snd_usbmidi_detect_yamaha(snd_usb_midi_t* umidi, static int snd_usbmidi_detect_yamaha(struct snd_usb_midi* umidi,
snd_usb_midi_endpoint_info_t* endpoint) struct snd_usb_midi_endpoint_info* endpoint)
{ {
struct usb_interface* intf; struct usb_interface* intf;
struct usb_host_interface *hostif; struct usb_host_interface *hostif;
@@ -1375,10 +1372,10 @@ static int snd_usbmidi_detect_yamaha(snd_usb_midi_t* umidi,
/* /*
* Creates the endpoints and their ports for Midiman devices. * Creates the endpoints and their ports for Midiman devices.
*/ */
static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi, static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi,
snd_usb_midi_endpoint_info_t* endpoint) struct snd_usb_midi_endpoint_info* endpoint)
{ {
snd_usb_midi_endpoint_info_t ep_info; struct snd_usb_midi_endpoint_info ep_info;
struct usb_interface* intf; struct usb_interface* intf;
struct usb_host_interface *hostif; struct usb_host_interface *hostif;
struct usb_interface_descriptor* intfd; struct usb_interface_descriptor* intfd;
@@ -1458,10 +1455,10 @@ static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi,
return 0; return 0;
} }
static int snd_usbmidi_create_rawmidi(snd_usb_midi_t* umidi, static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi,
int out_ports, int in_ports) int out_ports, int in_ports)
{ {
snd_rawmidi_t* rmidi; struct snd_rawmidi *rmidi;
int err; int err;
err = snd_rawmidi_new(umidi->chip->card, "USB MIDI", err = snd_rawmidi_new(umidi->chip->card, "USB MIDI",
@@ -1487,18 +1484,18 @@ static int snd_usbmidi_create_rawmidi(snd_usb_midi_t* umidi,
*/ */
void snd_usbmidi_input_stop(struct list_head* p) void snd_usbmidi_input_stop(struct list_head* p)
{ {
snd_usb_midi_t* umidi; struct snd_usb_midi* umidi;
int i; int i;
umidi = list_entry(p, snd_usb_midi_t, list); umidi = list_entry(p, struct snd_usb_midi, list);
for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
snd_usb_midi_endpoint_t* ep = &umidi->endpoints[i]; struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i];
if (ep->in) if (ep->in)
usb_kill_urb(ep->in->urb); usb_kill_urb(ep->in->urb);
} }
} }
static void snd_usbmidi_input_start_ep(snd_usb_midi_in_endpoint_t* ep) static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint* ep)
{ {
if (ep) { if (ep) {
struct urb* urb = ep->urb; struct urb* urb = ep->urb;
@@ -1512,10 +1509,10 @@ static void snd_usbmidi_input_start_ep(snd_usb_midi_in_endpoint_t* ep)
*/ */
void snd_usbmidi_input_start(struct list_head* p) void snd_usbmidi_input_start(struct list_head* p)
{ {
snd_usb_midi_t* umidi; struct snd_usb_midi* umidi;
int i; int i;
umidi = list_entry(p, snd_usb_midi_t, list); umidi = list_entry(p, struct snd_usb_midi, list);
for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i)
snd_usbmidi_input_start_ep(umidi->endpoints[i].in); snd_usbmidi_input_start_ep(umidi->endpoints[i].in);
} }
@@ -1523,12 +1520,12 @@ void snd_usbmidi_input_start(struct list_head* p)
/* /*
* Creates and registers everything needed for a MIDI streaming interface. * Creates and registers everything needed for a MIDI streaming interface.
*/ */
int snd_usb_create_midi_interface(snd_usb_audio_t* chip, int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
struct usb_interface* iface, struct usb_interface* iface,
const snd_usb_audio_quirk_t* quirk) const struct snd_usb_audio_quirk* quirk)
{ {
snd_usb_midi_t* umidi; struct snd_usb_midi* umidi;
snd_usb_midi_endpoint_info_t endpoints[MIDI_MAX_ENDPOINTS]; struct snd_usb_midi_endpoint_info endpoints[MIDI_MAX_ENDPOINTS];
int out_ports, in_ports; int out_ports, in_ports;
int i, err; int i, err;
@@ -1551,7 +1548,7 @@ int snd_usb_create_midi_interface(snd_usb_audio_t* chip,
break; break;
case QUIRK_MIDI_FIXED_ENDPOINT: case QUIRK_MIDI_FIXED_ENDPOINT:
memcpy(&endpoints[0], quirk->data, memcpy(&endpoints[0], quirk->data,
sizeof(snd_usb_midi_endpoint_info_t)); sizeof(struct snd_usb_midi_endpoint_info));
err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1); err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1);
break; break;
case QUIRK_MIDI_YAMAHA: case QUIRK_MIDI_YAMAHA:
@@ -1560,7 +1557,7 @@ int snd_usb_create_midi_interface(snd_usb_audio_t* chip,
case QUIRK_MIDI_MIDIMAN: case QUIRK_MIDI_MIDIMAN:
umidi->usb_protocol_ops = &snd_usbmidi_midiman_ops; umidi->usb_protocol_ops = &snd_usbmidi_midiman_ops;
memcpy(&endpoints[0], quirk->data, memcpy(&endpoints[0], quirk->data,
sizeof(snd_usb_midi_endpoint_info_t)); sizeof(struct snd_usb_midi_endpoint_info));
err = 0; err = 0;
break; break;
case QUIRK_MIDI_NOVATION: case QUIRK_MIDI_NOVATION:
@@ -1574,7 +1571,7 @@ int snd_usb_create_midi_interface(snd_usb_audio_t* chip,
case QUIRK_MIDI_EMAGIC: case QUIRK_MIDI_EMAGIC:
umidi->usb_protocol_ops = &snd_usbmidi_emagic_ops; umidi->usb_protocol_ops = &snd_usbmidi_emagic_ops;
memcpy(&endpoints[0], quirk->data, memcpy(&endpoints[0], quirk->data,
sizeof(snd_usb_midi_endpoint_info_t)); sizeof(struct snd_usb_midi_endpoint_info));
err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1); err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1);
break; break;
case QUIRK_MIDI_MIDITECH: case QUIRK_MIDI_MIDITECH:

183
sound/usb/usbmixer.c
View File

@@ -46,18 +46,13 @@
/* ignore error from controls - for debugging */ /* ignore error from controls - for debugging */
/* #define IGNORE_CTL_ERROR */ /* #define IGNORE_CTL_ERROR */
typedef struct usb_mixer_build mixer_build_t;
typedef struct usb_audio_term usb_audio_term_t;
typedef struct usb_mixer_elem_info usb_mixer_elem_info_t;
struct usb_mixer_interface { struct usb_mixer_interface {
snd_usb_audio_t *chip; struct snd_usb_audio *chip;
unsigned int ctrlif; unsigned int ctrlif;
struct list_head list; struct list_head list;
unsigned int ignore_ctl_error; unsigned int ignore_ctl_error;
struct urb *urb; struct urb *urb;
usb_mixer_elem_info_t **id_elems; /* array[256], indexed by unit id */ struct usb_mixer_elem_info **id_elems; /* array[256], indexed by unit id */
/* Sound Blaster remote control stuff */ /* Sound Blaster remote control stuff */
enum { enum {
@@ -86,21 +81,21 @@ struct usb_audio_term {
struct usbmix_name_map; struct usbmix_name_map;
struct usb_mixer_build { struct mixer_build {
snd_usb_audio_t *chip; struct snd_usb_audio *chip;
struct usb_mixer_interface *mixer; struct usb_mixer_interface *mixer;
unsigned char *buffer; unsigned char *buffer;
unsigned int buflen; unsigned int buflen;
DECLARE_BITMAP(unitbitmap, 256); DECLARE_BITMAP(unitbitmap, 256);
usb_audio_term_t oterm; struct usb_audio_term oterm;
const struct usbmix_name_map *map; const struct usbmix_name_map *map;
const struct usbmix_selector_map *selector_map; const struct usbmix_selector_map *selector_map;
}; };
struct usb_mixer_elem_info { struct usb_mixer_elem_info {
struct usb_mixer_interface *mixer; struct usb_mixer_interface *mixer;
usb_mixer_elem_info_t *next_id_elem; /* list of controls with same id */ struct usb_mixer_elem_info *next_id_elem; /* list of controls with same id */
snd_ctl_elem_id_t *elem_id; struct snd_ctl_elem_id *elem_id;
unsigned int id; unsigned int id;
unsigned int control; /* CS or ICN (high byte) */ unsigned int control; /* CS or ICN (high byte) */
unsigned int cmask; /* channel mask bitmap: 0 = master */ unsigned int cmask; /* channel mask bitmap: 0 = master */
@@ -179,7 +174,7 @@ enum {
#include "usbmixer_maps.c" #include "usbmixer_maps.c"
/* get the mapped name if the unit matches */ /* get the mapped name if the unit matches */
static int check_mapped_name(mixer_build_t *state, int unitid, int control, char *buf, int buflen) static int check_mapped_name(struct mixer_build *state, int unitid, int control, char *buf, int buflen)
{ {
const struct usbmix_name_map *p; const struct usbmix_name_map *p;
@@ -197,7 +192,7 @@ static int check_mapped_name(mixer_build_t *state, int unitid, int control, char
} }
/* check whether the control should be ignored */ /* check whether the control should be ignored */
static int check_ignored_ctl(mixer_build_t *state, int unitid, int control) static int check_ignored_ctl(struct mixer_build *state, int unitid, int control)
{ {
const struct usbmix_name_map *p; const struct usbmix_name_map *p;
@@ -214,7 +209,7 @@ static int check_ignored_ctl(mixer_build_t *state, int unitid, int control)
} }
/* get the mapped selector source name */ /* get the mapped selector source name */
static int check_mapped_selector_name(mixer_build_t *state, int unitid, static int check_mapped_selector_name(struct mixer_build *state, int unitid,
int index, char *buf, int buflen) int index, char *buf, int buflen)
{ {
const struct usbmix_selector_map *p; const struct usbmix_selector_map *p;
@@ -231,7 +226,7 @@ static int check_mapped_selector_name(mixer_build_t *state, int unitid,
/* /*
* find an audio control unit with the given unit id * find an audio control unit with the given unit id
*/ */
static void *find_audio_control_unit(mixer_build_t *state, unsigned char unit) static void *find_audio_control_unit(struct mixer_build *state, unsigned char unit)
{ {
unsigned char *p; unsigned char *p;
@@ -248,7 +243,7 @@ static void *find_audio_control_unit(mixer_build_t *state, unsigned char unit)
/* /*
* copy a string with the given id * copy a string with the given id
*/ */
static int snd_usb_copy_string_desc(mixer_build_t *state, int index, char *buf, int maxlen) static int snd_usb_copy_string_desc(struct mixer_build *state, int index, char *buf, int maxlen)
{ {
int len = usb_string(state->chip->dev, index, buf, maxlen - 1); int len = usb_string(state->chip->dev, index, buf, maxlen - 1);
buf[len] = 0; buf[len] = 0;
@@ -258,7 +253,7 @@ static int snd_usb_copy_string_desc(mixer_build_t *state, int index, char *buf,
/* /*
* convert from the byte/word on usb descriptor to the zero-based integer * convert from the byte/word on usb descriptor to the zero-based integer
*/ */
static int convert_signed_value(usb_mixer_elem_info_t *cval, int val) static int convert_signed_value(struct usb_mixer_elem_info *cval, int val)
{ {
switch (cval->val_type) { switch (cval->val_type) {
case USB_MIXER_BOOLEAN: case USB_MIXER_BOOLEAN:
@@ -288,7 +283,7 @@ static int convert_signed_value(usb_mixer_elem_info_t *cval, int val)
/* /*
* convert from the zero-based int to the byte/word for usb descriptor * convert from the zero-based int to the byte/word for usb descriptor
*/ */
static int convert_bytes_value(usb_mixer_elem_info_t *cval, int val) static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val)
{ {
switch (cval->val_type) { switch (cval->val_type) {
case USB_MIXER_BOOLEAN: case USB_MIXER_BOOLEAN:
@@ -305,7 +300,7 @@ static int convert_bytes_value(usb_mixer_elem_info_t *cval, int val)
return 0; /* not reached */ return 0; /* not reached */
} }
static int get_relative_value(usb_mixer_elem_info_t *cval, int val) static int get_relative_value(struct usb_mixer_elem_info *cval, int val)
{ {
if (! cval->res) if (! cval->res)
cval->res = 1; cval->res = 1;
@@ -317,7 +312,7 @@ static int get_relative_value(usb_mixer_elem_info_t *cval, int val)
return (val - cval->min) / cval->res; return (val - cval->min) / cval->res;
} }
static int get_abs_value(usb_mixer_elem_info_t *cval, int val) static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
{ {
if (val < 0) if (val < 0)
return cval->min; return cval->min;
@@ -335,7 +330,7 @@ static int get_abs_value(usb_mixer_elem_info_t *cval, int val)
* retrieve a mixer value * retrieve a mixer value
*/ */
static int get_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, int *value_ret) static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
{ {
unsigned char buf[2]; unsigned char buf[2];
int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1; int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
@@ -357,13 +352,13 @@ static int get_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, i
return -EINVAL; return -EINVAL;
} }
static int get_cur_ctl_value(usb_mixer_elem_info_t *cval, int validx, int *value) static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value)
{ {
return get_ctl_value(cval, GET_CUR, validx, value); return get_ctl_value(cval, GET_CUR, validx, value);
} }
/* channel = 0: master, 1 = first channel */ /* channel = 0: master, 1 = first channel */
static inline int get_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, int *value) static inline int get_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int *value)
{ {
return get_ctl_value(cval, GET_CUR, (cval->control << 8) | channel, value); return get_ctl_value(cval, GET_CUR, (cval->control << 8) | channel, value);
} }
@@ -372,7 +367,7 @@ static inline int get_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, in
* set a mixer value * set a mixer value
*/ */
static int set_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, int value_set) static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int value_set)
{ {
unsigned char buf[2]; unsigned char buf[2];
int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1; int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
@@ -394,12 +389,12 @@ static int set_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, i
return -EINVAL; return -EINVAL;
} }
static int set_cur_ctl_value(usb_mixer_elem_info_t *cval, int validx, int value) static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value)
{ {
return set_ctl_value(cval, SET_CUR, validx, value); return set_ctl_value(cval, SET_CUR, validx, value);
} }
static inline int set_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, int value) static inline int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int value)
{ {
return set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel, value); return set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel, value);
} }
@@ -409,7 +404,7 @@ static inline int set_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, in
* parser routines begin here... * parser routines begin here...
*/ */
static int parse_audio_unit(mixer_build_t *state, int unitid); static int parse_audio_unit(struct mixer_build *state, int unitid);
/* /*
@@ -430,9 +425,9 @@ static int check_matrix_bitmap(unsigned char *bmap, int ich, int och, int num_ou
* if failed, give up and free the control instance. * if failed, give up and free the control instance.
*/ */
static int add_control_to_empty(mixer_build_t *state, snd_kcontrol_t *kctl) static int add_control_to_empty(struct mixer_build *state, struct snd_kcontrol *kctl)
{ {
usb_mixer_elem_info_t *cval = kctl->private_data; struct usb_mixer_elem_info *cval = kctl->private_data;
int err; int err;
while (snd_ctl_find_id(state->chip->card, &kctl->id)) while (snd_ctl_find_id(state->chip->card, &kctl->id))
@@ -496,7 +491,7 @@ static struct iterm_name_combo {
{ 0 }, { 0 },
}; };
static int get_term_name(mixer_build_t *state, usb_audio_term_t *iterm, static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm,
unsigned char *name, int maxlen, int term_only) unsigned char *name, int maxlen, int term_only)
{ {
struct iterm_name_combo *names; struct iterm_name_combo *names;
@@ -546,7 +541,7 @@ static int get_term_name(mixer_build_t *state, usb_audio_term_t *iterm,
* parse the source unit recursively until it reaches to a terminal * parse the source unit recursively until it reaches to a terminal
* or a branched unit. * or a branched unit.
*/ */
static int check_input_term(mixer_build_t *state, int id, usb_audio_term_t *term) static int check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term)
{ {
unsigned char *p1; unsigned char *p1;
@@ -621,7 +616,7 @@ static struct usb_feature_control_info audio_feature_info[] = {
/* private_free callback */ /* private_free callback */
static void usb_mixer_elem_free(snd_kcontrol_t *kctl) static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
{ {
kfree(kctl->private_data); kfree(kctl->private_data);
kctl->private_data = NULL; kctl->private_data = NULL;
@@ -635,7 +630,7 @@ static void usb_mixer_elem_free(snd_kcontrol_t *kctl)
/* /*
* retrieve the minimum and maximum values for the specified control * retrieve the minimum and maximum values for the specified control
*/ */
static int get_min_max(usb_mixer_elem_info_t *cval, int default_min) static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
{ {
/* for failsafe */ /* for failsafe */
cval->min = default_min; cval->min = default_min;
@@ -683,9 +678,9 @@ static int get_min_max(usb_mixer_elem_info_t *cval, int default_min)
/* get a feature/mixer unit info */ /* get a feature/mixer unit info */
static int mixer_ctl_feature_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) static int mixer_ctl_feature_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{ {
usb_mixer_elem_info_t *cval = kcontrol->private_data; struct usb_mixer_elem_info *cval = kcontrol->private_data;
if (cval->val_type == USB_MIXER_BOOLEAN || if (cval->val_type == USB_MIXER_BOOLEAN ||
cval->val_type == USB_MIXER_INV_BOOLEAN) cval->val_type == USB_MIXER_INV_BOOLEAN)
@@ -707,9 +702,9 @@ static int mixer_ctl_feature_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
} }
/* get the current value from feature/mixer unit */ /* get the current value from feature/mixer unit */
static int mixer_ctl_feature_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
usb_mixer_elem_info_t *cval = kcontrol->private_data; struct usb_mixer_elem_info *cval = kcontrol->private_data;
int c, cnt, val, err; int c, cnt, val, err;
if (cval->cmask) { if (cval->cmask) {
@@ -748,9 +743,9 @@ static int mixer_ctl_feature_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
} }
/* put the current value to feature/mixer unit */ /* put the current value to feature/mixer unit */
static int mixer_ctl_feature_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
usb_mixer_elem_info_t *cval = kcontrol->private_data; struct usb_mixer_elem_info *cval = kcontrol->private_data;
int c, cnt, val, oval, err; int c, cnt, val, oval, err;
int changed = 0; int changed = 0;
@@ -791,7 +786,7 @@ static int mixer_ctl_feature_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
return changed; return changed;
} }
static snd_kcontrol_new_t usb_feature_unit_ctl = { static struct snd_kcontrol_new usb_feature_unit_ctl = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "", /* will be filled later manually */ .name = "", /* will be filled later manually */
.info = mixer_ctl_feature_info, .info = mixer_ctl_feature_info,
@@ -804,15 +799,15 @@ static snd_kcontrol_new_t usb_feature_unit_ctl = {
* build a feature control * build a feature control
*/ */
static void build_feature_ctl(mixer_build_t *state, unsigned char *desc, static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
unsigned int ctl_mask, int control, unsigned int ctl_mask, int control,
usb_audio_term_t *iterm, int unitid) struct usb_audio_term *iterm, int unitid)
{ {
unsigned int len = 0; unsigned int len = 0;
int mapped_name = 0; int mapped_name = 0;
int nameid = desc[desc[0] - 1]; int nameid = desc[desc[0] - 1];
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
usb_mixer_elem_info_t *cval; struct usb_mixer_elem_info *cval;
control++; /* change from zero-based to 1-based value */ control++; /* change from zero-based to 1-based value */
@@ -928,10 +923,10 @@ static void build_feature_ctl(mixer_build_t *state, unsigned char *desc,
* *
* most of controlls are defined here. * most of controlls are defined here.
*/ */
static int parse_audio_feature_unit(mixer_build_t *state, int unitid, unsigned char *ftr) static int parse_audio_feature_unit(struct mixer_build *state, int unitid, unsigned char *ftr)
{ {
int channels, i, j; int channels, i, j;
usb_audio_term_t iterm; struct usb_audio_term iterm;
unsigned int master_bits, first_ch_bits; unsigned int master_bits, first_ch_bits;
int err, csize; int err, csize;
@@ -984,15 +979,15 @@ static int parse_audio_feature_unit(mixer_build_t *state, int unitid, unsigned c
* input channel number (zero based) is given in control field instead. * input channel number (zero based) is given in control field instead.
*/ */
static void build_mixer_unit_ctl(mixer_build_t *state, unsigned char *desc, static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
int in_pin, int in_ch, int unitid, int in_pin, int in_ch, int unitid,
usb_audio_term_t *iterm) struct usb_audio_term *iterm)
{ {
usb_mixer_elem_info_t *cval; struct usb_mixer_elem_info *cval;
unsigned int input_pins = desc[4]; unsigned int input_pins = desc[4];
unsigned int num_outs = desc[5 + input_pins]; unsigned int num_outs = desc[5 + input_pins];
unsigned int i, len; unsigned int i, len;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
if (check_ignored_ctl(state, unitid, 0)) if (check_ignored_ctl(state, unitid, 0))
return; return;
@@ -1039,9 +1034,9 @@ static void build_mixer_unit_ctl(mixer_build_t *state, unsigned char *desc,
/* /*
* parse a mixer unit * parse a mixer unit
*/ */
static int parse_audio_mixer_unit(mixer_build_t *state, int unitid, unsigned char *desc) static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, unsigned char *desc)
{ {
usb_audio_term_t iterm; struct usb_audio_term iterm;
int input_pins, num_ins, num_outs; int input_pins, num_ins, num_outs;
int pin, ich, err; int pin, ich, err;
@@ -1089,9 +1084,9 @@ static int parse_audio_mixer_unit(mixer_build_t *state, int unitid, unsigned cha
*/ */
/* get callback for processing/extension unit */ /* get callback for processing/extension unit */
static int mixer_ctl_procunit_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) static int mixer_ctl_procunit_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
usb_mixer_elem_info_t *cval = kcontrol->private_data; struct usb_mixer_elem_info *cval = kcontrol->private_data;
int err, val; int err, val;
err = get_cur_ctl_value(cval, cval->control << 8, &val); err = get_cur_ctl_value(cval, cval->control << 8, &val);
@@ -1107,9 +1102,9 @@ static int mixer_ctl_procunit_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
} }
/* put callback for processing/extension unit */ /* put callback for processing/extension unit */
static int mixer_ctl_procunit_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) static int mixer_ctl_procunit_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
usb_mixer_elem_info_t *cval = kcontrol->private_data; struct usb_mixer_elem_info *cval = kcontrol->private_data;
int val, oval, err; int val, oval, err;
err = get_cur_ctl_value(cval, cval->control << 8, &oval); err = get_cur_ctl_value(cval, cval->control << 8, &oval);
@@ -1128,7 +1123,7 @@ static int mixer_ctl_procunit_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
} }
/* alsa control interface for processing/extension unit */ /* alsa control interface for processing/extension unit */
static snd_kcontrol_new_t mixer_procunit_ctl = { static struct snd_kcontrol_new mixer_procunit_ctl = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "", /* will be filled later */ .name = "", /* will be filled later */
.info = mixer_ctl_feature_info, .info = mixer_ctl_feature_info,
@@ -1205,11 +1200,11 @@ static struct procunit_info procunits[] = {
/* /*
* build a processing/extension unit * build a processing/extension unit
*/ */
static int build_audio_procunit(mixer_build_t *state, int unitid, unsigned char *dsc, struct procunit_info *list, char *name) static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned char *dsc, struct procunit_info *list, char *name)
{ {
int num_ins = dsc[6]; int num_ins = dsc[6];
usb_mixer_elem_info_t *cval; struct usb_mixer_elem_info *cval;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
int i, err, nameid, type, len; int i, err, nameid, type, len;
struct procunit_info *info; struct procunit_info *info;
struct procunit_value_info *valinfo; struct procunit_value_info *valinfo;
@@ -1297,12 +1292,12 @@ static int build_audio_procunit(mixer_build_t *state, int unitid, unsigned char
} }
static int parse_audio_processing_unit(mixer_build_t *state, int unitid, unsigned char *desc) static int parse_audio_processing_unit(struct mixer_build *state, int unitid, unsigned char *desc)
{ {
return build_audio_procunit(state, unitid, desc, procunits, "Processing Unit"); return build_audio_procunit(state, unitid, desc, procunits, "Processing Unit");
} }
static int parse_audio_extension_unit(mixer_build_t *state, int unitid, unsigned char *desc) static int parse_audio_extension_unit(struct mixer_build *state, int unitid, unsigned char *desc)
{ {
return build_audio_procunit(state, unitid, desc, NULL, "Extension Unit"); return build_audio_procunit(state, unitid, desc, NULL, "Extension Unit");
} }
@@ -1315,9 +1310,9 @@ static int parse_audio_extension_unit(mixer_build_t *state, int unitid, unsigned
/* info callback for selector unit /* info callback for selector unit
* use an enumerator type for routing * use an enumerator type for routing
*/ */
static int mixer_ctl_selector_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{ {
usb_mixer_elem_info_t *cval = kcontrol->private_data; struct usb_mixer_elem_info *cval = kcontrol->private_data;
char **itemlist = (char **)kcontrol->private_value; char **itemlist = (char **)kcontrol->private_value;
snd_assert(itemlist, return -EINVAL); snd_assert(itemlist, return -EINVAL);
@@ -1331,9 +1326,9 @@ static int mixer_ctl_selector_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
} }
/* get callback for selector unit */ /* get callback for selector unit */
static int mixer_ctl_selector_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
usb_mixer_elem_info_t *cval = kcontrol->private_data; struct usb_mixer_elem_info *cval = kcontrol->private_data;
int val, err; int val, err;
err = get_cur_ctl_value(cval, 0, &val); err = get_cur_ctl_value(cval, 0, &val);
@@ -1350,9 +1345,9 @@ static int mixer_ctl_selector_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
} }
/* put callback for selector unit */ /* put callback for selector unit */
static int mixer_ctl_selector_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
usb_mixer_elem_info_t *cval = kcontrol->private_data; struct usb_mixer_elem_info *cval = kcontrol->private_data;
int val, oval, err; int val, oval, err;
err = get_cur_ctl_value(cval, 0, &oval); err = get_cur_ctl_value(cval, 0, &oval);
@@ -1371,7 +1366,7 @@ static int mixer_ctl_selector_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
} }
/* alsa control interface for selector unit */ /* alsa control interface for selector unit */
static snd_kcontrol_new_t mixer_selectunit_ctl = { static struct snd_kcontrol_new mixer_selectunit_ctl = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "", /* will be filled later */ .name = "", /* will be filled later */
.info = mixer_ctl_selector_info, .info = mixer_ctl_selector_info,
@@ -1383,12 +1378,12 @@ static snd_kcontrol_new_t mixer_selectunit_ctl = {
/* private free callback. /* private free callback.
* free both private_data and private_value * free both private_data and private_value
*/ */
static void usb_mixer_selector_elem_free(snd_kcontrol_t *kctl) static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl)
{ {
int i, num_ins = 0; int i, num_ins = 0;
if (kctl->private_data) { if (kctl->private_data) {
usb_mixer_elem_info_t *cval = kctl->private_data; struct usb_mixer_elem_info *cval = kctl->private_data;
num_ins = cval->max; num_ins = cval->max;
kfree(cval); kfree(cval);
kctl->private_data = NULL; kctl->private_data = NULL;
@@ -1405,13 +1400,13 @@ static void usb_mixer_selector_elem_free(snd_kcontrol_t *kctl)
/* /*
* parse a selector unit * parse a selector unit
*/ */
static int parse_audio_selector_unit(mixer_build_t *state, int unitid, unsigned char *desc) static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsigned char *desc)
{ {
unsigned int num_ins = desc[4]; unsigned int num_ins = desc[4];
unsigned int i, nameid, len; unsigned int i, nameid, len;
int err; int err;
usb_mixer_elem_info_t *cval; struct usb_mixer_elem_info *cval;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
char **namelist; char **namelist;
if (! num_ins || desc[0] < 6 + num_ins) { if (! num_ins || desc[0] < 6 + num_ins) {
@@ -1452,7 +1447,7 @@ static int parse_audio_selector_unit(mixer_build_t *state, int unitid, unsigned
} }
#define MAX_ITEM_NAME_LEN 64 #define MAX_ITEM_NAME_LEN 64
for (i = 0; i < num_ins; i++) { for (i = 0; i < num_ins; i++) {
usb_audio_term_t iterm; struct usb_audio_term iterm;
len = 0; len = 0;
namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL); namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
if (! namelist[i]) { if (! namelist[i]) {
@@ -1511,7 +1506,7 @@ static int parse_audio_selector_unit(mixer_build_t *state, int unitid, unsigned
* parse an audio unit recursively * parse an audio unit recursively
*/ */
static int parse_audio_unit(mixer_build_t *state, int unitid) static int parse_audio_unit(struct mixer_build *state, int unitid)
{ {
unsigned char *p1; unsigned char *p1;
@@ -1556,7 +1551,7 @@ static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
kfree(mixer); kfree(mixer);
} }
static int snd_usb_mixer_dev_free(snd_device_t *device) static int snd_usb_mixer_dev_free(struct snd_device *device)
{ {
struct usb_mixer_interface *mixer = device->device_data; struct usb_mixer_interface *mixer = device->device_data;
snd_usb_mixer_free(mixer); snd_usb_mixer_free(mixer);
@@ -1571,7 +1566,7 @@ static int snd_usb_mixer_dev_free(snd_device_t *device)
static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer) static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
{ {
unsigned char *desc; unsigned char *desc;
mixer_build_t state; struct mixer_build state;
int err; int err;
const struct usbmix_ctl_map *map; const struct usbmix_ctl_map *map;
struct usb_host_interface *hostif; struct usb_host_interface *hostif;
@@ -1611,7 +1606,7 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
static void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, static void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer,
int unitid) int unitid)
{ {
usb_mixer_elem_info_t *info; struct usb_mixer_elem_info *info;
for (info = mixer->id_elems[unitid]; info; info = info->next_id_elem) for (info = mixer->id_elems[unitid]; info; info = info->next_id_elem)
snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
@@ -1725,7 +1720,7 @@ static void snd_usb_soundblaster_remote_complete(struct urb *urb,
wake_up(&mixer->rc_waitq); wake_up(&mixer->rc_waitq);
} }
static int snd_usb_sbrc_hwdep_open(snd_hwdep_t *hw, struct file *file) static int snd_usb_sbrc_hwdep_open(struct snd_hwdep *hw, struct file *file)
{ {
struct usb_mixer_interface *mixer = hw->private_data; struct usb_mixer_interface *mixer = hw->private_data;
@@ -1734,7 +1729,7 @@ static int snd_usb_sbrc_hwdep_open(snd_hwdep_t *hw, struct file *file)
return 0; return 0;
} }
static int snd_usb_sbrc_hwdep_release(snd_hwdep_t *hw, struct file *file) static int snd_usb_sbrc_hwdep_release(struct snd_hwdep *hw, struct file *file)
{ {
struct usb_mixer_interface *mixer = hw->private_data; struct usb_mixer_interface *mixer = hw->private_data;
@@ -1743,7 +1738,7 @@ static int snd_usb_sbrc_hwdep_release(snd_hwdep_t *hw, struct file *file)
return 0; return 0;
} }
static long snd_usb_sbrc_hwdep_read(snd_hwdep_t *hw, char __user *buf, static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
long count, loff_t *offset) long count, loff_t *offset)
{ {
struct usb_mixer_interface *mixer = hw->private_data; struct usb_mixer_interface *mixer = hw->private_data;
@@ -1763,7 +1758,7 @@ static long snd_usb_sbrc_hwdep_read(snd_hwdep_t *hw, char __user *buf,
return err < 0 ? err : count; return err < 0 ? err : count;
} }
static unsigned int snd_usb_sbrc_hwdep_poll(snd_hwdep_t *hw, struct file *file, static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
poll_table *wait) poll_table *wait)
{ {
struct usb_mixer_interface *mixer = hw->private_data; struct usb_mixer_interface *mixer = hw->private_data;
@@ -1774,7 +1769,7 @@ static unsigned int snd_usb_sbrc_hwdep_poll(snd_hwdep_t *hw, struct file *file,
static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer) static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
{ {
snd_hwdep_t *hwdep; struct snd_hwdep *hwdep;
int err, len; int err, len;
switch (mixer->chip->usb_id) { switch (mixer->chip->usb_id) {
@@ -1825,7 +1820,7 @@ static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
return 0; return 0;
} }
static int snd_audigy2nx_led_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) static int snd_audigy2nx_led_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 1; uinfo->count = 1;
@@ -1834,7 +1829,7 @@ static int snd_audigy2nx_led_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
return 0; return 0;
} }
static int snd_audigy2nx_led_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
int index = kcontrol->private_value; int index = kcontrol->private_value;
@@ -1843,7 +1838,7 @@ static int snd_audigy2nx_led_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
return 0; return 0;
} }
static int snd_audigy2nx_led_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
int index = kcontrol->private_value; int index = kcontrol->private_value;
@@ -1863,7 +1858,7 @@ static int snd_audigy2nx_led_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
return changed; return changed;
} }
static snd_kcontrol_new_t snd_audigy2nx_controls[] = { static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "CMSS LED Switch", .name = "CMSS LED Switch",
@@ -1904,8 +1899,8 @@ static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
return 0; return 0;
} }
static void snd_audigy2nx_proc_read(snd_info_entry_t *entry, static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
snd_info_buffer_t *buffer) struct snd_info_buffer *buffer)
{ {
static const struct { static const struct {
int unitid; int unitid;
@@ -1935,9 +1930,9 @@ static void snd_audigy2nx_proc_read(snd_info_entry_t *entry,
} }
} }
int snd_usb_create_mixer(snd_usb_audio_t *chip, int ctrlif) int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif)
{ {
static snd_device_ops_t dev_ops = { static struct snd_device_ops dev_ops = {
.dev_free = snd_usb_mixer_dev_free .dev_free = snd_usb_mixer_dev_free
}; };
struct usb_mixer_interface *mixer; struct usb_mixer_interface *mixer;
@@ -1967,7 +1962,7 @@ int snd_usb_create_mixer(snd_usb_audio_t *chip, int ctrlif)
goto _error; goto _error;
if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020)) { if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020)) {
snd_info_entry_t *entry; struct snd_info_entry *entry;
if ((err = snd_audigy2nx_controls_create(mixer)) < 0) if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
goto _error; goto _error;

270
sound/usb/usbquirks.h
View File

@@ -45,7 +45,7 @@
#define YAMAHA_DEVICE(id, name) { \ #define YAMAHA_DEVICE(id, name) { \
USB_DEVICE(0x0499, id), \ USB_DEVICE(0x0499, id), \
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \ .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
.vendor_name = "Yamaha", \ .vendor_name = "Yamaha", \
.product_name = name, \ .product_name = name, \
.ifnum = QUIRK_ANY_INTERFACE, \ .ifnum = QUIRK_ANY_INTERFACE, \
@@ -54,7 +54,7 @@
} }
#define YAMAHA_INTERFACE(id, intf, name) { \ #define YAMAHA_INTERFACE(id, intf, name) { \
USB_DEVICE_VENDOR_SPEC(0x0499, id), \ USB_DEVICE_VENDOR_SPEC(0x0499, id), \
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \ .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
.vendor_name = "Yamaha", \ .vendor_name = "Yamaha", \
.product_name = name, \ .product_name = name, \
.ifnum = intf, \ .ifnum = intf, \
@@ -149,12 +149,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
*/ */
{ {
USB_DEVICE(0x0582, 0x0000), USB_DEVICE(0x0582, 0x0000),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "UA-100", .product_name = "UA-100",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_AUDIO_FIXED_ENDPOINT, .type = QUIRK_AUDIO_FIXED_ENDPOINT,
@@ -192,7 +192,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0007, .out_cables = 0x0007,
.in_cables = 0x0007 .in_cables = 0x0007
} }
@@ -205,12 +205,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x0582, 0x0002), USB_DEVICE(0x0582, 0x0002),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UM-4", .product_name = "UM-4",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -222,7 +222,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x000f, .out_cables = 0x000f,
.in_cables = 0x000f .in_cables = 0x000f
} }
@@ -235,12 +235,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x0582, 0x0003), USB_DEVICE(0x0582, 0x0003),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "SC-8850", .product_name = "SC-8850",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -252,7 +252,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x003f, .out_cables = 0x003f,
.in_cables = 0x003f .in_cables = 0x003f
} }
@@ -265,12 +265,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x0582, 0x0004), USB_DEVICE(0x0582, 0x0004),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "U-8", .product_name = "U-8",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -282,7 +282,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0005, .out_cables = 0x0005,
.in_cables = 0x0005 .in_cables = 0x0005
} }
@@ -296,12 +296,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* a later revision uses ID 0x0099 */ /* a later revision uses ID 0x0099 */
USB_DEVICE(0x0582, 0x0005), USB_DEVICE(0x0582, 0x0005),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UM-2", .product_name = "UM-2",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -313,7 +313,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0003, .out_cables = 0x0003,
.in_cables = 0x0003 .in_cables = 0x0003
} }
@@ -326,12 +326,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x0582, 0x0007), USB_DEVICE(0x0582, 0x0007),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "SC-8820", .product_name = "SC-8820",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -343,7 +343,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0013, .out_cables = 0x0013,
.in_cables = 0x0013 .in_cables = 0x0013
} }
@@ -356,12 +356,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x0582, 0x0008), USB_DEVICE(0x0582, 0x0008),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "PC-300", .product_name = "PC-300",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -373,7 +373,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -387,12 +387,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* a later revision uses ID 0x009d */ /* a later revision uses ID 0x009d */
USB_DEVICE(0x0582, 0x0009), USB_DEVICE(0x0582, 0x0009),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UM-1", .product_name = "UM-1",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -404,7 +404,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -417,12 +417,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x0582, 0x000b), USB_DEVICE(0x0582, 0x000b),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "SK-500", .product_name = "SK-500",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -434,7 +434,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0013, .out_cables = 0x0013,
.in_cables = 0x0013 .in_cables = 0x0013
} }
@@ -449,12 +449,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
/* thanks to Emiliano Grilli <emillo@libero.it> /* thanks to Emiliano Grilli <emillo@libero.it>
* for helping researching this data */ * for helping researching this data */
USB_DEVICE(0x0582, 0x000c), USB_DEVICE(0x0582, 0x000c),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "SC-D70", .product_name = "SC-D70",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_AUDIO_FIXED_ENDPOINT, .type = QUIRK_AUDIO_FIXED_ENDPOINT,
@@ -492,7 +492,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0007, .out_cables = 0x0007,
.in_cables = 0x0007 .in_cables = 0x0007
} }
@@ -513,12 +513,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* the 96kHz sample rate. * the 96kHz sample rate.
*/ */
USB_DEVICE(0x0582, 0x0010), USB_DEVICE(0x0582, 0x0010),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UA-5", .product_name = "UA-5",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 1, .ifnum = 1,
.type = QUIRK_AUDIO_STANDARD_INTERFACE .type = QUIRK_AUDIO_STANDARD_INTERFACE
@@ -536,12 +536,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0013 when not in "Advanced Driver" mode */ /* has ID 0x0013 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0012), USB_DEVICE(0x0582, 0x0012),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "XV-5050", .product_name = "XV-5050",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -550,12 +550,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0015 when not in "Advanced Driver" mode */ /* has ID 0x0015 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0014), USB_DEVICE(0x0582, 0x0014),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UM-880", .product_name = "UM-880",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x01ff, .out_cables = 0x01ff,
.in_cables = 0x01ff .in_cables = 0x01ff
} }
@@ -564,12 +564,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0017 when not in "Advanced Driver" mode */ /* has ID 0x0017 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0016), USB_DEVICE(0x0582, 0x0016),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "SD-90", .product_name = "SD-90",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -581,7 +581,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x000f, .out_cables = 0x000f,
.in_cables = 0x000f .in_cables = 0x000f
} }
@@ -595,12 +595,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x001c when not in "Advanced Driver" mode */ /* has ID 0x001c when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x001b), USB_DEVICE(0x0582, 0x001b),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "MMP-2", .product_name = "MMP-2",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -612,7 +612,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -626,12 +626,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x001e when not in "Advanced Driver" mode */ /* has ID 0x001e when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x001d), USB_DEVICE(0x0582, 0x001d),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "V-SYNTH", .product_name = "V-SYNTH",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -640,12 +640,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0024 when not in "Advanced Driver" mode */ /* has ID 0x0024 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0023), USB_DEVICE(0x0582, 0x0023),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UM-550", .product_name = "UM-550",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x003f, .out_cables = 0x003f,
.in_cables = 0x003f .in_cables = 0x003f
} }
@@ -658,12 +658,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* and no MIDI. * and no MIDI.
*/ */
USB_DEVICE(0x0582, 0x0025), USB_DEVICE(0x0582, 0x0025),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UA-20", .product_name = "UA-20",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 1, .ifnum = 1,
.type = QUIRK_AUDIO_STANDARD_INTERFACE .type = QUIRK_AUDIO_STANDARD_INTERFACE
@@ -685,12 +685,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0028 when not in "Advanced Driver" mode */ /* has ID 0x0028 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0027), USB_DEVICE(0x0582, 0x0027),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "SD-20", .product_name = "SD-20",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0003, .out_cables = 0x0003,
.in_cables = 0x0007 .in_cables = 0x0007
} }
@@ -699,12 +699,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x002a when not in "Advanced Driver" mode */ /* has ID 0x002a when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0029), USB_DEVICE(0x0582, 0x0029),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "SD-80", .product_name = "SD-80",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x000f, .out_cables = 0x000f,
.in_cables = 0x000f .in_cables = 0x000f
} }
@@ -717,12 +717,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* but offers only 16-bit PCM and no MIDI. * but offers only 16-bit PCM and no MIDI.
*/ */
USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b), USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UA-700", .product_name = "UA-700",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 1, .ifnum = 1,
.type = QUIRK_AUDIO_EDIROL_UA700_UA25 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
@@ -744,12 +744,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x002e when not in "Advanced Driver" mode */ /* has ID 0x002e when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x002d), USB_DEVICE(0x0582, 0x002d),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "XV-2020", .product_name = "XV-2020",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -758,12 +758,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0030 when not in "Advanced Driver" mode */ /* has ID 0x0030 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x002f), USB_DEVICE(0x0582, 0x002f),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "VariOS", .product_name = "VariOS",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0007, .out_cables = 0x0007,
.in_cables = 0x0007 .in_cables = 0x0007
} }
@@ -772,12 +772,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0034 when not in "Advanced Driver" mode */ /* has ID 0x0034 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0033), USB_DEVICE(0x0582, 0x0033),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "PCR", .product_name = "PCR",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0003, .out_cables = 0x0003,
.in_cables = 0x0007 .in_cables = 0x0007
} }
@@ -790,12 +790,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* later revisions use IDs 0x0054 and 0x00a2. * later revisions use IDs 0x0054 and 0x00a2.
*/ */
USB_DEVICE(0x0582, 0x0037), USB_DEVICE(0x0582, 0x0037),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "Digital Piano", .product_name = "Digital Piano",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -808,12 +808,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* and no MIDI. * and no MIDI.
*/ */
USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b), USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "BOSS", .vendor_name = "BOSS",
.product_name = "GS-10", .product_name = "GS-10",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = & (const snd_usb_audio_quirk_t[]) { .data = & (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 1, .ifnum = 1,
.type = QUIRK_AUDIO_STANDARD_INTERFACE .type = QUIRK_AUDIO_STANDARD_INTERFACE
@@ -835,12 +835,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0041 when not in "Advanced Driver" mode */ /* has ID 0x0041 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0040), USB_DEVICE(0x0582, 0x0040),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "GI-20", .product_name = "GI-20",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -849,12 +849,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0043 when not in "Advanced Driver" mode */ /* has ID 0x0043 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0042), USB_DEVICE(0x0582, 0x0042),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "RS-70", .product_name = "RS-70",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -862,12 +862,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x0582, 0x0044), USB_DEVICE(0x0582, 0x0044),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "UA-1000", .product_name = "UA-1000",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 1, .ifnum = 1,
.type = QUIRK_AUDIO_EDIROL_UA1000 .type = QUIRK_AUDIO_EDIROL_UA1000
@@ -879,7 +879,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 3, .ifnum = 3,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0003, .out_cables = 0x0003,
.in_cables = 0x0003 .in_cables = 0x0003
} }
@@ -893,12 +893,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x004a when not in "Advanced Driver" mode */ /* has ID 0x004a when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0048), USB_DEVICE(0x0582, 0x0048),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UR-80", .product_name = "UR-80",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0003, .out_cables = 0x0003,
.in_cables = 0x0007 .in_cables = 0x0007
} }
@@ -908,12 +908,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x004f when not in "Advanced Driver" mode */ /* has ID 0x004f when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x004d), USB_DEVICE(0x0582, 0x004d),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "PCR-A", .product_name = "PCR-A",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0003, .out_cables = 0x0003,
.in_cables = 0x0007 .in_cables = 0x0007
} }
@@ -925,12 +925,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* is standard compliant, but has only 16-bit PCM. * is standard compliant, but has only 16-bit PCM.
*/ */
USB_DEVICE(0x0582, 0x0050), USB_DEVICE(0x0582, 0x0050),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UA-3FX", .product_name = "UA-3FX",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 1, .ifnum = 1,
.type = QUIRK_AUDIO_STANDARD_INTERFACE .type = QUIRK_AUDIO_STANDARD_INTERFACE
@@ -947,7 +947,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x0582, 0x0052), USB_DEVICE(0x0582, 0x0052),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UM-1SX", .product_name = "UM-1SX",
.ifnum = 0, .ifnum = 0,
@@ -958,12 +958,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0067 when not in "Advanced Driver" mode */ /* has ID 0x0067 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0065), USB_DEVICE(0x0582, 0x0065),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "PCR-1", .product_name = "PCR-1",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0003 .in_cables = 0x0003
} }
@@ -972,12 +972,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x006b when not in "Advanced Driver" mode */ /* has ID 0x006b when not in "Advanced Driver" mode */
USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a), USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "SP-606", .product_name = "SP-606",
.ifnum = 3, .ifnum = 3,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -986,12 +986,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x006e when not in "Advanced Driver" mode */ /* has ID 0x006e when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x006d), USB_DEVICE(0x0582, 0x006d),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
.product_name = "FANTOM-X", .product_name = "FANTOM-X",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1004,12 +1004,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* offers only 16-bit PCM at 44.1 kHz and no MIDI. * offers only 16-bit PCM at 44.1 kHz and no MIDI.
*/ */
USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074), USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "EDIROL", .vendor_name = "EDIROL",
.product_name = "UA-25", .product_name = "UA-25",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = (const snd_usb_audio_quirk_t[]) { .data = (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_AUDIO_EDIROL_UA700_UA25 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
@@ -1031,12 +1031,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x0076 when not in "Advanced Driver" mode */ /* has ID 0x0076 when not in "Advanced Driver" mode */
USB_DEVICE(0x0582, 0x0075), USB_DEVICE(0x0582, 0x0075),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "BOSS", .vendor_name = "BOSS",
.product_name = "DR-880", .product_name = "DR-880",
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1045,12 +1045,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* has ID 0x007b when not in "Advanced Driver" mode */ /* has ID 0x007b when not in "Advanced Driver" mode */
USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a), USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Roland", .vendor_name = "Roland",
/* "RD" or "RD-700SX"? */ /* "RD" or "RD-700SX"? */
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0003, .out_cables = 0x0003,
.in_cables = 0x0003 .in_cables = 0x0003
} }
@@ -1066,12 +1066,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* compliant USB MIDI ports for external MIDI and controls. * compliant USB MIDI ports for external MIDI and controls.
*/ */
USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Hercules", .vendor_name = "Hercules",
.product_name = "DJ Console (WE)", .product_name = "DJ Console (WE)",
.ifnum = 4, .ifnum = 4,
.type = QUIRK_MIDI_FIXED_ENDPOINT, .type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1090,12 +1090,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
/* Midiman/M-Audio devices */ /* Midiman/M-Audio devices */
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "MidiSport 2x2", .product_name = "MidiSport 2x2",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0003, .out_cables = 0x0003,
.in_cables = 0x0003 .in_cables = 0x0003
} }
@@ -1103,12 +1103,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "MidiSport 1x1", .product_name = "MidiSport 1x1",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1116,12 +1116,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "Keystation", .product_name = "Keystation",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1129,12 +1129,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "MidiSport 4x4", .product_name = "MidiSport 4x4",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x000f, .out_cables = 0x000f,
.in_cables = 0x000f .in_cables = 0x000f
} }
@@ -1147,12 +1147,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
* Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
*/ */
USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "MidiSport 8x8", .product_name = "MidiSport 8x8",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x01ff, .out_cables = 0x01ff,
.in_cables = 0x01ff .in_cables = 0x01ff
} }
@@ -1160,12 +1160,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "MidiSport 8x8", .product_name = "MidiSport 8x8",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x01ff, .out_cables = 0x01ff,
.in_cables = 0x01ff .in_cables = 0x01ff
} }
@@ -1173,12 +1173,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "MidiSport 2x4", .product_name = "MidiSport 2x4",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x000f, .out_cables = 0x000f,
.in_cables = 0x0003 .in_cables = 0x0003
} }
@@ -1186,12 +1186,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "Quattro", .product_name = "Quattro",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = & (const snd_usb_audio_quirk_t[]) { .data = & (const struct snd_usb_audio_quirk[]) {
/* /*
* Interfaces 0-2 are "Windows-compatible", 16-bit only, * Interfaces 0-2 are "Windows-compatible", 16-bit only,
* and share endpoints with the other interfaces. * and share endpoints with the other interfaces.
@@ -1237,7 +1237,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 9, .ifnum = 9,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1250,12 +1250,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "AudioPhile", .product_name = "AudioPhile",
.ifnum = 6, .ifnum = 6,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1263,12 +1263,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "Ozone", .product_name = "Ozone",
.ifnum = 3, .ifnum = 3,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1276,12 +1276,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "M-Audio", .vendor_name = "M-Audio",
.product_name = "OmniStudio", .product_name = "OmniStudio",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = & (const snd_usb_audio_quirk_t[]) { .data = & (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_IGNORE_INTERFACE .type = QUIRK_IGNORE_INTERFACE
@@ -1321,7 +1321,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
.ifnum = 9, .ifnum = 9,
.type = QUIRK_MIDI_MIDIMAN, .type = QUIRK_MIDI_MIDIMAN,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001, .out_cables = 0x0001,
.in_cables = 0x0001 .in_cables = 0x0001
} }
@@ -1342,12 +1342,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
.idVendor = 0x07fd, .idVendor = 0x07fd,
.idProduct = 0x0001, .idProduct = 0x0001,
.bDeviceSubClass = 2, .bDeviceSubClass = 2,
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "MOTU", .vendor_name = "MOTU",
.product_name = "Fastlane", .product_name = "Fastlane",
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE, .type = QUIRK_COMPOSITE,
.data = & (const snd_usb_audio_quirk_t[]) { .data = & (const struct snd_usb_audio_quirk[]) {
{ {
.ifnum = 0, .ifnum = 0,
.type = QUIRK_MIDI_RAW .type = QUIRK_MIDI_RAW
@@ -1366,7 +1366,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
/* Creative Sound Blaster MP3+ */ /* Creative Sound Blaster MP3+ */
USB_DEVICE(0x041e, 0x3010), USB_DEVICE(0x041e, 0x3010),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Creative Labs", .vendor_name = "Creative Labs",
.product_name = "Sound Blaster MP3+", .product_name = "Sound Blaster MP3+",
.ifnum = QUIRK_NO_INTERFACE .ifnum = QUIRK_NO_INTERFACE
@@ -1377,12 +1377,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
/* Emagic devices */ /* Emagic devices */
{ {
USB_DEVICE(0x086a, 0x0001), USB_DEVICE(0x086a, 0x0001),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Emagic", .vendor_name = "Emagic",
/* .product_name = "Unitor8", */ /* .product_name = "Unitor8", */
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_EMAGIC, .type = QUIRK_MIDI_EMAGIC,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x80ff, .out_cables = 0x80ff,
.in_cables = 0x80ff .in_cables = 0x80ff
} }
@@ -1390,12 +1390,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x086a, 0x0002), USB_DEVICE(0x086a, 0x0002),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Emagic", .vendor_name = "Emagic",
/* .product_name = "AMT8", */ /* .product_name = "AMT8", */
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_EMAGIC, .type = QUIRK_MIDI_EMAGIC,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x80ff, .out_cables = 0x80ff,
.in_cables = 0x80ff .in_cables = 0x80ff
} }
@@ -1403,12 +1403,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x086a, 0x0003), USB_DEVICE(0x086a, 0x0003),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Emagic", .vendor_name = "Emagic",
/* .product_name = "MT4", */ /* .product_name = "MT4", */
.ifnum = 2, .ifnum = 2,
.type = QUIRK_MIDI_EMAGIC, .type = QUIRK_MIDI_EMAGIC,
.data = & (const snd_usb_midi_endpoint_info_t) { .data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x800f, .out_cables = 0x800f,
.in_cables = 0x8003 .in_cables = 0x8003
} }
@@ -1418,7 +1418,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
/* TerraTec devices */ /* TerraTec devices */
{ {
USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "TerraTec", .vendor_name = "TerraTec",
.product_name = "PHASE 26", .product_name = "PHASE 26",
.ifnum = 3, .ifnum = 3,
@@ -1427,7 +1427,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "TerraTec", .vendor_name = "TerraTec",
.product_name = "PHASE 26", .product_name = "PHASE 26",
.ifnum = 3, .ifnum = 3,
@@ -1438,7 +1438,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
/* Novation EMS devices */ /* Novation EMS devices */
{ {
USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Novation", .vendor_name = "Novation",
.product_name = "ReMOTE Audio/XStation", .product_name = "ReMOTE Audio/XStation",
.ifnum = 4, .ifnum = 4,
@@ -1447,7 +1447,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Novation", .vendor_name = "Novation",
.product_name = "Speedio", .product_name = "Speedio",
.ifnum = 3, .ifnum = 3,
@@ -1456,7 +1456,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Novation", .vendor_name = "Novation",
.product_name = "ReMOTE25", .product_name = "ReMOTE25",
.ifnum = 0, .ifnum = 0,
@@ -1466,7 +1466,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
{ {
USB_DEVICE(0x4752, 0x0011), USB_DEVICE(0x4752, 0x0011),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Miditech", .vendor_name = "Miditech",
.product_name = "Midistart-2", .product_name = "Midistart-2",
.ifnum = 0, .ifnum = 0,
@@ -1475,7 +1475,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
}, },
{ {
USB_DEVICE(0x7104, 0x2202), USB_DEVICE(0x7104, 0x2202),
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.vendor_name = "Miditech", .vendor_name = "Miditech",
.product_name = "MidiStudio-2", .product_name = "MidiStudio-2",
.ifnum = 0, .ifnum = 0,
@@ -1492,7 +1492,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
USB_DEVICE_ID_MATCH_INT_SUBCLASS, USB_DEVICE_ID_MATCH_INT_SUBCLASS,
.bInterfaceClass = USB_CLASS_AUDIO, .bInterfaceClass = USB_CLASS_AUDIO,
.bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING, .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
.driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
.ifnum = QUIRK_ANY_INTERFACE, .ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_MIDI_STANDARD_INTERFACE .type = QUIRK_MIDI_STANDARD_INTERFACE
} }