[ALSA] Remove xxx_t typedefs: PCM OSS-emulation
[linux-2.6.git] / sound / core / oss / pcm_oss.c
index bcc970759134ec86e3c271e4c1738451227ca5de..ffc13b9194b7829404c8e86b8480a054fe5a2a83 100644 (file)
@@ -61,10 +61,10 @@ MODULE_PARM_DESC(nonblock_open, "Don't block opening busy PCM devices.");
 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM);
 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1);
 
-extern int snd_mixer_oss_ioctl_card(snd_card_t *card, unsigned int cmd, unsigned long arg);
-static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file);
-static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file);
-static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file);
+extern int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg);
+static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file);
+static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file);
+static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file);
 
 static inline mm_segment_t snd_enter_user(void)
 {
@@ -78,10 +78,10 @@ static inline void snd_leave_user(mm_segment_t fs)
        set_fs(fs);
 }
 
-static int snd_pcm_oss_plugin_clear(snd_pcm_substream_t *substream)
+static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_pcm_plugin_t *plugin, *next;
+       struct snd_pcm_runtime *runtime = substream->runtime;
+       struct snd_pcm_plugin *plugin, *next;
        
        plugin = runtime->oss.plugin_first;
        while (plugin) {
@@ -93,9 +93,9 @@ static int snd_pcm_oss_plugin_clear(snd_pcm_substream_t *substream)
        return 0;
 }
 
-static int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin)
+static int snd_pcm_plugin_insert(struct snd_pcm_plugin *plugin)
 {
-       snd_pcm_runtime_t *runtime = plugin->plug->runtime;
+       struct snd_pcm_runtime *runtime = plugin->plug->runtime;
        plugin->next = runtime->oss.plugin_first;
        plugin->prev = NULL;
        if (runtime->oss.plugin_first) {
@@ -108,9 +108,9 @@ static int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin)
        return 0;
 }
 
-int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin)
+int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin)
 {
-       snd_pcm_runtime_t *runtime = plugin->plug->runtime;
+       struct snd_pcm_runtime *runtime = plugin->plug->runtime;
        plugin->next = NULL;
        plugin->prev = runtime->oss.plugin_last;
        if (runtime->oss.plugin_last) {
@@ -123,9 +123,9 @@ int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin)
        return 0;
 }
 
-static long snd_pcm_oss_bytes(snd_pcm_substream_t *substream, long frames)
+static long snd_pcm_oss_bytes(struct snd_pcm_substream *substream, long frames)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        long buffer_size = snd_pcm_lib_buffer_bytes(substream);
        long bytes = frames_to_bytes(runtime, frames);
        if (buffer_size == runtime->oss.buffer_bytes)
@@ -142,9 +142,9 @@ static long snd_pcm_oss_bytes(snd_pcm_substream_t *substream, long frames)
 #endif
 }
 
-static long snd_pcm_alsa_frames(snd_pcm_substream_t *substream, long bytes)
+static long snd_pcm_alsa_frames(struct snd_pcm_substream *substream, long bytes)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        long buffer_size = snd_pcm_lib_buffer_bytes(substream);
        if (buffer_size == runtime->oss.buffer_bytes)
                return bytes_to_frames(runtime, bytes);
@@ -185,14 +185,14 @@ static int snd_pcm_oss_format_to(int format)
        }
 }
 
-static int snd_pcm_oss_period_size(snd_pcm_substream_t *substream, 
-                                  snd_pcm_hw_params_t *oss_params,
-                                  snd_pcm_hw_params_t *slave_params)
+static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, 
+                                  struct snd_pcm_hw_params *oss_params,
+                                  struct snd_pcm_hw_params *slave_params)
 {
        size_t s;
        size_t oss_buffer_size, oss_period_size, oss_periods;
        size_t min_period_size, max_period_size;
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        size_t oss_frame_size;
 
        oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) *
@@ -277,11 +277,11 @@ static int snd_pcm_oss_period_size(snd_pcm_substream_t *substream,
        return 0;
 }
 
-static int choose_rate(snd_pcm_substream_t *substream,
-                      snd_pcm_hw_params_t *params, unsigned int best_rate)
+static int choose_rate(struct snd_pcm_substream *substream,
+                      struct snd_pcm_hw_params *params, unsigned int best_rate)
 {
-       snd_interval_t *it;
-       snd_pcm_hw_params_t *save;
+       struct snd_interval *it;
+       struct snd_pcm_hw_params *save;
        unsigned int rate, prev;
 
        save = kmalloc(sizeof(*save), GFP_KERNEL);
@@ -317,18 +317,18 @@ static int choose_rate(snd_pcm_substream_t *substream,
        return snd_pcm_hw_param_near(substream, params, SNDRV_PCM_HW_PARAM_RATE, best_rate, NULL);
 }
 
-static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream)
+static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_pcm_hw_params_t *params, *sparams;
-       snd_pcm_sw_params_t *sw_params;
+       struct snd_pcm_runtime *runtime = substream->runtime;
+       struct snd_pcm_hw_params *params, *sparams;
+       struct snd_pcm_sw_params *sw_params;
        ssize_t oss_buffer_size, oss_period_size;
        size_t oss_frame_size;
        int err;
        int direct;
        int format, sformat, n;
