From 86e07d34658bb85b3424f4db64fa28f884edbe8d Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 17 Nov 2005 15:08:02 +0100 Subject: [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 --- sound/usb/usbaudio.c | 374 +++++++++++++++++++++++++-------------------------- 1 file changed, 186 insertions(+), 188 deletions(-) (limited to 'sound/usb/usbaudio.c') diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c index 99dae024b640..e1326704c0c5 100644 --- a/sound/usb/usbaudio.c +++ b/sound/usb/usbaudio.c @@ -102,10 +102,6 @@ MODULE_PARM_DESC(async_unlink, "Use async unlink mode."); #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 @@ struct audioformat { 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 @@ struct snd_usb_substream { 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_substream { 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 @@ struct snd_usb_stream { */ 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. * 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 @@ static int prepare_capture_sync_urb(snd_usb_substream_t *subs, * 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 @@ static int prepare_capture_sync_urb_hs(snd_usb_substream_t *subs, * 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 @@ static int retire_capture_sync_urb(snd_usb_substream_t *subs, * 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 @@ static int prepare_capture_urb(snd_usb_substream_t *subs, * 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 @@ static int retire_capture_urb(snd_usb_substream_t *subs, * 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 @@ static int prepare_playback_sync_urb(snd_usb_substream_t *subs, * 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 @@ static int prepare_playback_sync_urb_hs(snd_usb_substream_t *subs, * 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 @@ static int retire_playback_sync_urb(snd_usb_substream_t *subs, * 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 @@ 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. */ -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 @@ static int prepare_startup_playback_urb(snd_usb_substream_t *subs, * 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 @@ static int prepare_playback_urb(snd_usb_substream_t *subs, * 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 struct snd_urb_ops audio_urb_ops_high_speed[2] = { */ 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_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; - 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 @@ static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs) /* 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 @@ static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs, } /* 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 @@ static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size) } /* 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 @@ static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs) /* * 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 @@ static int deactivate_urbs(snd_usb_substream_t *subs, int force, int can_sleep) /* * 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 @@ static int start_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime) /* * 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 @@ static int wait_clear_urbs(snd_usb_substream_t *subs) /* * 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 @@ static snd_pcm_uframes_t snd_usb_pcm_pointer(snd_pcm_substream_t *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) { - 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 @@ static int snd_usb_pcm_playback_trigger(snd_pcm_substream_t *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) { - 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 @@ static int snd_usb_pcm_capture_trigger(snd_pcm_substream_t *substream, /* * 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 @@ static void release_urb_ctx(snd_urb_ctx_t *u) /* * 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 @@ static void release_substream_urbs(snd_usb_substream_t *subs, int force) /* * 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 @@ static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_by /* 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 @@ static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_by 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 @@ out_of_memory: /* * find a matching audio format */ -static struct audioformat *find_format(snd_usb_substream_t *subs, unsigned int format, +static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format, unsigned int rate, unsigned int channels) { struct list_head *p; @@ -1229,7 +1227,7 @@ static int init_usb_sample_rate(struct usb_device *dev, int iface, /* * 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 @@ 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 * 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 @@ static int snd_usb_hw_params(snd_pcm_substream_t *substream, * * 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 @@ static int snd_usb_hw_free(snd_pcm_substream_t *substream) * * 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 @@ static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream) 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 @@ static snd_pcm_hardware_t snd_usb_playback = .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 @@ static snd_pcm_hardware_t snd_usb_capture = #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 @@ static int hw_check_valid_format(snd_pcm_hw_params_t *params, struct audioformat 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_rate(snd_pcm_hw_params_t *params, } -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 @@ static int hw_rule_channels(snd_pcm_hw_params_t *params, 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 @@ static int hw_rule_format(snd_pcm_hw_params_t *params, /* * 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 @@ static int check_hw_params_convention(snd_usb_substream_t *subs) * 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 @@ static int setup_hw_info(snd_pcm_runtime_t *runtime, snd_usb_substream_t *subs) 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 @@ static int snd_usb_pcm_open(snd_pcm_substream_t *substream, int direction, 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 @@ static int snd_usb_pcm_close(snd_pcm_substream_t *substream, int direction) 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 @@ static snd_pcm_ops_t snd_usb_playback_ops = { .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 @@ static struct usb_driver usb_audio_driver = { /* * 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_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) { 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); @@ -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]; - 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 @@ static void proc_pcm_format_add(snd_usb_stream_t *stream) * 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 @@ static void init_substream(snd_usb_stream_t *as, int stream, struct audioformat /* * 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 @@ static void free_substream(snd_usb_substream_t *subs) /* * 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 @@ static void snd_usb_audio_stream_free(snd_usb_stream_t *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) { stream->pcm = NULL; 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 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 @@ static int add_audio_endpoint(snd_usb_audio_t *chip, int stream, struct audiofor } /* 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 @@ static int add_audio_endpoint(snd_usb_audio_t *chip, int stream, struct audiofor /* * 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 @@ static int is_big_endian_format(snd_usb_audio_t *chip, struct audioformat *fp) * @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 @@ static int parse_audio_format_i_type(snd_usb_audio_t *chip, struct audioformat * * @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 @@ static int parse_audio_format_rates(snd_usb_audio_t *chip, struct audioformat *f /* * 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 @@ static int parse_audio_format_i(snd_usb_audio_t *chip, struct audioformat *fp, /* * 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 @@ 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 */ } -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 @@ static int parse_audio_format(snd_usb_audio_t *chip, struct audioformat *fp, 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 int parse_audio_endpoints(snd_usb_audio_t *chip, int iface_no) 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 @@ static void snd_usb_stream_disconnect(struct list_head *head) /* * 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 @@ static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif) /* * 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 @@ static int create_fixed_stream_quirk(snd_usb_audio_t *chip, /* * 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 @@ 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 * 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 @@ static int create_ua700_ua25_quirk(snd_usb_audio_t *chip, 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 @@ static int create_ua700_ua25_quirk(snd_usb_audio_t *chip, /* * 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 @@ static int create_ua1000_quirk(snd_usb_audio_t *chip, 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 @@ static int create_composite_quirk(snd_usb_audio_t *chip, 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 @@ static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev) * 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 @@ static int snd_usb_create_quirk(snd_usb_audio_t *chip, /* * 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 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); 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 @@ static int snd_usb_audio_dev_free(snd_device_t *device) * 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 @@ static void *snd_usb_audio_probe(struct usb_device *dev, 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_probe(struct usb_device *dev, */ 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) -- cgit v1.2.1