Commit 4a4d2cfd authored by Takashi Iwai's avatar Takashi Iwai Committed by Jaroslav Kysela
Browse files

[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: default avatarTakashi Iwai <tiwai@suse.de>
parent 03da312a

sound/drivers/dummy.c

+65 −59
Original line number Diff line number Diff line
@@ -42,7 +42,7 @@ MODULE_SUPPORTED_DEVICE("{{ALSA,Dummy soundcard}}"); 


#if 0 /* emu10k1 emulation */

#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;

	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_LAST		4



typedef struct snd_card_dummy {

	snd_card_t *card;

struct snd_dummy {

	struct snd_card *card;

	spinlock_t mixer_lock;

	int mixer_volume[MIXER_ADDR_LAST+1][2];

	int capture_source[MIXER_ADDR_LAST+1][2];

} snd_card_dummy_t;

};



typedef struct snd_card_dummy_pcm {

	snd_card_dummy_t *dummy;

struct snd_dummy_pcm {

	struct snd_dummy *dummy;

	spinlock_t lock;

	struct timer_list timer;

	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_irq_pos;	/* IRQ position */

	unsigned int pcm_buf_pos;	/* position in buffer */

	snd_pcm_substream_t *substream;

} snd_card_dummy_pcm_t;

	struct snd_pcm_substream *substream;

};



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;

	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);

}



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;

	snd_dummy_card_pcm_t *dpcm = runtime->private_data;

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct snd_dummy_pcm *dpcm = runtime->private_data;

	int err = 0;



	spin_lock(&dpcm->lock);
@@ -201,10 +201,10 @@ static int snd_card_dummy_pcm_trigger(snd_pcm_substream_t *substream, int cmd) 
	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;

	snd_card_dummy_pcm_t *dpcm = runtime->private_data;

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct snd_dummy_pcm *dpcm = runtime->private_data;

	unsigned int bps;



	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)

{

	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);

	dpcm->timer.expires = 1 + jiffies;
@@ -240,15 +240,15 @@ static void snd_card_dummy_pcm_timer_function(unsigned long data) 
	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;

	snd_card_dummy_pcm_t *dpcm = runtime->private_data;

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct snd_dummy_pcm *dpcm = runtime->private_data;



	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 |

				 SNDRV_PCM_INFO_MMAP_VALID),
@@ -266,7 +266,7 @@ static snd_pcm_hardware_t snd_card_dummy_playback = 
	.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 |

				 SNDRV_PCM_INFO_MMAP_VALID),
@@ -284,25 +284,25 @@ static snd_pcm_hardware_t snd_card_dummy_capture = 
	.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);

}



static int snd_card_dummy_hw_params(snd_pcm_substream_t * substream,

				    snd_pcm_hw_params_t * hw_params)

static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream,

				    struct snd_pcm_hw_params *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);

}



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);

	if (! dpcm)
@@ -315,10 +315,10 @@ static snd_card_dummy_pcm_t *new_pcm_stream(snd_pcm_substream_t *substream) 
	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;

	snd_card_dummy_pcm_t *dpcm;

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct snd_dummy_pcm *dpcm;

	int err;



	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;

}



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;

	snd_card_dummy_pcm_t *dpcm;

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct snd_dummy_pcm *dpcm;

	int err;



	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;

}



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;

}



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;

}



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,

	.close =		snd_card_dummy_playback_close,

	.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,

};



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,

	.close =		snd_card_dummy_capture_close,

	.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,

};



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;



	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;

	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);
@@ -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, \

  .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->count = 2;
@@ -430,9 +432,10 @@ static int snd_dummy_volume_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t 
	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;



	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;

}



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 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, \

  .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->count = 2;
@@ -482,9 +487,10 @@ static int snd_dummy_capsrc_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t 
	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;



	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;

}



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 left, right;
@@ -511,7 +517,7 @@ static int snd_dummy_capsrc_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t 
	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_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER),

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)

};



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;

	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)

{

	snd_card_t *card;

	struct snd_card_dummy *dummy;

	struct snd_card *card;

	struct snd_dummy *dummy;

	int idx, err;



	if (!enable[dev])

		return -ENODEV;

	card = snd_card_new(index[dev], id[dev], THIS_MODULE,

			    sizeof(struct snd_card_dummy));

			    sizeof(struct snd_dummy));

	if (card == NULL)

		return -ENOMEM;

	dummy = (struct snd_card_dummy *)card->private_data;

	dummy = card->private_data;

	dummy->card = card;

	for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) {

		if (pcm_substreams[dev] < 1)

sound/drivers/mtpav.c

+19 −19
Original line number Diff line number Diff line
@@ -130,12 +130,12 @@ typedef struct mtpav_port { 
	u8 hwport;

	u8 mode;

	u8 running_status;

	snd_rawmidi_substream_t *input;

	snd_rawmidi_substream_t *output;

	struct snd_rawmidi_substream *input;

	struct snd_rawmidi_substream *output;

} mtpav_port_t;



typedef struct mtpav {

	snd_card_t *card;

	struct snd_card *card;

	unsigned long port;

	struct resource *res_port;

	int irq;			/* interrupt (for inputs) */
@@ -143,7 +143,7 @@ typedef struct mtpav { 
	int share_irq;			/* number of accesses to input interrupts */

	int istimer;			/* number of accesses to timer interrupts */

	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) */

	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 */

static void snd_mtpav_output_port_write(mtpav_port_t *port,

					snd_rawmidi_substream_t *substream)

					struct snd_rawmidi_substream *substream)

{

	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);

}



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];

	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;

	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;

	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;

	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;

	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;

	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;

	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,

	.close =	snd_mtpav_output_close,

	.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,

	.close =	snd_mtpav_input_close,

	.trigger =	snd_mtpav_input_trigger,