-       snd_mask_t sformat_mask;
-       snd_mask_t mask;
+       struct snd_mask sformat_mask;
+       struct snd_mask mask;
 
        sw_params = kmalloc(sizeof(*sw_params), GFP_KERNEL);
        params = kmalloc(sizeof(*params), GFP_KERNEL);
@@ -342,7 +342,7 @@ static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream)
        if (atomic_read(&runtime->mmap_count)) {
                direct = 1;
        } else {
-               snd_pcm_oss_setup_t *setup = substream->oss.setup;
+               struct snd_pcm_oss_setup *setup = substream->oss.setup;
                direct = (setup != NULL && setup->direct);
        }
 
@@ -424,7 +424,7 @@ static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream)
                        goto failure;
                }
                if (runtime->oss.plugin_first) {
-                       snd_pcm_plugin_t *plugin;
+                       struct snd_pcm_plugin *plugin;
                        if ((err = snd_pcm_plugin_build_io(substream, sparams, &plugin)) < 0) {
                                snd_printd("snd_pcm_plugin_build_io failed: %i\n", err);
                                snd_pcm_oss_plugin_clear(substream);
@@ -540,10 +540,10 @@ failure:
        return err;
 }
 
-static int snd_pcm_oss_get_active_substream(snd_pcm_oss_file_t *pcm_oss_file, snd_pcm_substream_t **r_substream)
+static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_file, struct snd_pcm_substream **r_substream)
 {
        int idx, err;
-       snd_pcm_substream_t *asubstream = NULL, *substream;
+       struct snd_pcm_substream *asubstream = NULL, *substream;
 
        for (idx = 0; idx < 2; idx++) {
                substream = pcm_oss_file->streams[idx];
@@ -563,10 +563,10 @@ static int snd_pcm_oss_get_active_substream(snd_pcm_oss_file_t *pcm_oss_file, sn
        return 0;
 }
 
-static int snd_pcm_oss_prepare(snd_pcm_substream_t *substream)
+static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream)
 {
        int err;
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
 
        err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL);
        if (err < 0) {
@@ -581,9 +581,9 @@ static int snd_pcm_oss_prepare(snd_pcm_substream_t *substream)
        return 0;
 }
 
-static int snd_pcm_oss_make_ready(snd_pcm_substream_t *substream)
+static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream)
 {
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_runtime *runtime;
        int err;
 
        if (substream == NULL)
@@ -602,9 +602,9 @@ static int snd_pcm_oss_make_ready(snd_pcm_substream_t *substream)
        return 0;
 }
 
-static int snd_pcm_oss_capture_position_fixup(snd_pcm_substream_t *substream, snd_pcm_sframes_t *delay)
+static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream *substream, snd_pcm_sframes_t *delay)
 {
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_runtime *runtime;
        snd_pcm_uframes_t frames;
        int err = 0;
 
@@ -627,9 +627,9 @@ static int snd_pcm_oss_capture_position_fixup(snd_pcm_substream_t *substream, sn
        return err;
 }
 
-snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel)
+snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        int ret;
        while (1) {
                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
@@ -662,9 +662,9 @@ snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char
        return ret;
 }
 
-snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel)
+snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_sframes_t delay;
        int ret;
        while (1) {
@@ -709,9 +709,9 @@ snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, s
        return ret;
 }
 
-snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel)
+snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        int ret;
        while (1) {
                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
@@ -745,9 +745,9 @@ snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **buf
        return ret;
 }
        
-snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel)
+snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        int ret;
        while (1) {
                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
@@ -780,12 +780,12 @@ snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs
        return ret;
 }
 
