openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

[ALSA] Remove xxx_t typedefs: Generic drivers 

Modules: Generic drivers

Remove xxx_t typedefs from the generic drivers
(dummy, mtpav, serial-u16550 and virmidi).

Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai 2005-11-17 14:27:28 +01:00 committed by Jaroslav Kysela
parent 03da312ac0
commit 4a4d2cfd8c
4 changed files with 115 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
sound/drivers/dummy.c
View File

@ -42,7 +42,7 @@ MODULE_SUPPORTED_DEVICE("{{ALSA,Dummy soundcard}}");
#if 0 /* emu10k1 emulation */ #if 0 /* emu10k1 emulation */
#define MAX_BUFFER_SIZE (128 * 1024) #define MAX_BUFFER_SIZE (128 * 1024)
static int emu10k1_playback_constraints(snd_pcm_runtime_t *runtime) static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime)
{ {
int err; int err;
if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
@ -149,15 +149,15 @@ MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-16) for dummy driver.");
#define MIXER_ADDR_CD 4 #define MIXER_ADDR_CD 4
#define MIXER_ADDR_LAST 4 #define MIXER_ADDR_LAST 4
typedef struct snd_card_dummy { struct snd_dummy {
snd_card_t *card; struct snd_card *card;
spinlock_t mixer_lock; spinlock_t mixer_lock;
int mixer_volume[MIXER_ADDR_LAST+1][2]; int mixer_volume[MIXER_ADDR_LAST+1][2];
int capture_source[MIXER_ADDR_LAST+1][2]; int capture_source[MIXER_ADDR_LAST+1][2];
} snd_card_dummy_t; };
typedef struct snd_card_dummy_pcm { struct snd_dummy_pcm {
snd_card_dummy_t *dummy; struct snd_dummy *dummy;
spinlock_t lock; spinlock_t lock;
struct timer_list timer; struct timer_list timer;
unsigned int pcm_size; unsigned int pcm_size;
@ -166,27 +166,27 @@ typedef struct snd_card_dummy_pcm {
unsigned int pcm_jiffie; /* bytes per one jiffie */ unsigned int pcm_jiffie; /* bytes per one jiffie */
unsigned int pcm_irq_pos; /* IRQ position */ unsigned int pcm_irq_pos; /* IRQ position */
unsigned int pcm_buf_pos; /* position in buffer */ unsigned int pcm_buf_pos; /* position in buffer */
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
} snd_card_dummy_pcm_t; };
static snd_card_t *snd_dummy_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; static struct snd_card *snd_dummy_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
static inline void snd_card_dummy_pcm_timer_start(snd_card_dummy_pcm_t *dpcm) static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm)
{ {
dpcm->timer.expires = 1 + jiffies; dpcm->timer.expires = 1 + jiffies;
add_timer(&dpcm->timer); add_timer(&dpcm->timer);
} }
static inline void snd_card_dummy_pcm_timer_stop(snd_card_dummy_pcm_t *dpcm) static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm)
{ {
del_timer(&dpcm->timer); del_timer(&dpcm->timer);
} }
static int snd_card_dummy_pcm_trigger(snd_pcm_substream_t *substream, int cmd) static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_dummy_card_pcm_t *dpcm = runtime->private_data; struct snd_dummy_pcm *dpcm = runtime->private_data;
int err = 0; int err = 0;
spin_lock(&dpcm->lock); spin_lock(&dpcm->lock);
@ -201,10 +201,10 @@ static int snd_card_dummy_pcm_trigger(snd_pcm_substream_t *substream, int cmd)
return err; return err;
} }
static int snd_card_dummy_pcm_prepare(snd_pcm_substream_t * substream) static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_card_dummy_pcm_t *dpcm = runtime->private_data; struct snd_dummy_pcm *dpcm = runtime->private_data;
unsigned int bps; unsigned int bps;
bps = runtime->rate * runtime->channels; bps = runtime->rate * runtime->channels;
@ -223,7 +223,7 @@ static int snd_card_dummy_pcm_prepare(snd_pcm_substream_t * substream)
static void snd_card_dummy_pcm_timer_function(unsigned long data) static void snd_card_dummy_pcm_timer_function(unsigned long data)
{ {
snd_card_dummy_pcm_t *dpcm = (snd_card_dummy_pcm_t *)data; struct snd_dummy_pcm *dpcm = (struct snd_dummy_pcm *)data;
spin_lock(&dpcm->lock); spin_lock(&dpcm->lock);
dpcm->timer.expires = 1 + jiffies; dpcm->timer.expires = 1 + jiffies;
@ -240,15 +240,15 @@ static void snd_card_dummy_pcm_timer_function(unsigned long data)
spin_unlock(&dpcm->lock); spin_unlock(&dpcm->lock);
} }
static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(struct snd_pcm_substream *substream)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_card_dummy_pcm_t *dpcm = runtime->private_data; struct snd_dummy_pcm *dpcm = runtime->private_data;
return bytes_to_frames(runtime, dpcm->pcm_buf_pos); return bytes_to_frames(runtime, dpcm->pcm_buf_pos);
} }
static snd_pcm_hardware_t snd_card_dummy_playback = static struct snd_pcm_hardware snd_card_dummy_playback =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_MMAP_VALID), SNDRV_PCM_INFO_MMAP_VALID),
@ -266,7 +266,7 @@ static snd_pcm_hardware_t snd_card_dummy_playback =
.fifo_size = 0, .fifo_size = 0,
}; };
static snd_pcm_hardware_t snd_card_dummy_capture = static struct snd_pcm_hardware snd_card_dummy_capture =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_MMAP_VALID), SNDRV_PCM_INFO_MMAP_VALID),
@ -284,25 +284,25 @@ static snd_pcm_hardware_t snd_card_dummy_capture =
.fifo_size = 0, .fifo_size = 0,
}; };
static void snd_card_dummy_runtime_free(snd_pcm_runtime_t *runtime) static void snd_card_dummy_runtime_free(struct snd_pcm_runtime *runtime)
{ {
kfree(runtime->private_data); kfree(runtime->private_data);
} }
static int snd_card_dummy_hw_params(snd_pcm_substream_t * substream, static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
} }
static int snd_card_dummy_hw_free(snd_pcm_substream_t * substream) static int snd_card_dummy_hw_free(struct snd_pcm_substream *substream)
{ {
return snd_pcm_lib_free_pages(substream); return snd_pcm_lib_free_pages(substream);
} }
static snd_card_dummy_pcm_t *new_pcm_stream(snd_pcm_substream_t *substream) static struct snd_dummy_pcm *new_pcm_stream(struct snd_pcm_substream *substream)
{ {
snd_card_dummy_pcm_t *dpcm; struct snd_dummy_pcm *dpcm;
dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL); dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
if (! dpcm) if (! dpcm)
@ -315,10 +315,10 @@ static snd_card_dummy_pcm_t *new_pcm_stream(snd_pcm_substream_t *substream)
return dpcm; return dpcm;
} }
static int snd_card_dummy_playback_open(snd_pcm_substream_t * substream) static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_card_dummy_pcm_t *dpcm; struct snd_dummy_pcm *dpcm;
int err; int err;
if ((dpcm = new_pcm_stream(substream)) == NULL) if ((dpcm = new_pcm_stream(substream)) == NULL)
@ -340,10 +340,10 @@ static int snd_card_dummy_playback_open(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_card_dummy_capture_open(snd_pcm_substream_t * substream) static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_card_dummy_pcm_t *dpcm; struct snd_dummy_pcm *dpcm;
int err; int err;
if ((dpcm = new_pcm_stream(substream)) == NULL) if ((dpcm = new_pcm_stream(substream)) == NULL)
@ -365,17 +365,17 @@ static int snd_card_dummy_capture_open(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_card_dummy_playback_close(snd_pcm_substream_t * substream) static int snd_card_dummy_playback_close(struct snd_pcm_substream *substream)
{ {
return 0; return 0;
} }
static int snd_card_dummy_capture_close(snd_pcm_substream_t * substream) static int snd_card_dummy_capture_close(struct snd_pcm_substream *substream)
{ {
return 0; return 0;
} }
static snd_pcm_ops_t snd_card_dummy_playback_ops = { static struct snd_pcm_ops snd_card_dummy_playback_ops = {
.open = snd_card_dummy_playback_open, .open = snd_card_dummy_playback_open,
.close = snd_card_dummy_playback_close, .close = snd_card_dummy_playback_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
@ -386,7 +386,7 @@ static snd_pcm_ops_t snd_card_dummy_playback_ops = {
.pointer = snd_card_dummy_pcm_pointer, .pointer = snd_card_dummy_pcm_pointer,
}; };
static snd_pcm_ops_t snd_card_dummy_capture_ops = { static struct snd_pcm_ops snd_card_dummy_capture_ops = {
.open = snd_card_dummy_capture_open, .open = snd_card_dummy_capture_open,
.close = snd_card_dummy_capture_close, .close = snd_card_dummy_capture_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
@ -397,12 +397,13 @@ static snd_pcm_ops_t snd_card_dummy_capture_ops = {
.pointer = snd_card_dummy_pcm_pointer, .pointer = snd_card_dummy_pcm_pointer,
}; };
static int __init snd_card_dummy_pcm(snd_card_dummy_t *dummy, int device, int substreams) static int __init snd_card_dummy_pcm(struct snd_dummy *dummy, int device, int substreams)
{ {
snd_pcm_t *pcm; struct snd_pcm *pcm;
int err; int err;
if ((err = snd_pcm_new(dummy->card, "Dummy PCM", device, substreams, substreams, &pcm)) < 0) if ((err = snd_pcm_new(dummy->card, "Dummy PCM", device,
substreams, substreams, &pcm)) < 0)
return err; return err;
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops);
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops);
@ -421,7 +422,8 @@ static int __init snd_card_dummy_pcm(snd_card_dummy_t *dummy, int device, int su
.get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \ .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \
.private_value = addr } .private_value = addr }
static int snd_dummy_volume_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_dummy_volume_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2; uinfo->count = 2;
@ -430,9 +432,10 @@ static int snd_dummy_volume_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t
return 0; return 0;
} }
static int snd_dummy_volume_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_dummy_volume_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol); struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
int addr = kcontrol->private_value; int addr = kcontrol->private_value;
spin_lock_irq(&dummy->mixer_lock); spin_lock_irq(&dummy->mixer_lock);
@ -442,9 +445,10 @@ static int snd_dummy_volume_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return 0; return 0;
} }
static int snd_dummy_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol); struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
int change, addr = kcontrol->private_value; int change, addr = kcontrol->private_value;
int left, right; int left, right;
@ -473,7 +477,8 @@ static int snd_dummy_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
.get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \ .get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \
.private_value = addr } .private_value = addr }
static int snd_dummy_capsrc_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_dummy_capsrc_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 2; uinfo->count = 2;
@ -482,9 +487,10 @@ static int snd_dummy_capsrc_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t
return 0; return 0;
} }
static int snd_dummy_capsrc_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_dummy_capsrc_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol); struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
int addr = kcontrol->private_value; int addr = kcontrol->private_value;
spin_lock_irq(&dummy->mixer_lock); spin_lock_irq(&dummy->mixer_lock);
@ -494,9 +500,9 @@ static int snd_dummy_capsrc_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return 0; return 0;
} }
static int snd_dummy_capsrc_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_dummy_capsrc_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol); struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
int change, addr = kcontrol->private_value; int change, addr = kcontrol->private_value;
int left, right; int left, right;
@ -511,7 +517,7 @@ static int snd_dummy_capsrc_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return change; return change;
} }
static snd_kcontrol_new_t snd_dummy_controls[] = { static struct snd_kcontrol_new snd_dummy_controls[] = {
DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER), DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER),
DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER), DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER),
DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH), DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH),
@ -524,9 +530,9 @@ DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD),
DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_MASTER) DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_MASTER)
}; };
static int __init snd_card_dummy_new_mixer(snd_card_dummy_t * dummy) static int __init snd_card_dummy_new_mixer(struct snd_dummy *dummy)
{ {
snd_card_t *card = dummy->card; struct snd_card *card = dummy->card;
unsigned int idx; unsigned int idx;
int err; int err;
@ -543,17 +549,17 @@ static int __init snd_card_dummy_new_mixer(snd_card_dummy_t * dummy)
static int __init snd_card_dummy_probe(int dev) static int __init snd_card_dummy_probe(int dev)
{ {
snd_card_t *card; struct snd_card *card;
struct snd_card_dummy *dummy; struct snd_dummy *dummy;
int idx, err; int idx, err;
if (!enable[dev]) if (!enable[dev])
return -ENODEV; return -ENODEV;
card = snd_card_new(index[dev], id[dev], THIS_MODULE, card = snd_card_new(index[dev], id[dev], THIS_MODULE,
sizeof(struct snd_card_dummy)); sizeof(struct snd_dummy));
if (card == NULL) if (card == NULL)
return -ENOMEM; return -ENOMEM;
dummy = (struct snd_card_dummy *)card->private_data; dummy = card->private_data;
dummy->card = card; dummy->card = card;
for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) { for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) {
if (pcm_substreams[dev] < 1) if (pcm_substreams[dev] < 1)

38
sound/drivers/mtpav.c
View File

@ -130,12 +130,12 @@ typedef struct mtpav_port {
u8 hwport; u8 hwport;
u8 mode; u8 mode;
u8 running_status; u8 running_status;
snd_rawmidi_substream_t *input; struct snd_rawmidi_substream *input;
snd_rawmidi_substream_t *output; struct snd_rawmidi_substream *output;
} mtpav_port_t; } mtpav_port_t;
typedef struct mtpav { typedef struct mtpav {
snd_card_t *card; struct snd_card *card;
unsigned long port; unsigned long port;
struct resource *res_port; struct resource *res_port;
int irq; /* interrupt (for inputs) */ int irq; /* interrupt (for inputs) */
@ -143,7 +143,7 @@ typedef struct mtpav {
int share_irq; /* number of accesses to input interrupts */ int share_irq; /* number of accesses to input interrupts */
int istimer; /* number of accesses to timer interrupts */ int istimer; /* number of accesses to timer interrupts */
struct timer_list timer; /* timer interrupts for outputs */ struct timer_list timer; /* timer interrupts for outputs */
snd_rawmidi_t *rmidi; struct snd_rawmidi *rmidi;
int num_ports; /* number of hw ports (1-8) */ int num_ports; /* number of hw ports (1-8) */
mtpav_port_t ports[NUMPORTS]; /* all ports including computer, adat and bc */ mtpav_port_t ports[NUMPORTS]; /* all ports including computer, adat and bc */
@ -292,7 +292,7 @@ static void snd_mtpav_send_byte(mtpav_t *chip, u8 byte)
/* call this with spin lock held */ /* call this with spin lock held */
static void snd_mtpav_output_port_write(mtpav_port_t *port, static void snd_mtpav_output_port_write(mtpav_port_t *port,
snd_rawmidi_substream_t *substream) struct snd_rawmidi_substream *substream)
{ {
u8 outbyte; u8 outbyte;
@ -324,7 +324,7 @@ static void snd_mtpav_output_port_write(mtpav_port_t *port,
} while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1); } while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1);
} }
static void snd_mtpav_output_write(snd_rawmidi_substream_t * substream) static void snd_mtpav_output_write(struct snd_rawmidi_substream *substream)
{ {
mtpav_port_t *port = &mtp_card->ports[substream->number]; mtpav_port_t *port = &mtp_card->ports[substream->number];
unsigned long flags; unsigned long flags;
@ -353,7 +353,7 @@ static void snd_mtpav_portscan(mtpav_t *chip) // put mtp into smart routing mode
/* /*
*/ */
static int snd_mtpav_input_open(snd_rawmidi_substream_t * substream) static int snd_mtpav_input_open(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
mtpav_port_t *portp = &mtp_card->ports[substream->number]; mtpav_port_t *portp = &mtp_card->ports[substream->number];
@ -371,7 +371,7 @@ static int snd_mtpav_input_open(snd_rawmidi_substream_t * substream)
/* /*
*/ */
static int snd_mtpav_input_close(snd_rawmidi_substream_t *substream) static int snd_mtpav_input_close(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
mtpav_port_t *portp = &mtp_card->ports[substream->number]; mtpav_port_t *portp = &mtp_card->ports[substream->number];
@ -392,7 +392,7 @@ static int snd_mtpav_input_close(snd_rawmidi_substream_t *substream)
/* /*
*/ */
static void snd_mtpav_input_trigger(snd_rawmidi_substream_t * substream, int up) static void snd_mtpav_input_trigger(struct snd_rawmidi_substream *substream, int up)
{ {
unsigned long flags; unsigned long flags;
mtpav_port_t *portp = &mtp_card->ports[substream->number]; mtpav_port_t *portp = &mtp_card->ports[substream->number];
@ -449,7 +449,7 @@ static void snd_mtpav_remove_output_timer(mtpav_t *chip)
/* /*
*/ */
static int snd_mtpav_output_open(snd_rawmidi_substream_t * substream) static int snd_mtpav_output_open(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
mtpav_port_t *portp = &mtp_card->ports[substream->number]; mtpav_port_t *portp = &mtp_card->ports[substream->number];
@ -464,7 +464,7 @@ static int snd_mtpav_output_open(snd_rawmidi_substream_t * substream)
/* /*
*/ */
static int snd_mtpav_output_close(snd_rawmidi_substream_t * substream) static int snd_mtpav_output_close(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
mtpav_port_t *portp = &mtp_card->ports[substream->number]; mtpav_port_t *portp = &mtp_card->ports[substream->number];
@ -479,7 +479,7 @@ static int snd_mtpav_output_close(snd_rawmidi_substream_t * substream)
/* /*
*/ */
static void snd_mtpav_output_trigger(snd_rawmidi_substream_t * substream, int up) static void snd_mtpav_output_trigger(struct snd_rawmidi_substream *substream, int up)
{ {
unsigned long flags; unsigned long flags;
mtpav_port_t *portp = &mtp_card->ports[substream->number]; mtpav_port_t *portp = &mtp_card->ports[substream->number];
@ -611,13 +611,13 @@ static int snd_mtpav_get_ISA(mtpav_t * mcard)
/* /*
*/ */
static snd_rawmidi_ops_t snd_mtpav_output = { static struct snd_rawmidi_ops snd_mtpav_output = {
.open = snd_mtpav_output_open, .open = snd_mtpav_output_open,
.close = snd_mtpav_output_close, .close = snd_mtpav_output_close,
.trigger = snd_mtpav_output_trigger, .trigger = snd_mtpav_output_trigger,
}; };
static snd_rawmidi_ops_t snd_mtpav_input = { static struct snd_rawmidi_ops snd_mtpav_input = {
.open = snd_mtpav_input_open, .open = snd_mtpav_input_open,
.close = snd_mtpav_input_close, .close = snd_mtpav_input_close,
.trigger = snd_mtpav_input_trigger, .trigger = snd_mtpav_input_trigger,
@ -628,7 +628,7 @@ static snd_rawmidi_ops_t snd_mtpav_input = {
* get RAWMIDI resources * get RAWMIDI resources
*/ */
static void snd_mtpav_set_name(mtpav_t *chip, snd_rawmidi_substream_t *substream) static void snd_mtpav_set_name(mtpav_t *chip, struct snd_rawmidi_substream *substream)
{ {
if (substream->number >= 0 && substream->number < chip->num_ports) if (substream->number >= 0 && substream->number < chip->num_ports)
sprintf(substream->name, "MTP direct %d", (substream->number % chip->num_ports) + 1); sprintf(substream->name, "MTP direct %d", (substream->number % chip->num_ports) + 1);
@ -645,8 +645,8 @@ static void snd_mtpav_set_name(mtpav_t *chip, snd_rawmidi_substream_t *substream
static int snd_mtpav_get_RAWMIDI(mtpav_t * mcard) static int snd_mtpav_get_RAWMIDI(mtpav_t * mcard)
{ {
int rval = 0; int rval = 0;
snd_rawmidi_t *rawmidi; struct snd_rawmidi *rawmidi;
snd_rawmidi_substream_t *substream; struct snd_rawmidi_substream *substream;
struct list_head *list; struct list_head *list;
//printk("entering snd_mtpav_get_RAWMIDI\n"); //printk("entering snd_mtpav_get_RAWMIDI\n");
@ -666,12 +666,12 @@ static int snd_mtpav_get_RAWMIDI(mtpav_t * mcard)
rawmidi = mcard->rmidi; rawmidi = mcard->rmidi;
list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) {
substream = list_entry(list, snd_rawmidi_substream_t, list); substream = list_entry(list, struct snd_rawmidi_substream, list);
snd_mtpav_set_name(mcard, substream); snd_mtpav_set_name(mcard, substream);
substream->ops = &snd_mtpav_input; substream->ops = &snd_mtpav_input;
} }
list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) {
substream = list_entry(list, snd_rawmidi_substream_t, list); substream = list_entry(list, struct snd_rawmidi_substream, list);
snd_mtpav_set_name(mcard, substream); snd_mtpav_set_name(mcard, substream);
substream->ops = &snd_mtpav_output; substream->ops = &snd_mtpav_output;
mcard->ports[substream->number].hwport = translate_subdevice_to_hwport(mcard, substream->number); mcard->ports[substream->number].hwport = translate_subdevice_to_hwport(mcard, substream->number);

46
sound/drivers/serial-u16550.c
View File

@ -116,10 +116,10 @@ MODULE_PARM_DESC(adaptor, "Type of adaptor.");
#define SERIAL_MODE_OUTPUT_TRIGGERED (1 << 3) #define SERIAL_MODE_OUTPUT_TRIGGERED (1 << 3)
typedef struct _snd_uart16550 { typedef struct _snd_uart16550 {
snd_card_t *card; struct snd_card *card;
snd_rawmidi_t *rmidi; struct snd_rawmidi *rmidi;
snd_rawmidi_substream_t *midi_output[SNDRV_SERIAL_MAX_OUTS]; struct snd_rawmidi_substream *midi_output[SNDRV_SERIAL_MAX_OUTS];
snd_rawmidi_substream_t *midi_input[SNDRV_SERIAL_MAX_INS]; struct snd_rawmidi_substream *midi_input[SNDRV_SERIAL_MAX_INS];
int filemode; //open status of file int filemode; //open status of file
@ -166,7 +166,7 @@ typedef struct _snd_uart16550 {
} snd_uart16550_t; } snd_uart16550_t;
static snd_card_t *snd_serial_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; static struct snd_card *snd_serial_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
static inline void snd_uart16550_add_timer(snd_uart16550_t *uart) static inline void snd_uart16550_add_timer(snd_uart16550_t *uart)
{ {
@ -509,7 +509,7 @@ static void snd_uart16550_do_close(snd_uart16550_t * uart)
} }
} }
static int snd_uart16550_input_open(snd_rawmidi_substream_t * substream) static int snd_uart16550_input_open(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
snd_uart16550_t *uart = substream->rmidi->private_data; snd_uart16550_t *uart = substream->rmidi->private_data;
@ -523,7 +523,7 @@ static int snd_uart16550_input_open(snd_rawmidi_substream_t * substream)
return 0; return 0;
} }
static int snd_uart16550_input_close(snd_rawmidi_substream_t * substream) static int snd_uart16550_input_close(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
snd_uart16550_t *uart = substream->rmidi->private_data; snd_uart16550_t *uart = substream->rmidi->private_data;
@ -537,7 +537,7 @@ static int snd_uart16550_input_close(snd_rawmidi_substream_t * substream)
return 0; return 0;
} }
static void snd_uart16550_input_trigger(snd_rawmidi_substream_t * substream, int up) static void snd_uart16550_input_trigger(struct snd_rawmidi_substream *substream, int up)
{ {
unsigned long flags; unsigned long flags;
snd_uart16550_t *uart = substream->rmidi->private_data; snd_uart16550_t *uart = substream->rmidi->private_data;
@ -551,7 +551,7 @@ static void snd_uart16550_input_trigger(snd_rawmidi_substream_t * substream, int
spin_unlock_irqrestore(&uart->open_lock, flags); spin_unlock_irqrestore(&uart->open_lock, flags);
} }
static int snd_uart16550_output_open(snd_rawmidi_substream_t * substream) static int snd_uart16550_output_open(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
snd_uart16550_t *uart = substream->rmidi->private_data; snd_uart16550_t *uart = substream->rmidi->private_data;
@ -565,7 +565,7 @@ static int snd_uart16550_output_open(snd_rawmidi_substream_t * substream)
return 0; return 0;
}; };
static int snd_uart16550_output_close(snd_rawmidi_substream_t * substream) static int snd_uart16550_output_close(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
snd_uart16550_t *uart = substream->rmidi->private_data; snd_uart16550_t *uart = substream->rmidi->private_data;
@ -603,7 +603,7 @@ static inline int snd_uart16550_write_buffer(snd_uart16550_t *uart, unsigned cha
return 0; return 0;
} }
static int snd_uart16550_output_byte(snd_uart16550_t *uart, snd_rawmidi_substream_t * substream, unsigned char midi_byte) static int snd_uart16550_output_byte(snd_uart16550_t *uart, struct snd_rawmidi_substream *substream, unsigned char midi_byte)
{ {
if (uart->buff_in_count == 0 /* Buffer empty? */ if (uart->buff_in_count == 0 /* Buffer empty? */
&& ((uart->adaptor != SNDRV_SERIAL_MS124W_SA && && ((uart->adaptor != SNDRV_SERIAL_MS124W_SA &&
@ -636,7 +636,7 @@ static int snd_uart16550_output_byte(snd_uart16550_t *uart, snd_rawmidi_substrea
return 1; return 1;
} }
static void snd_uart16550_output_write(snd_rawmidi_substream_t * substream) static void snd_uart16550_output_write(struct snd_rawmidi_substream *substream)
{ {
unsigned long flags; unsigned long flags;
unsigned char midi_byte, addr_byte; unsigned char midi_byte, addr_byte;
@ -715,7 +715,7 @@ static void snd_uart16550_output_write(snd_rawmidi_substream_t * substream)
spin_unlock_irqrestore(&uart->open_lock, flags); spin_unlock_irqrestore(&uart->open_lock, flags);
} }
static void snd_uart16550_output_trigger(snd_rawmidi_substream_t * substream, int up) static void snd_uart16550_output_trigger(struct snd_rawmidi_substream *substream, int up)
{ {
unsigned long flags; unsigned long flags;
snd_uart16550_t *uart = substream->rmidi->private_data; snd_uart16550_t *uart = substream->rmidi->private_data;
@ -731,14 +731,14 @@ static void snd_uart16550_output_trigger(snd_rawmidi_substream_t * substream, in
snd_uart16550_output_write(substream); snd_uart16550_output_write(substream);
} }
static snd_rawmidi_ops_t snd_uart16550_output = static struct snd_rawmidi_ops snd_uart16550_output =
{ {
.open = snd_uart16550_output_open, .open = snd_uart16550_output_open,
.close = snd_uart16550_output_close, .close = snd_uart16550_output_close,
.trigger = snd_uart16550_output_trigger, .trigger = snd_uart16550_output_trigger,
}; };
static snd_rawmidi_ops_t snd_uart16550_input = static struct snd_rawmidi_ops snd_uart16550_input =
{ {
.open = snd_uart16550_input_open, .open = snd_uart16550_input_open,
.close = snd_uart16550_input_close, .close = snd_uart16550_input_close,
@ -754,13 +754,13 @@ static int snd_uart16550_free(snd_uart16550_t *uart)
return 0; return 0;
}; };
static int snd_uart16550_dev_free(snd_device_t *device) static int snd_uart16550_dev_free(struct snd_device *device)
{ {
snd_uart16550_t *uart = device->device_data; snd_uart16550_t *uart = device->device_data;
return snd_uart16550_free(uart); return snd_uart16550_free(uart);
} }
static int __init snd_uart16550_create(snd_card_t * card, static int __init snd_uart16550_create(struct snd_card *card,
unsigned long iobase, unsigned long iobase,
int irq, int irq,
unsigned int speed, unsigned int speed,
@ -769,7 +769,7 @@ static int __init snd_uart16550_create(snd_card_t * card,
int droponfull, int droponfull,
snd_uart16550_t **ruart) snd_uart16550_t **ruart)
{ {
static snd_device_ops_t ops = { static struct snd_device_ops ops = {
.dev_free = snd_uart16550_dev_free, .dev_free = snd_uart16550_dev_free,
}; };
snd_uart16550_t *uart; snd_uart16550_t *uart;
@ -838,19 +838,19 @@ static int __init snd_uart16550_create(snd_card_t * card,
return 0; return 0;
} }
static void __init snd_uart16550_substreams(snd_rawmidi_str_t *stream) static void __init snd_uart16550_substreams(struct snd_rawmidi_str *stream)
{ {
struct list_head *list; struct list_head *list;
list_for_each(list, &stream->substreams) { list_for_each(list, &stream->substreams) {
snd_rawmidi_substream_t *substream = list_entry(list, snd_rawmidi_substream_t, list); struct snd_rawmidi_substream *substream = list_entry(list, struct snd_rawmidi_substream, list);
sprintf(substream->name, "Serial MIDI %d", substream->number + 1); sprintf(substream->name, "Serial MIDI %d", substream->number + 1);
} }
} }
static int __init snd_uart16550_rmidi(snd_uart16550_t *uart, int device, int outs, int ins, snd_rawmidi_t **rmidi) static int __init snd_uart16550_rmidi(snd_uart16550_t *uart, int device, int outs, int ins, struct snd_rawmidi **rmidi)
{ {
snd_rawmidi_t *rrawmidi; struct snd_rawmidi *rrawmidi;
int err; int err;
if ((err = snd_rawmidi_new(uart->card, "UART Serial MIDI", device, outs, ins, &rrawmidi)) < 0) if ((err = snd_rawmidi_new(uart->card, "UART Serial MIDI", device, outs, ins, &rrawmidi)) < 0)
@ -871,7 +871,7 @@ static int __init snd_uart16550_rmidi(snd_uart16550_t *uart, int device, int out
static int __init snd_serial_probe(int dev) static int __init snd_serial_probe(int dev)
{ {
snd_card_t *card; struct snd_card *card;
snd_uart16550_t *uart; snd_uart16550_t *uart;
int err; int err;

16
sound/drivers/virmidi.c
View File

@ -75,17 +75,17 @@ MODULE_PARM_DESC(enable, "Enable this soundcard.");
module_param_array(midi_devs, int, NULL, 0444); module_param_array(midi_devs, int, NULL, 0444);
MODULE_PARM_DESC(midi_devs, "MIDI devices # (1-8)"); MODULE_PARM_DESC(midi_devs, "MIDI devices # (1-8)");
typedef struct snd_card_virmidi { struct snd_card_virmidi {
snd_card_t *card; struct snd_card *card;
snd_rawmidi_t *midi[MAX_MIDI_DEVICES]; struct snd_rawmidi *midi[MAX_MIDI_DEVICES];
} snd_card_virmidi_t; };
static snd_card_t *snd_virmidi_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; static struct snd_card *snd_virmidi_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
static int __init snd_card_virmidi_probe(int dev) static int __init snd_card_virmidi_probe(int dev)
{ {
snd_card_t *card; struct snd_card *card;
struct snd_card_virmidi *vmidi; struct snd_card_virmidi *vmidi;
int idx, err; int idx, err;
@ -103,8 +103,8 @@ static int __init snd_card_virmidi_probe(int dev)
midi_devs[dev] = MAX_MIDI_DEVICES; midi_devs[dev] = MAX_MIDI_DEVICES;
} }
for (idx = 0; idx < midi_devs[dev]; idx++) { for (idx = 0; idx < midi_devs[dev]; idx++) {
snd_rawmidi_t *rmidi; struct snd_rawmidi *rmidi;
snd_virmidi_dev_t *rdev; struct snd_virmidi_dev *rdev;
if ((err = snd_virmidi_new(card, idx, &rmidi)) < 0) if ((err = snd_virmidi_new(card, idx, &rmidi)) < 0)
goto __nodev; goto __nodev;
rdev = rmidi->private_data; rdev = rmidi->private_data;