@@ -628,7 +628,7 @@ static snd_rawmidi_ops_t snd_mtpav_input = { 
 * 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)

		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)

{

	int rval = 0;

	snd_rawmidi_t *rawmidi;

	snd_rawmidi_substream_t *substream;

	struct snd_rawmidi *rawmidi;

	struct snd_rawmidi_substream *substream;

	struct list_head *list;



	//printk("entering snd_mtpav_get_RAWMIDI\n");
@@ -666,12 +666,12 @@ static int snd_mtpav_get_RAWMIDI(mtpav_t * mcard) 
	rawmidi = mcard->rmidi;



	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);

		substream->ops = &snd_mtpav_input;

	}

	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);

		substream->ops = &snd_mtpav_output;

		mcard->ports[substream->number].hwport = translate_subdevice_to_hwport(mcard, substream->number);

sound/drivers/serial-u16550.c

+23 −23
Original line number Diff line number Diff line
@@ -116,10 +116,10 @@ MODULE_PARM_DESC(adaptor, "Type of adaptor."); 
#define SERIAL_MODE_OUTPUT_TRIGGERED	(1 << 3)



typedef struct _snd_uart16550 {

	snd_card_t *card;

	snd_rawmidi_t *rmidi;

	snd_rawmidi_substream_t *midi_output[SNDRV_SERIAL_MAX_OUTS];

	snd_rawmidi_substream_t *midi_input[SNDRV_SERIAL_MAX_INS];

	struct snd_card *card;

	struct snd_rawmidi *rmidi;

	struct snd_rawmidi_substream *midi_output[SNDRV_SERIAL_MAX_OUTS];

	struct snd_rawmidi_substream *midi_input[SNDRV_SERIAL_MAX_INS];



	int filemode;		//open status of file
@@ -166,7 +166,7 @@ typedef struct _snd_uart16550 { 


} 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)

{
@@ -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;

	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;

}



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;

	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;

}



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;

	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);

}



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;

	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;

};



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;

	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;

}



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? */

	    && ((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;

}



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 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);

}



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;

	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);

}



static snd_rawmidi_ops_t snd_uart16550_output =

static struct snd_rawmidi_ops snd_uart16550_output =

{

	.open =		snd_uart16550_output_open,

	.close =	snd_uart16550_output_close,

	.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,

	.close =	snd_uart16550_input_close,
@@ -754,13 +754,13 @@ static int snd_uart16550_free(snd_uart16550_t *uart) 
	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;

	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,

				       int irq,

				       unsigned int speed,
@@ -769,7 +769,7 @@ static int __init snd_uart16550_create(snd_card_t * card, 
				       int droponfull,

				       snd_uart16550_t **ruart)

{

	static snd_device_ops_t ops = {

	static struct snd_device_ops ops = {

		.dev_free =	snd_uart16550_dev_free,

	};

	snd_uart16550_t *uart;
@@ -838,19 +838,19 @@ static int __init snd_uart16550_create(snd_card_t * card, 
	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;



	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);

	}

}



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;



	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)

{

	snd_card_t *card;

	struct snd_card *card;

	snd_uart16550_t *uart;

	int err;

sound/drivers/virmidi.c

+8 −8
Original line number Diff line number Diff line
@@ -75,17 +75,17 @@ MODULE_PARM_DESC(enable, "Enable this soundcard."); 
module_param_array(midi_devs, int, NULL, 0444);

MODULE_PARM_DESC(midi_devs, "MIDI devices # (1-8)");



typedef struct snd_card_virmidi {

	snd_card_t *card;

	snd_rawmidi_t *midi[MAX_MIDI_DEVICES];

} snd_card_virmidi_t;

struct snd_card_virmidi {

	struct snd_card *card;

	struct snd_rawmidi *midi[MAX_MIDI_DEVICES];

};



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)

{

	snd_card_t *card;

	struct snd_card *card;

	struct snd_card_virmidi *vmidi;

	int idx, err;
@@ -103,8 +103,8 @@ static int __init snd_card_virmidi_probe(int dev) 
		midi_devs[dev] = MAX_MIDI_DEVICES;

	}

	for (idx = 0; idx < midi_devs[dev]; idx++) {

		snd_rawmidi_t *rmidi;

		snd_virmidi_dev_t *rdev;

		struct snd_rawmidi *rmidi;

		struct snd_virmidi_dev *rdev;

		if ((err = snd_virmidi_new(card, idx, &rmidi)) < 0)

			goto __nodev;

		rdev = rmidi->private_data;