-static ssize_t snd_pcm_oss_write2(snd_pcm_substream_t *substream, const char *buf, size_t bytes, int in_kernel)
+static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const char *buf, size_t bytes, int in_kernel)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_sframes_t frames, frames1;
        if (runtime->oss.plugin_first) {
-               snd_pcm_plugin_channel_t *channels;
+               struct snd_pcm_plugin_channel *channels;
                size_t oss_frame_bytes = (runtime->oss.plugin_first->src_width * runtime->oss.plugin_first->src_format.channels) / 8;
                if (!in_kernel) {
                        if (copy_from_user(runtime->oss.buffer, (const char __user *)buf, bytes))
@@ -810,11 +810,11 @@ static ssize_t snd_pcm_oss_write2(snd_pcm_substream_t *substream, const char *bu
        return bytes;
 }
 
-static ssize_t snd_pcm_oss_write1(snd_pcm_substream_t *substream, const char __user *buf, size_t bytes)
+static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const char __user *buf, size_t bytes)
 {
        size_t xfer = 0;
        ssize_t tmp;
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
 
        if (atomic_read(&runtime->mmap_count))
                return -ENXIO;
@@ -867,13 +867,13 @@ static ssize_t snd_pcm_oss_write1(snd_pcm_substream_t *substream, const char __u
        return xfer;
 }
 
-static ssize_t snd_pcm_oss_read2(snd_pcm_substream_t *substream, char *buf, size_t bytes, int in_kernel)
+static ssize_t snd_pcm_oss_read2(struct snd_pcm_substream *substream, char *buf, size_t bytes, int in_kernel)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_sframes_t frames, frames1;
        char __user *final_dst = (char __user *)buf;
        if (runtime->oss.plugin_first) {
-               snd_pcm_plugin_channel_t *channels;
+               struct snd_pcm_plugin_channel *channels;
                size_t oss_frame_bytes = (runtime->oss.plugin_last->dst_width * runtime->oss.plugin_last->dst_format.channels) / 8;
                if (!in_kernel)
                        buf = runtime->oss.buffer;
@@ -897,11 +897,11 @@ static ssize_t snd_pcm_oss_read2(snd_pcm_substream_t *substream, char *buf, size
        return bytes;
 }
 
-static ssize_t snd_pcm_oss_read1(snd_pcm_substream_t *substream, char __user *buf, size_t bytes)
+static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __user *buf, size_t bytes)
 {
        size_t xfer = 0;
        ssize_t tmp;
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
 
        if (atomic_read(&runtime->mmap_count))
                return -ENXIO;
@@ -941,9 +941,9 @@ static ssize_t snd_pcm_oss_read1(snd_pcm_substream_t *substream, char __user *bu
        return xfer;
 }
 
-static int snd_pcm_oss_reset(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_substream *substream;
 
        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
        if (substream != NULL) {
@@ -958,9 +958,9 @@ static int snd_pcm_oss_reset(snd_pcm_oss_file_t *pcm_oss_file)
        return 0;
 }
 
-static int snd_pcm_oss_post(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_post(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_substream *substream;
        int err;
 
        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
@@ -974,9 +974,9 @@ static int snd_pcm_oss_post(snd_pcm_oss_file_t *pcm_oss_file)
        return 0;
 }
 
-static int snd_pcm_oss_sync1(snd_pcm_substream_t *substream, size_t size)
+static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size)
 {
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_runtime *runtime;
        ssize_t result = 0;
        long res;
        wait_queue_t wait;
@@ -1020,12 +1020,12 @@ static int snd_pcm_oss_sync1(snd_pcm_substream_t *substream, size_t size)
        return result;
 }
 
-static int snd_pcm_oss_sync(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
 {
        int err = 0;
        unsigned int saved_f_flags;
-       snd_pcm_substream_t *substream;
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_substream *substream;
+       struct snd_pcm_runtime *runtime;
        snd_pcm_format_t format;
        unsigned long width;
        size_t size;
@@ -1117,13 +1117,13 @@ static int snd_pcm_oss_sync(snd_pcm_oss_file_t *pcm_oss_file)
        return 0;
 }
 
-static int snd_pcm_oss_set_rate(snd_pcm_oss_file_t *pcm_oss_file, int rate)
+static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate)
 {
        int idx;
 
        for (idx = 1; idx >= 0; --idx) {
-               snd_pcm_substream_t *substream = pcm_oss_file->streams[idx];
-               snd_pcm_runtime_t *runtime;
+               struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
+               struct snd_pcm_runtime *runtime;
                if (substream == NULL)
                        continue;
                runtime = substream->runtime;
@@ -1139,9 +1139,9 @@ static int snd_pcm_oss_set_rate(snd_pcm_oss_file_t *pcm_oss_file, int rate)
        return snd_pcm_oss_get_rate(pcm_oss_file);
 }
 
-static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_substream *substream;
        int err;
        
        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
@@ -1149,7 +1149,7 @@ static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file)
        return substream->runtime->oss.rate;
 }
 
-static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned int channels)
+static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsigned int channels)
 {
        int idx;
        if (channels < 1)
@@ -1157,8 +1157,8 @@ static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned i
        if (channels > 128)
                return -EINVAL;
        for (idx = 1; idx >= 0; --idx) {
-               snd_pcm_substream_t *substream = pcm_oss_file->streams[idx];
-               snd_pcm_runtime_t *runtime;
+               struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
+               struct snd_pcm_runtime *runtime;
                if (substream == NULL)
                        continue;
                runtime = substream->runtime;
@@ -1170,9 +1170,9 @@ static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned i
        return snd_pcm_oss_get_channels(pcm_oss_file);
 }
 
-static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_substream *substream;
        int err;
        
        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
@@ -1180,9 +1180,9 @@ static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file)
        return substream->runtime->oss.channels;
 }
 
