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