-static int snd_pcm_oss_get_block_size(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_substream *substream;
        int err;
        
        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
@@ -1190,14 +1190,14 @@ static int snd_pcm_oss_get_block_size(snd_pcm_oss_file_t *pcm_oss_file)
        return substream->runtime->oss.period_bytes;
 }
 
-static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_substream *substream;
        int err;
        int direct;
-       snd_pcm_hw_params_t *params;
+       struct snd_pcm_hw_params *params;
        unsigned int formats = 0;
-       snd_mask_t format_mask;
+       struct snd_mask format_mask;
        int fmt;
 
        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
@@ -1205,7 +1205,7 @@ static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file)
        if (atomic_read(&substream->runtime->mmap_count)) {
                direct = 1;
        } else {
-               snd_pcm_oss_setup_t *setup = substream->oss.setup;
+               struct snd_pcm_oss_setup *setup = substream->oss.setup;
                direct = (setup != NULL && setup->direct);
        }
        if (!direct)
@@ -1231,7 +1231,7 @@ static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file)
        return formats;
 }
 
-static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format)
+static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int format)
 {
        int formats, idx;
        
@@ -1240,8 +1240,8 @@ static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format)
                if (!(formats & format))
                        format = AFMT_U8;
                for (idx = 1; idx >= 0; --idx) {
-                       snd_pcm_substream_t *substream = pcm_oss_file->streams[idx];
-                       snd_pcm_runtime_t *runtime;
+                       struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
+                       struct snd_pcm_runtime *runtime;
                        if (substream == NULL)
                                continue;
                        runtime = substream->runtime;
@@ -1254,9 +1254,9 @@ static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format)
        return snd_pcm_oss_get_format(pcm_oss_file);
 }
 
-static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_substream *substream;
        int err;
        
        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
@@ -1264,9 +1264,9 @@ static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file)
        return substream->runtime->oss.format;
 }
 
-static int snd_pcm_oss_set_subdivide1(snd_pcm_substream_t *substream, int subdivide)
+static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream *substream, int subdivide)
 {
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_runtime *runtime;
 
        if (substream == NULL)
                return 0;
@@ -1287,12 +1287,12 @@ static int snd_pcm_oss_set_subdivide1(snd_pcm_substream_t *substream, int subdiv
        return subdivide;
 }
 
-static int snd_pcm_oss_set_subdivide(snd_pcm_oss_file_t *pcm_oss_file, int subdivide)
+static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file *pcm_oss_file, int subdivide)
 {
        int err = -EINVAL, idx;
 
        for (idx = 1; idx >= 0; --idx) {
-               snd_pcm_substream_t *substream = pcm_oss_file->streams[idx];
+               struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
                if (substream == NULL)
                        continue;
                if ((err = snd_pcm_oss_set_subdivide1(substream, subdivide)) < 0)
@@ -1301,9 +1301,9 @@ static int snd_pcm_oss_set_subdivide(snd_pcm_oss_file_t *pcm_oss_file, int subdi
        return err;
 }
 
-static int snd_pcm_oss_set_fragment1(snd_pcm_substream_t *substream, unsigned int val)
+static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsigned int val)
 {
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_runtime *runtime;
 
        if (substream == NULL)
                return 0;
@@ -1320,12 +1320,12 @@ static int snd_pcm_oss_set_fragment1(snd_pcm_substream_t *substream, unsigned in
        return 0;
 }
 
-static int snd_pcm_oss_set_fragment(snd_pcm_oss_file_t *pcm_oss_file, unsigned int val)
+static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file *pcm_oss_file, unsigned int val)
 {
        int err = -EINVAL, idx;
 
        for (idx = 1; idx >= 0; --idx) {
-               snd_pcm_substream_t *substream = pcm_oss_file->streams[idx];
+               struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
                if (substream == NULL)
                        continue;
                if ((err = snd_pcm_oss_set_fragment1(substream, val)) < 0)
@@ -1340,7 +1340,7 @@ static int snd_pcm_oss_nonblock(struct file * file)
        return 0;
 }
 
-static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res)
+static int snd_pcm_oss_get_caps1(struct snd_pcm_substream *substream, int res)
 {
 
        if (substream == NULL) {
@@ -1356,7 +1356,7 @@ static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res)
        /* all ALSA drivers can return actual pointer in ring buffer */
 #if defined(DSP_CAP_REALTIME) && 0
        {
-               snd_pcm_runtime_t *runtime = substream->runtime;
+               struct snd_pcm_runtime *runtime = substream->runtime;
                if (runtime->info & (SNDRV_PCM_INFO_BLOCK_TRANSFER|SNDRV_PCM_INFO_BATCH))
                        res &= ~DSP_CAP_REALTIME;
        }
@@ -1364,32 +1364,32 @@ static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res)
        return res;
 }
 
-static int snd_pcm_oss_get_caps(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file *pcm_oss_file)
 {
        int result, idx;
        
        result = DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_DUPLEX | DSP_CAP_REALTIME;
        for (idx = 0; idx < 2; idx++) {
-               snd_pcm_substream_t *substream = pcm_oss_file->streams[idx];
+               struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
                result = snd_pcm_oss_get_caps1(substream, result);
        }
        result |= 0x0001;       /* revision - same as SB AWE 64 */
        return result;
 }
 
-static void snd_pcm_oss_simulate_fill(snd_pcm_substream_t *substream, snd_pcm_uframes_t hw_ptr)
+static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream *substream, snd_pcm_uframes_t hw_ptr)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_uframes_t appl_ptr;
        appl_ptr = hw_ptr + runtime->buffer_size;
        appl_ptr %= runtime->boundary;
        runtime->control->appl_ptr = appl_ptr;
 }
 
-static int snd_pcm_oss_set_trigger(snd_pcm_oss_file_t *pcm_oss_file, int trigger)
+static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int trigger)
 {
-       snd_pcm_runtime_t *runtime;
-       snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL;
+       struct snd_pcm_runtime *runtime;
+       struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
        int err, cmd;
 
 #ifdef OSS_DEBUG
@@ -1454,9 +1454,9 @@ static int snd_pcm_oss_set_trigger(snd_pcm_oss_file_t *pcm_oss_file, int trigger
        return 0;
 }
 
-static int snd_pcm_oss_get_trigger(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL;
+       struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
        int result = 0;
 
        psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
@@ -1468,10 +1468,10 @@ static int snd_pcm_oss_get_trigger(snd_pcm_oss_file_t *pcm_oss_file)
        return result;
 }
 
-static int snd_pcm_oss_get_odelay(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file *pcm_oss_file)
 {
-       snd_pcm_substream_t *substream;
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_substream *substream;
+       struct snd_pcm_runtime *runtime;
        snd_pcm_sframes_t delay;
        int err;
 
@@ -1491,10 +1491,10 @@ static int snd_pcm_oss_get_odelay(snd_pcm_oss_file_t *pcm_oss_file)
        return snd_pcm_oss_bytes(substream, delay);
 }
 
-static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct count_info __user * _info)
+static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct count_info __user * _info)
 {      
-       snd_pcm_substream_t *substream;
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_substream *substream;
+       struct snd_pcm_runtime *runtime;
        snd_pcm_sframes_t delay;
        int fixup;
        struct count_info info;
@@ -1543,7 +1543,7 @@ static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, str
        } else {
                delay = snd_pcm_oss_bytes(substream, delay);
                if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                       snd_pcm_oss_setup_t *setup = substream->oss.setup;
+                       struct snd_pcm_oss_setup *setup = substream->oss.setup;
                        if (setup && setup->buggyptr)
                                info.blocks = (runtime->oss.buffer_bytes - delay - fixup) / runtime->oss.period_bytes;
                        else
@@ -1560,10 +1560,10 @@ static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, str
        return 0;
 }
 
-static int snd_pcm_oss_get_space(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct audio_buf_info __user *_info)
+static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct audio_buf_info __user *_info)
 {
-       snd_pcm_substream_t *substream;
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_substream *substream;
+       struct snd_pcm_runtime *runtime;
        snd_pcm_sframes_t avail;
        int fixup;
        struct audio_buf_info info;
@@ -1619,17 +1619,17 @@ static int snd_pcm_oss_get_space(snd_pcm_oss_file_t *pcm_oss_file, int stream, s
        return 0;
 }
 
-static int snd_pcm_oss_get_mapbuf(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct buffmem_desc __user * _info)
+static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct buffmem_desc __user * _info)
 {
        // it won't be probably implemented
        // snd_printd("TODO: snd_pcm_oss_get_mapbuf\n");
        return -EINVAL;
 }
 
-static snd_pcm_oss_setup_t *snd_pcm_oss_look_for_setup(snd_pcm_t *pcm, int stream, const char *task_name)
+static struct snd_pcm_oss_setup *snd_pcm_oss_look_for_setup(struct snd_pcm *pcm, int stream, const char *task_name)
 {
        const char *ptr, *ptrl;
-       snd_pcm_oss_setup_t *setup;
+       struct snd_pcm_oss_setup *setup;
 
        down(&pcm->streams[stream].oss.setup_mutex);
        for (setup = pcm->streams[stream].oss.setup_list; setup; setup = setup->next) {
@@ -1659,11 +1659,11 @@ static snd_pcm_oss_setup_t *snd_pcm_oss_look_for_setup(snd_pcm_t *pcm, int strea
        return NULL;
 }
 
-static void snd_pcm_oss_init_substream(snd_pcm_substream_t *substream,
-                                      snd_pcm_oss_setup_t *setup,
+static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream,
+                                      struct snd_pcm_oss_setup *setup,
                                       int minor)
 {
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_runtime *runtime;
 
        substream->oss.oss = 1;
        substream->oss.setup = setup;
@@ -1687,9 +1687,9 @@ static void snd_pcm_oss_init_substream(snd_pcm_substream_t *substream,
        runtime->oss.subdivision = 0;
 }
 
-static void snd_pcm_oss_release_substream(snd_pcm_substream_t *substream)
+static void snd_pcm_oss_release_substream(struct snd_pcm_substream *substream)
 {
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_runtime *runtime;
        runtime = substream->runtime;
        vfree(runtime->oss.buffer);
        snd_pcm_oss_plugin_clear(substream);
@@ -1697,13 +1697,13 @@ static void snd_pcm_oss_release_substream(snd_pcm_substream_t *substream)
        substream->oss.oss = 0;
 }
 
-static int snd_pcm_oss_release_file(snd_pcm_oss_file_t *pcm_oss_file)
+static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file)
 {
        int cidx;
        snd_assert(pcm_oss_file != NULL, return -ENXIO);
        for (cidx = 0; cidx < 2; ++cidx) {
-               snd_pcm_substream_t *substream = pcm_oss_file->streams[cidx];
-               snd_pcm_runtime_t *runtime;
+               struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx];
+               struct snd_pcm_runtime *runtime;
                if (substream == NULL)
                        continue;
                runtime = substream->runtime;
@@ -1726,15 +1726,15 @@ static int snd_pcm_oss_release_file(snd_pcm_oss_file_t *pcm_oss_file)
 }
 
 static int snd_pcm_oss_open_file(struct file *file,
-                                snd_pcm_t *pcm,
-                                snd_pcm_oss_file_t **rpcm_oss_file,
+                                struct snd_pcm *pcm,
+                                struct snd_pcm_oss_file **rpcm_oss_file,
                                 int minor,
-                                snd_pcm_oss_setup_t *psetup,
-                                snd_pcm_oss_setup_t *csetup)
+                                struct snd_pcm_oss_setup *psetup,
+                                struct snd_pcm_oss_setup *csetup)
 {
        int err = 0;
-       snd_pcm_oss_file_t *pcm_oss_file;
-       snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL;
+       struct snd_pcm_oss_file *pcm_oss_file;
+       struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
        unsigned int f_mode = file->f_mode;
 
        snd_assert(rpcm_oss_file != NULL, return -EINVAL);
@@ -1839,9 +1839,9 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file)
        int device;
        int err;
        char task_name[32];
-       snd_pcm_t *pcm;
-       snd_pcm_oss_file_t *pcm_oss_file;
-       snd_pcm_oss_setup_t *psetup = NULL, *csetup = NULL;
+       struct snd_pcm *pcm;
+       struct snd_pcm_oss_file *pcm_oss_file;
+       struct snd_pcm_oss_setup *psetup = NULL, *csetup = NULL;
        int nonblock;
        wait_queue_t wait;
 
@@ -1925,9 +1925,9 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file)
 
 static int snd_pcm_oss_release(struct inode *inode, struct file *file)
 {
-       snd_pcm_t *pcm;
-       snd_pcm_substream_t *substream;
-       snd_pcm_oss_file_t *pcm_oss_file;
+       struct snd_pcm *pcm;
+       struct snd_pcm_substream *substream;
+       struct snd_pcm_oss_file *pcm_oss_file;
 
        pcm_oss_file = file->private_data;
        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
@@ -1947,7 +1947,7 @@ static int snd_pcm_oss_release(struct inode *inode, struct file *file)
 
 static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-       snd_pcm_oss_file_t *pcm_oss_file;
+       struct snd_pcm_oss_file *pcm_oss_file;
        int __user *p = (int __user *)arg;
        int res;
 
@@ -1958,7 +1958,7 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long
                return put_user(1, p);
 #if defined(CONFIG_SND_MIXER_OSS) || (defined(MODULE) && defined(CONFIG_SND_MIXER_OSS_MODULE))
        if (((cmd >> 8) & 0xff) == 'M') {       /* mixer ioctl - for OSS compatibility */
-               snd_pcm_substream_t *substream;
+               struct snd_pcm_substream *substream;
                int idx;
                for (idx = 0; idx < 2; ++idx) {
                        substream = pcm_oss_file->streams[idx];
@@ -2113,8 +2113,8 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long
 
 static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 {
-       snd_pcm_oss_file_t *pcm_oss_file;
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_oss_file *pcm_oss_file;
+       struct snd_pcm_substream *substream;
 
        pcm_oss_file = file->private_data;
        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
@@ -2133,8 +2133,8 @@ static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t coun
 
 static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
 {
-       snd_pcm_oss_file_t *pcm_oss_file;
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_oss_file *pcm_oss_file;
+       struct snd_pcm_substream *substream;
        long result;
 
        pcm_oss_file = file->private_data;
@@ -2150,18 +2150,18 @@ static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size
        return result;
 }
 
-static int snd_pcm_oss_playback_ready(snd_pcm_substream_t *substream)
+static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        if (atomic_read(&runtime->mmap_count))
                return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt;
        else
                return snd_pcm_playback_avail(runtime) >= runtime->oss.period_frames;
 }
 
-static int snd_pcm_oss_capture_ready(snd_pcm_substream_t *substream)
+static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream)
 {
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
        if (atomic_read(&runtime->mmap_count))
                return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt;
        else
@@ -2170,9 +2170,9 @@ static int snd_pcm_oss_capture_ready(snd_pcm_substream_t *substream)
 
 static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait)
 {
-       snd_pcm_oss_file_t *pcm_oss_file;
+       struct snd_pcm_oss_file *pcm_oss_file;
        unsigned int mask;
-       snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL;
+       struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
        
        pcm_oss_file = file->private_data;
 
@@ -2181,7 +2181,7 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait)
 
        mask = 0;
        if (psubstream != NULL) {
-               snd_pcm_runtime_t *runtime = psubstream->runtime;
+               struct snd_pcm_runtime *runtime = psubstream->runtime;
                poll_wait(file, &runtime->sleep, wait);
                snd_pcm_stream_lock_irq(psubstream);
                if (runtime->status->state != SNDRV_PCM_STATE_DRAINING &&
@@ -2191,8 +2191,8 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait)
                snd_pcm_stream_unlock_irq(psubstream);
        }
        if (csubstream != NULL) {
-               snd_pcm_runtime_t *runtime = csubstream->runtime;
-               enum sndrv_pcm_state ostate;
+               struct snd_pcm_runtime *runtime = csubstream->runtime;
+               snd_pcm_state_t ostate;
                poll_wait(file, &runtime->sleep, wait);
                snd_pcm_stream_lock_irq(csubstream);
                if ((ostate = runtime->status->state) != SNDRV_PCM_STATE_RUNNING ||
@@ -2200,7 +2200,7 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait)
                        mask |= POLLIN | POLLRDNORM;
                snd_pcm_stream_unlock_irq(csubstream);
                if (ostate != SNDRV_PCM_STATE_RUNNING && runtime->oss.trigger) {
-                       snd_pcm_oss_file_t ofile;
+                       struct snd_pcm_oss_file ofile;
                        memset(&ofile, 0, sizeof(ofile));
                        ofile.streams[SNDRV_PCM_STREAM_CAPTURE] = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
                        runtime->oss.trigger = 0;
@@ -2213,9 +2213,9 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait)
 
 static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area)
 {
-       snd_pcm_oss_file_t *pcm_oss_file;
-       snd_pcm_substream_t *substream = NULL;
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_oss_file *pcm_oss_file;
+       struct snd_pcm_substream *substream = NULL;
+       struct snd_pcm_runtime *runtime;
        int err;
 
 #ifdef OSS_DEBUG
@@ -2279,11 +2279,11 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area)
  *  /proc interface
  */
 
-static void snd_pcm_oss_proc_read(snd_info_entry_t *entry,
-                                 snd_info_buffer_t * buffer)
+static void snd_pcm_oss_proc_read(struct snd_info_entry *entry,
+                                 struct snd_info_buffer *buffer)
 {
-       snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data;
-       snd_pcm_oss_setup_t *setup = pstr->oss.setup_list;
+       struct snd_pcm_str *pstr = entry->private_data;
+       struct snd_pcm_oss_setup *setup = pstr->oss.setup_list;
        down(&pstr->oss.setup_mutex);
        while (setup) {
                snd_iprintf(buffer, "%s %u %u%s%s%s%s%s%s\n",
@@ -2301,11 +2301,11 @@ static void snd_pcm_oss_proc_read(snd_info_entry_t *entry,
        up(&pstr->oss.setup_mutex);
 }
 
-static void snd_pcm_oss_proc_free_setup_list(snd_pcm_str_t * pstr)
+static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str * pstr)
 {
        unsigned int idx;
-       snd_pcm_substream_t *substream;
-       snd_pcm_oss_setup_t *setup, *setupn;
+       struct snd_pcm_substream *substream;
+       struct snd_pcm_oss_setup *setup, *setupn;
 
        for (idx = 0, substream = pstr->substream;
             idx < pstr->substream_count; idx++, substream = substream->next)
@@ -2319,13 +2319,13 @@ static void snd_pcm_oss_proc_free_setup_list(snd_pcm_str_t * pstr)
        pstr->oss.setup_list = NULL;
 }
 
-static void snd_pcm_oss_proc_write(snd_info_entry_t *entry,
-                                  snd_info_buffer_t * buffer)
+static void snd_pcm_oss_proc_write(struct snd_info_entry *entry,
+                                  struct snd_info_buffer *buffer)
 {
-       snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data;
+       struct snd_pcm_str *pstr = entry->private_data;
        char line[128], str[32], task_name[32], *ptr;
        int idx1;
-       snd_pcm_oss_setup_t *setup, *setup1, template;
+       struct snd_pcm_oss_setup *setup, *setup1, template;
 
        while (!snd_info_get_line(buffer, line, sizeof(line))) {
                down(&pstr->oss.setup_mutex);
@@ -2370,7 +2370,7 @@ static void snd_pcm_oss_proc_write(snd_info_entry_t *entry,
                        }
                } while (*str);
                if (setup == NULL) {
-                       setup = (snd_pcm_oss_setup_t *) kmalloc(sizeof(snd_pcm_oss_setup_t), GFP_KERNEL);
+                       setup = kmalloc(sizeof(struct snd_pcm_oss_setup), GFP_KERNEL);
                        if (setup) {
                                if (pstr->oss.setup_list == NULL) {
                                        pstr->oss.setup_list = setup;
@@ -2389,12 +2389,12 @@ static void snd_pcm_oss_proc_write(snd_info_entry_t *entry,
        }
 }
 
-static void snd_pcm_oss_proc_init(snd_pcm_t *pcm)
+static void snd_pcm_oss_proc_init(struct snd_pcm *pcm)
 {
        int stream;
        for (stream = 0; stream < 2; ++stream) {
-               snd_info_entry_t *entry;
-               snd_pcm_str_t *pstr = &pcm->streams[stream];
+               struct snd_info_entry *entry;
+               struct snd_pcm_str *pstr = &pcm->streams[stream];
                if (pstr->substream_count == 0)
                        continue;
                if ((entry = snd_info_create_card_entry(pcm->card, "oss", pstr->proc_root)) != NULL) {
@@ -2414,11 +2414,11 @@ static void snd_pcm_oss_proc_init(snd_pcm_t *pcm)
        }
 }
 
-static void snd_pcm_oss_proc_done(snd_pcm_t *pcm)
+static void snd_pcm_oss_proc_done(struct snd_pcm *pcm)
 {
        int stream;
        for (stream = 0; stream < 2; ++stream) {
-               snd_pcm_str_t *pstr = &pcm->streams[stream];
+               struct snd_pcm_str *pstr = &pcm->streams[stream];
                if (pstr->oss.proc_entry) {
                        snd_info_unregister(pstr->oss.proc_entry);
                        pstr->oss.proc_entry = NULL;
@@ -2444,13 +2444,13 @@ static struct file_operations snd_pcm_oss_f_reg =
        .mmap =         snd_pcm_oss_mmap,
 };
 
-static snd_minor_t snd_pcm_oss_reg =
+static struct snd_minor snd_pcm_oss_reg =
 {
        .comment =      "digital audio",
        .f_ops =        &snd_pcm_oss_f_reg,
 };
 
-static void register_oss_dsp(snd_pcm_t *pcm, int index)
+static void register_oss_dsp(struct snd_pcm *pcm, int index)
 {
        char name[128];
        sprintf(name, "dsp%i%i", pcm->card->number, pcm->device);
@@ -2462,7 +2462,7 @@ static void register_oss_dsp(snd_pcm_t *pcm, int index)
        }
 }
 
-static int snd_pcm_oss_register_minor(snd_pcm_t * pcm)
+static int snd_pcm_oss_register_minor(struct snd_pcm *pcm)
 {
        pcm->oss.reg = 0;
        if (dsp_map[pcm->card->number] == (int)pcm->device) {
@@ -2493,7 +2493,7 @@ static int snd_pcm_oss_register_minor(snd_pcm_t * pcm)
        return 0;
 }
 
-static int snd_pcm_oss_disconnect_minor(snd_pcm_t * pcm)
+static int snd_pcm_oss_disconnect_minor(struct snd_pcm *pcm)
 {
        if (pcm->oss.reg) {
                if (pcm->oss.reg_mask & 1) {
@@ -2510,7 +2510,7 @@ static int snd_pcm_oss_disconnect_minor(snd_pcm_t * pcm)
        return 0;
 }
 
-static int snd_pcm_oss_unregister_minor(snd_pcm_t * pcm)
+static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm)
 {
        snd_pcm_oss_disconnect_minor(pcm);
        if (pcm->oss.reg) {
@@ -2525,7 +2525,7 @@ static int snd_pcm_oss_unregister_minor(snd_pcm_t * pcm)
        return 0;
 }
 
-static snd_pcm_notify_t snd_pcm_oss_notify =
+static struct snd_pcm_notify snd_pcm_oss_notify =
 {
        .n_register =   snd_pcm_oss_register_minor,
        .n_disconnect = snd_pcm_oss_disconnect_minor,