Commit 969165a8 authored by Takashi Iwai's avatar Takashi Iwai Committed by Jaroslav Kysela
Browse files

[ALSA] Remove xxx_t typedefs: PCI ES1968 



Modules: ES1968 driver

Remove xxx_t typedefs from the PCI ES1968 driver.

Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent e571f594

sound/pci/es1968.c

+142 −146
Original line number Diff line number Diff line
@@ -470,10 +470,6 @@ static u16 acpi_state_mask[] = { 
};





typedef struct snd_es1968 es1968_t;

typedef struct snd_esschan esschan_t;

typedef struct snd_esm_memory esm_memory_t;



/* APU use in the driver */

enum snd_enum_apu_type {

	ESM_APU_PCM_PLAY,
@@ -488,23 +484,23 @@ enum { 
};



/* DMA Hack! */

struct snd_esm_memory {

struct esm_memory {

	struct snd_dma_buffer buf;

	int empty;	/* status */

	struct list_head list;

};



/* Playback Channel */

struct snd_esschan {

struct esschan {

	int running;



	u8 apu[4];

	u8 apu_mode[4];



	/* playback/capture pcm buffer */

	esm_memory_t *memory;

	struct esm_memory *memory;

	/* capture mixer buffer */

	esm_memory_t *mixbuf;

	struct esm_memory *mixbuf;



	unsigned int hwptr;	/* current hw pointer in bytes */

	unsigned int count;	/* sample counter in bytes */
@@ -519,7 +515,7 @@ struct snd_esschan { 


	int bob_freq;	/* required timer frequency */



	snd_pcm_substream_t *substream;

	struct snd_pcm_substream *substream;



	/* linked list */

	struct list_head list;
@@ -529,7 +525,7 @@ struct snd_esschan { 
#endif

};



struct snd_es1968 {

struct es1968 {

	/* Module Config */

	int total_bufsize;			/* in bytes */
@@ -550,19 +546,19 @@ struct snd_es1968 { 
	unsigned long io_port;

	int type;

	struct pci_dev *pci;

	snd_card_t *card;

	snd_pcm_t *pcm;

	struct snd_card *card;

	struct snd_pcm *pcm;

	int do_pm;		/* power-management enabled */



	/* DMA memory block */

	struct list_head buf_list;



	/* ALSA Stuff */

	ac97_t *ac97;

	snd_kcontrol_t *master_switch; /* for h/w volume control */

	snd_kcontrol_t *master_volume;

	struct snd_ac97 *ac97;

	struct snd_kcontrol *master_switch; /* for h/w volume control */

	struct snd_kcontrol *master_volume;



	snd_rawmidi_t *rmidi;

	struct snd_rawmidi *rmidi;



	spinlock_t reg_lock;

	spinlock_t ac97_lock;
@@ -610,14 +606,14 @@ MODULE_DEVICE_TABLE(pci, snd_es1968_ids); 
   *********************/



/* no spinlock */

static void __maestro_write(es1968_t *chip, u16 reg, u16 data)

static void __maestro_write(struct es1968 *chip, u16 reg, u16 data)

{

	outw(reg, chip->io_port + ESM_INDEX);

	outw(data, chip->io_port + ESM_DATA);

	chip->maestro_map[reg] = data;

}



static inline void maestro_write(es1968_t *chip, u16 reg, u16 data)

static inline void maestro_write(struct es1968 *chip, u16 reg, u16 data)

{

	unsigned long flags;

	spin_lock_irqsave(&chip->reg_lock, flags);
@@ -626,7 +622,7 @@ static inline void maestro_write(es1968_t *chip, u16 reg, u16 data) 
}



/* no spinlock */

static u16 __maestro_read(es1968_t *chip, u16 reg)

static u16 __maestro_read(struct es1968 *chip, u16 reg)

{

	if (READABLE_MAP & (1 << reg)) {

		outw(reg, chip->io_port + ESM_INDEX);
@@ -635,7 +631,7 @@ static u16 __maestro_read(es1968_t *chip, u16 reg) 
	return chip->maestro_map[reg];

}



static inline u16 maestro_read(es1968_t *chip, u16 reg)

static inline u16 maestro_read(struct es1968 *chip, u16 reg)

{

	unsigned long flags;

	u16 result;
@@ -646,7 +642,7 @@ static inline u16 maestro_read(es1968_t *chip, u16 reg) 
}



/* Wait for the codec bus to be free */

static int snd_es1968_ac97_wait(es1968_t *chip)

static int snd_es1968_ac97_wait(struct es1968 *chip)

{

	int timeout = 100000;
@@ -659,9 +655,9 @@ static int snd_es1968_ac97_wait(es1968_t *chip) 
	return 1; /* timeout */

}



static void snd_es1968_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val)

static void snd_es1968_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val)

{

	es1968_t *chip = ac97->private_data;

	struct es1968 *chip = ac97->private_data;

	unsigned long flags;



	snd_es1968_ac97_wait(chip);
@@ -675,10 +671,10 @@ static void snd_es1968_ac97_write(ac97_t *ac97, unsigned short reg, unsigned sho 
	spin_unlock_irqrestore(&chip->ac97_lock, flags);

}



static unsigned short snd_es1968_ac97_read(ac97_t *ac97, unsigned short reg)

static unsigned short snd_es1968_ac97_read(struct snd_ac97 *ac97, unsigned short reg)

{

	u16 data = 0;

	es1968_t *chip = ac97->private_data;

	struct es1968 *chip = ac97->private_data;

	unsigned long flags;



	snd_es1968_ac97_wait(chip);
@@ -697,7 +693,7 @@ static unsigned short snd_es1968_ac97_read(ac97_t *ac97, unsigned short reg) 
}



/* no spinlock */

static void apu_index_set(es1968_t *chip, u16 index)

static void apu_index_set(struct es1968 *chip, u16 index)

{

	int i;

	__maestro_write(chip, IDR1_CRAM_POINTER, index);
@@ -708,7 +704,7 @@ static void apu_index_set(es1968_t *chip, u16 index) 
}



/* no spinlock */

static void apu_data_set(es1968_t *chip, u16 data)

static void apu_data_set(struct es1968 *chip, u16 data)

{

	int i;

	for (i = 0; i < 1000; i++) {
@@ -720,7 +716,7 @@ static void apu_data_set(es1968_t *chip, u16 data) 
}



/* no spinlock */

static void __apu_set_register(es1968_t *chip, u16 channel, u8 reg, u16 data)

static void __apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)

{

	snd_assert(channel < NR_APUS, return);

#ifdef CONFIG_PM
@@ -731,7 +727,7 @@ static void __apu_set_register(es1968_t *chip, u16 channel, u8 reg, u16 data) 
	apu_data_set(chip, data);

}



static inline void apu_set_register(es1968_t *chip, u16 channel, u8 reg, u16 data)

static inline void apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)

{

	unsigned long flags;

	spin_lock_irqsave(&chip->reg_lock, flags);
@@ -739,7 +735,7 @@ static inline void apu_set_register(es1968_t *chip, u16 channel, u8 reg, u16 dat 
	spin_unlock_irqrestore(&chip->reg_lock, flags);

}



static u16 __apu_get_register(es1968_t *chip, u16 channel, u8 reg)

static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg)

{

	snd_assert(channel < NR_APUS, return 0);

	reg |= (channel << 4);
@@ -747,7 +743,7 @@ static u16 __apu_get_register(es1968_t *chip, u16 channel, u8 reg) 
	return __maestro_read(chip, IDR0_DATA_PORT);

}



static inline u16 apu_get_register(es1968_t *chip, u16 channel, u8 reg)

static inline u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg)

{

	unsigned long flags;

	u16 v;
@@ -759,7 +755,7 @@ static inline u16 apu_get_register(es1968_t *chip, u16 channel, u8 reg) 


#if 0 /* ASSP is not supported */



static void assp_set_register(es1968_t *chip, u32 reg, u32 value)

static void assp_set_register(struct es1968 *chip, u32 reg, u32 value)

{

	unsigned long flags;
@@ -769,7 +765,7 @@ static void assp_set_register(es1968_t *chip, u32 reg, u32 value) 
	spin_unlock_irqrestore(&chip->reg_lock, flags);

}



static u32 assp_get_register(es1968_t *chip, u32 reg)

static u32 assp_get_register(struct es1968 *chip, u32 reg)

{

	unsigned long flags;

	u32 value;
@@ -784,7 +780,7 @@ static u32 assp_get_register(es1968_t *chip, u32 reg) 


#endif



static void wave_set_register(es1968_t *chip, u16 reg, u16 value)

static void wave_set_register(struct es1968 *chip, u16 reg, u16 value)

{

	unsigned long flags;
@@ -794,7 +790,7 @@ static void wave_set_register(es1968_t *chip, u16 reg, u16 value) 
	spin_unlock_irqrestore(&chip->reg_lock, flags);

}



static u16 wave_get_register(es1968_t *chip, u16 reg)

static u16 wave_get_register(struct es1968 *chip, u16 reg)

{

	unsigned long flags;

	u16 value;
@@ -811,7 +807,7 @@ static u16 wave_get_register(es1968_t *chip, u16 reg) 
   * Bob the Timer!  *

   *******************/



static void snd_es1968_bob_stop(es1968_t *chip)

static void snd_es1968_bob_stop(struct es1968 *chip)

{

	u16 reg;
@@ -823,7 +819,7 @@ static void snd_es1968_bob_stop(es1968_t *chip) 
	__maestro_write(chip, 0x17, reg);

}



static void snd_es1968_bob_start(es1968_t *chip)

static void snd_es1968_bob_start(struct es1968 *chip)

{

	int prescale;

	int divide;
@@ -863,7 +859,7 @@ static void snd_es1968_bob_start(es1968_t *chip) 
}



/* call with substream spinlock */

static void snd_es1968_bob_inc(es1968_t *chip, int freq)

static void snd_es1968_bob_inc(struct es1968 *chip, int freq)

{

	chip->bobclient++;

	if (chip->bobclient == 1) {
@@ -877,7 +873,7 @@ static void snd_es1968_bob_inc(es1968_t *chip, int freq) 
}



/* call with substream spinlock */

static void snd_es1968_bob_dec(es1968_t *chip)

static void snd_es1968_bob_dec(struct es1968 *chip)

{

	chip->bobclient--;

	if (chip->bobclient <= 0)
@@ -887,7 +883,7 @@ static void snd_es1968_bob_dec(es1968_t *chip) 
		struct list_head *p;

		int max_freq = ESM_BOB_FREQ;

		list_for_each(p, &chip->substream_list) {

			esschan_t *es = list_entry(p, esschan_t, list);

			struct esschan *es = list_entry(p, struct esschan, list);

			if (max_freq < es->bob_freq)

				max_freq = es->bob_freq;

		}
@@ -900,8 +896,8 @@ static void snd_es1968_bob_dec(es1968_t *chip) 
}



static int

snd_es1968_calc_bob_rate(es1968_t *chip, esschan_t *es,

			 snd_pcm_runtime_t *runtime)

snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es,

			 struct snd_pcm_runtime *runtime)

{

	/* we acquire 4 interrupts per period for precise control.. */

	int freq = runtime->rate * 4;
@@ -922,7 +918,7 @@ snd_es1968_calc_bob_rate(es1968_t *chip, esschan_t *es, 
 *  PCM Part *

 *************/



static u32 snd_es1968_compute_rate(es1968_t *chip, u32 freq)

static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq)

{

	u32 rate = (freq << 16) / chip->clock;

#if 0 /* XXX: do we need this? */
@@ -934,7 +930,7 @@ static u32 snd_es1968_compute_rate(es1968_t *chip, u32 freq) 


/* get current pointer */

static inline unsigned int

snd_es1968_get_dma_ptr(es1968_t *chip, esschan_t *es)

snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es)

{

	unsigned int offset;
@@ -945,7 +941,7 @@ snd_es1968_get_dma_ptr(es1968_t *chip, esschan_t *es) 
	return (offset & 0xFFFE);	/* hardware is in words */

}



static void snd_es1968_apu_set_freq(es1968_t *chip, int apu, int freq)

static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq)

{

	apu_set_register(chip, apu, 2,

			   (apu_get_register(chip, apu, 2) & 0x00FF) |
@@ -954,7 +950,7 @@ static void snd_es1968_apu_set_freq(es1968_t *chip, int apu, int freq) 
}



/* spin lock held */

static inline void snd_es1968_trigger_apu(es1968_t *esm, int apu, int mode)

static inline void snd_es1968_trigger_apu(struct es1968 *esm, int apu, int mode)

{

	/* set the APU mode */

	__apu_set_register(esm, apu, 0,
@@ -962,7 +958,7 @@ static inline void snd_es1968_trigger_apu(es1968_t *esm, int apu, int mode) 
			   (mode << 4));

}



static void snd_es1968_pcm_start(es1968_t *chip, esschan_t *es)

static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es)

{

	spin_lock(&chip->reg_lock);

	__apu_set_register(chip, es->apu[0], 5, es->base[0]);
@@ -982,7 +978,7 @@ static void snd_es1968_pcm_start(es1968_t *chip, esschan_t *es) 
	spin_unlock(&chip->reg_lock);

}



static void snd_es1968_pcm_stop(es1968_t *chip, esschan_t *es)

static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es)

{

	spin_lock(&chip->reg_lock);

	snd_es1968_trigger_apu(chip, es->apu[0], 0);
@@ -995,7 +991,7 @@ static void snd_es1968_pcm_stop(es1968_t *chip, esschan_t *es) 
}



/* set the wavecache control reg */

static void snd_es1968_program_wavecache(es1968_t *chip, esschan_t *es,

static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es,

					 int channel, u32 addr, int capture)

{

	u32 tmpval = (addr - 0x10) & 0xFFF8;
@@ -1016,8 +1012,8 @@ static void snd_es1968_program_wavecache(es1968_t *chip, esschan_t *es, 
}





static void snd_es1968_playback_setup(es1968_t *chip, esschan_t *es,

				      snd_pcm_runtime_t *runtime)

static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es,

				      struct snd_pcm_runtime *runtime)

{

	u32 pa;

	int high_apu = 0;
@@ -1119,7 +1115,7 @@ static void snd_es1968_playback_setup(es1968_t *chip, esschan_t *es, 
}





static void init_capture_apu(es1968_t *chip, esschan_t *es, int channel,

static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel,

			     unsigned int pa, unsigned int bsize,

			     int mode, int route)

{
@@ -1164,8 +1160,8 @@ static void init_capture_apu(es1968_t *chip, esschan_t *es, int channel, 
	apu_set_register(chip, apu, 0, 0x400F);

}



static void snd_es1968_capture_setup(es1968_t *chip, esschan_t *es,

				     snd_pcm_runtime_t *runtime)

static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es,

				     struct snd_pcm_runtime *runtime)

{

	int size;

	u32 freq;
@@ -1233,11 +1229,11 @@ static void snd_es1968_capture_setup(es1968_t *chip, esschan_t *es, 
 *  ALSA Interface *

 *******************/



static int snd_es1968_pcm_prepare(snd_pcm_substream_t *substream)

static int snd_es1968_pcm_prepare(struct snd_pcm_substream *substream)

{

	es1968_t *chip = snd_pcm_substream_chip(substream);

	snd_pcm_runtime_t *runtime = substream->runtime;

	esschan_t *es = runtime->private_data;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct esschan *es = runtime->private_data;



	es->dma_size = snd_pcm_lib_buffer_bytes(substream);

	es->frag_size = snd_pcm_lib_period_bytes(substream);
@@ -1265,10 +1261,10 @@ static int snd_es1968_pcm_prepare(snd_pcm_substream_t *substream) 
	return 0;

}



static int snd_es1968_pcm_trigger(snd_pcm_substream_t *substream, int cmd)

static int snd_es1968_pcm_trigger(struct snd_pcm_substream *substream, int cmd)

{

	es1968_t *chip = snd_pcm_substream_chip(substream);

	esschan_t *es = substream->runtime->private_data;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct esschan *es = substream->runtime->private_data;



	spin_lock(&chip->substream_lock);

	switch (cmd) {
@@ -1295,10 +1291,10 @@ static int snd_es1968_pcm_trigger(snd_pcm_substream_t *substream, int cmd) 
	return 0;

}



static snd_pcm_uframes_t snd_es1968_pcm_pointer(snd_pcm_substream_t *substream)

static snd_pcm_uframes_t snd_es1968_pcm_pointer(struct snd_pcm_substream *substream)

{

	es1968_t *chip = snd_pcm_substream_chip(substream);

	esschan_t *es = substream->runtime->private_data;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct esschan *es = substream->runtime->private_data;

	unsigned int ptr;



	ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
@@ -1306,7 +1302,7 @@ static snd_pcm_uframes_t snd_es1968_pcm_pointer(snd_pcm_substream_t *substream) 
	return bytes_to_frames(substream->runtime, ptr % es->dma_size);

}



static snd_pcm_hardware_t snd_es1968_playback = {

static struct snd_pcm_hardware snd_es1968_playback = {

	.info =			(SNDRV_PCM_INFO_MMAP |

               		         SNDRV_PCM_INFO_MMAP_VALID |

				 SNDRV_PCM_INFO_INTERLEAVED |
@@ -1327,7 +1323,7 @@ static snd_pcm_hardware_t snd_es1968_playback = { 
	.fifo_size =		0,

};



static snd_pcm_hardware_t snd_es1968_capture = {

static struct snd_pcm_hardware snd_es1968_capture = {

	.info =			(SNDRV_PCM_INFO_NONINTERLEAVED |

				 SNDRV_PCM_INFO_MMAP |

				 SNDRV_PCM_INFO_MMAP_VALID |
@@ -1355,14 +1351,14 @@ static snd_pcm_hardware_t snd_es1968_capture = { 
/* Because the Maestro can only take addresses relative to the PCM base address

   register :( */



static int calc_available_memory_size(es1968_t *chip)

static int calc_available_memory_size(struct es1968 *chip)

{

	struct list_head *p;

	int max_size = 0;

	

	down(&chip->memory_mutex);

	list_for_each(p, &chip->buf_list) {

		esm_memory_t *buf = list_entry(p, esm_memory_t, list);

		struct esm_memory *buf = list_entry(p, struct esm_memory, list);

		if (buf->empty && buf->buf.bytes > max_size)

			max_size = buf->buf.bytes;

	}
@@ -1373,15 +1369,15 @@ static int calc_available_memory_size(es1968_t *chip) 
}



/* allocate a new memory chunk with the specified size */

static esm_memory_t *snd_es1968_new_memory(es1968_t *chip, int size)

static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size)

{

	esm_memory_t *buf;

	struct esm_memory *buf;

	struct list_head *p;

	

	size = ((size + ESM_MEM_ALIGN - 1) / ESM_MEM_ALIGN) * ESM_MEM_ALIGN;

	down(&chip->memory_mutex);

	list_for_each(p, &chip->buf_list) {

		buf = list_entry(p, esm_memory_t, list);

		buf = list_entry(p, struct esm_memory, list);

		if (buf->empty && buf->buf.bytes >= size)

			goto __found;

	}
@@ -1390,7 +1386,7 @@ static esm_memory_t *snd_es1968_new_memory(es1968_t *chip, int size) 


__found:

	if (buf->buf.bytes > size) {

		esm_memory_t *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);

		struct esm_memory *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);

		if (chunk == NULL) {

			up(&chip->memory_mutex);

			return NULL;
@@ -1409,14 +1405,14 @@ static esm_memory_t *snd_es1968_new_memory(es1968_t *chip, int size) 
}



/* free a memory chunk */

static void snd_es1968_free_memory(es1968_t *chip, esm_memory_t *buf)

static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf)

{

	esm_memory_t *chunk;

	struct esm_memory *chunk;



	down(&chip->memory_mutex);

	buf->empty = 1;

	if (buf->list.prev != &chip->buf_list) {

		chunk = list_entry(buf->list.prev, esm_memory_t, list);

		chunk = list_entry(buf->list.prev, struct esm_memory, list);

		if (chunk->empty) {

			chunk->buf.bytes += buf->buf.bytes;

			list_del(&buf->list);
@@ -1425,7 +1421,7 @@ static void snd_es1968_free_memory(es1968_t *chip, esm_memory_t *buf) 
		}

	}

	if (buf->list.next != &chip->buf_list) {

		chunk = list_entry(buf->list.next, esm_memory_t, list);

		chunk = list_entry(buf->list.next, struct esm_memory, list);

		if (chunk->empty) {

			buf->buf.bytes += chunk->buf.bytes;

			list_del(&chunk->list);
@@ -1435,7 +1431,7 @@ static void snd_es1968_free_memory(es1968_t *chip, esm_memory_t *buf) 
	up(&chip->memory_mutex);

}



static void snd_es1968_free_dmabuf(es1968_t *chip)

static void snd_es1968_free_dmabuf(struct es1968 *chip)

{

	struct list_head *p;
@@ -1443,17 +1439,17 @@ static void snd_es1968_free_dmabuf(es1968_t *chip) 
		return;

	snd_dma_reserve_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci));

	while ((p = chip->buf_list.next) != &chip->buf_list) {

		esm_memory_t *chunk = list_entry(p, esm_memory_t, list);

		struct esm_memory *chunk = list_entry(p, struct esm_memory, list);

		list_del(p);

		kfree(chunk);

	}

}



static int __devinit

snd_es1968_init_dmabuf(es1968_t *chip)

snd_es1968_init_dmabuf(struct es1968 *chip)

{

	int err;

	esm_memory_t *chunk;

	struct esm_memory *chunk;



	chip->dma.dev.type = SNDRV_DMA_TYPE_DEV;

	chip->dma.dev.dev = snd_dma_pci_data(chip->pci);
@@ -1493,12 +1489,12 @@ snd_es1968_init_dmabuf(es1968_t *chip) 


/* setup the dma_areas */

/* buffer is extracted from the pre-allocated memory chunk */

static int snd_es1968_hw_params(snd_pcm_substream_t *substream,

				snd_pcm_hw_params_t *hw_params)

static int snd_es1968_hw_params(struct snd_pcm_substream *substream,

				struct snd_pcm_hw_params *hw_params)

{

	es1968_t *chip = snd_pcm_substream_chip(substream);

	snd_pcm_runtime_t *runtime = substream->runtime;

	esschan_t *chan = runtime->private_data;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct esschan *chan = runtime->private_data;

	int size = params_buffer_bytes(hw_params);



	if (chan->memory) {
@@ -1518,11 +1514,11 @@ static int snd_es1968_hw_params(snd_pcm_substream_t *substream, 
}



/* remove dma areas if allocated */

static int snd_es1968_hw_free(snd_pcm_substream_t * substream)

static int snd_es1968_hw_free(struct snd_pcm_substream *substream)

{

	es1968_t *chip = snd_pcm_substream_chip(substream);

	snd_pcm_runtime_t *runtime = substream->runtime;

	esschan_t *chan;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct esschan *chan;

	

	if (runtime->private_data == NULL)

		return 0;
@@ -1538,7 +1534,7 @@ static int snd_es1968_hw_free(snd_pcm_substream_t * substream) 
/*

 * allocate APU pair

 */

static int snd_es1968_alloc_apu_pair(es1968_t *chip, int type)

static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type)

{

	int apu;
@@ -1555,7 +1551,7 @@ static int snd_es1968_alloc_apu_pair(es1968_t *chip, int type) 
/*

 * release APU pair

 */

static void snd_es1968_free_apu_pair(es1968_t *chip, int apu)

static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu)

{

	chip->apu[apu] = chip->apu[apu + 1] = ESM_APU_FREE;

}
@@ -1565,11 +1561,11 @@ static void snd_es1968_free_apu_pair(es1968_t *chip, int apu) 
 * PCM open/close *

 ******************/



static int snd_es1968_playback_open(snd_pcm_substream_t *substream)

static int snd_es1968_playback_open(struct snd_pcm_substream *substream)

{

	es1968_t *chip = snd_pcm_substream_chip(substream);

	snd_pcm_runtime_t *runtime = substream->runtime;

	esschan_t *es;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct esschan *es;

	int apu1;



	/* search 2 APUs */
@@ -1606,11 +1602,11 @@ static int snd_es1968_playback_open(snd_pcm_substream_t *substream) 
	return 0;

}



static int snd_es1968_capture_open(snd_pcm_substream_t *substream)

static int snd_es1968_capture_open(struct snd_pcm_substream *substream)

{

	snd_pcm_runtime_t *runtime = substream->runtime;

	es1968_t *chip = snd_pcm_substream_chip(substream);

	esschan_t *es;

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct esschan *es;

	int apu1, apu2;



	apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE);
@@ -1665,10 +1661,10 @@ static int snd_es1968_capture_open(snd_pcm_substream_t *substream) 
	return 0;

}



static int snd_es1968_playback_close(snd_pcm_substream_t * substream)

static int snd_es1968_playback_close(struct snd_pcm_substream *substream)

{

	es1968_t *chip = snd_pcm_substream_chip(substream);

	esschan_t *es;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct esschan *es;



	if (substream->runtime->private_data == NULL)

		return 0;
@@ -1682,10 +1678,10 @@ static int snd_es1968_playback_close(snd_pcm_substream_t * substream) 
	return 0;

}



static int snd_es1968_capture_close(snd_pcm_substream_t * substream)

static int snd_es1968_capture_close(struct snd_pcm_substream *substream)

{

	es1968_t *chip = snd_pcm_substream_chip(substream);

	esschan_t *es;

	struct es1968 *chip = snd_pcm_substream_chip(substream);

	struct esschan *es;



	if (substream->runtime->private_data == NULL)

		return 0;
@@ -1701,7 +1697,7 @@ static int snd_es1968_capture_close(snd_pcm_substream_t * substream) 
	return 0;

}



static snd_pcm_ops_t snd_es1968_playback_ops = {

static struct snd_pcm_ops snd_es1968_playback_ops = {

	.open =		snd_es1968_playback_open,

	.close =	snd_es1968_playback_close,

	.ioctl =	snd_pcm_lib_ioctl,
@@ -1712,7 +1708,7 @@ static snd_pcm_ops_t snd_es1968_playback_ops = { 
	.pointer =	snd_es1968_pcm_pointer,

};



static snd_pcm_ops_t snd_es1968_capture_ops = {

static struct snd_pcm_ops snd_es1968_capture_ops = {

	.open =		snd_es1968_capture_open,

	.close =	snd_es1968_capture_close,

	.ioctl =	snd_pcm_lib_ioctl,
@@ -1729,11 +1725,11 @@ static snd_pcm_ops_t snd_es1968_capture_ops = { 
 */

#define CLOCK_MEASURE_BUFSIZE	16768	/* enough large for a single shot */



static void __devinit es1968_measure_clock(es1968_t *chip)

static void __devinit es1968_measure_clock(struct es1968 *chip)

{

	int i, apu;

	unsigned int pa, offset, t;

	esm_memory_t *memory;

	struct esm_memory *memory;

	struct timeval start_time, stop_time;



	if (chip->clock == 0)
@@ -1824,17 +1820,17 @@ static void __devinit es1968_measure_clock(es1968_t *chip) 
/*

 */



static void snd_es1968_pcm_free(snd_pcm_t *pcm)

static void snd_es1968_pcm_free(struct snd_pcm *pcm)

{

	es1968_t *esm = pcm->private_data;

	struct es1968 *esm = pcm->private_data;

	snd_es1968_free_dmabuf(esm);

	esm->pcm = NULL;

}



static int __devinit

snd_es1968_pcm(es1968_t *chip, int device)

snd_es1968_pcm(struct es1968 *chip, int device)

{

	snd_pcm_t *pcm;

	struct snd_pcm *pcm;

	int err;



	/* get DMA buffer */
@@ -1870,11 +1866,11 @@ snd_es1968_pcm(es1968_t *chip, int device) 
/*

 * update pointer

 */

static void snd_es1968_update_pcm(es1968_t *chip, esschan_t *es)

static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es)

{

	unsigned int hwptr;

	unsigned int diff;

	snd_pcm_substream_t *subs = es->substream;

	struct snd_pcm_substream *subs = es->substream;

        

	if (subs == NULL || !es->running)

		return;
@@ -1899,7 +1895,7 @@ static void snd_es1968_update_pcm(es1968_t *chip, esschan_t *es) 
 */

static void es1968_update_hw_volume(unsigned long private_data)

{

	es1968_t *chip = (es1968_t *) private_data;

	struct es1968 *chip = (struct es1968 *) private_data;

	int x, val;

	unsigned long flags;
@@ -1959,7 +1955,7 @@ static void es1968_update_hw_volume(unsigned long private_data) 
 */

static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *regs)

{

	es1968_t *chip = dev_id;

	struct es1968 *chip = dev_id;

	u32 event;



	if (!(event = inb(chip->io_port + 0x1A)))
@@ -1981,7 +1977,7 @@ static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *r 
		struct list_head *p;

		spin_lock(&chip->substream_lock);

		list_for_each(p, &chip->substream_list) {

			esschan_t *es = list_entry(p, esschan_t, list);

			struct esschan *es = list_entry(p, struct esschan, list);

			if (es->running)

				snd_es1968_update_pcm(chip, es);

		}
@@ -2002,13 +1998,13 @@ static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *r 
 */



static int __devinit

snd_es1968_mixer(es1968_t *chip)

snd_es1968_mixer(struct es1968 *chip)

{

	ac97_bus_t *pbus;

	ac97_template_t ac97;

	snd_ctl_elem_id_t id;

	struct snd_ac97_bus *pbus;

	struct snd_ac97_template ac97;

	struct snd_ctl_elem_id id;

	int err;

	static ac97_bus_ops_t ops = {

	static struct snd_ac97_bus_ops ops = {

		.write = snd_es1968_ac97_write,

		.read = snd_es1968_ac97_read,

	};
@@ -2039,7 +2035,7 @@ snd_es1968_mixer(es1968_t *chip) 
 * reset ac97 codec

 */



static void snd_es1968_ac97_reset(es1968_t *chip)

static void snd_es1968_ac97_reset(struct es1968 *chip)

{

	unsigned long ioaddr = chip->io_port;
@@ -2144,7 +2140,7 @@ static void snd_es1968_ac97_reset(es1968_t *chip) 
	outb(0x3f, ioaddr+0xd0);

}



static void snd_es1968_reset(es1968_t *chip)

static void snd_es1968_reset(struct es1968 *chip)

{

	/* Reset */

	outw(ESM_RESET_MAESTRO | ESM_RESET_DIRECTSOUND,
@@ -2157,7 +2153,7 @@ static void snd_es1968_reset(es1968_t *chip) 
/*

 * power management

 */

static void snd_es1968_set_acpi(es1968_t *chip, int state)

static void snd_es1968_set_acpi(struct es1968 *chip, int state)

{

	u16 active_mask = acpi_state_mask[state];
@@ -2172,7 +2168,7 @@ static void snd_es1968_set_acpi(es1968_t *chip, int state) 
/*

 * initialize maestro chip

 */

static void snd_es1968_chip_init(es1968_t *chip)

static void snd_es1968_chip_init(struct es1968 *chip)

{

	struct pci_dev *pci = chip->pci;

	int i;
@@ -2369,7 +2365,7 @@ static void snd_es1968_chip_init(es1968_t *chip) 
}



/* Enable IRQ's */

static void snd_es1968_start_irq(es1968_t *chip)

static void snd_es1968_start_irq(struct es1968 *chip)

{

	unsigned short w;

	w = ESM_HIRQ_DSIE | ESM_HIRQ_HW_VOLUME;
@@ -2382,9 +2378,9 @@ static void snd_es1968_start_irq(es1968_t *chip) 
/*

 * PM support

 */

static int es1968_suspend(snd_card_t *card, pm_message_t state)

static int es1968_suspend(struct snd_card *card, pm_message_t state)

{

	es1968_t *chip = card->pm_private_data;

	struct es1968 *chip = card->pm_private_data;



	if (! chip->do_pm)

		return 0;
@@ -2398,9 +2394,9 @@ static int es1968_suspend(snd_card_t *card, pm_message_t state) 
	return 0;

}



static int es1968_resume(snd_card_t *card)

static int es1968_resume(struct snd_card *card)

{

	es1968_t *chip = card->pm_private_data;

	struct es1968 *chip = card->pm_private_data;

	struct list_head *p;



	if (! chip->do_pm)
@@ -2423,7 +2419,7 @@ static int es1968_resume(snd_card_t *card) 
	snd_ac97_resume(chip->ac97);



	list_for_each(p, &chip->substream_list) {

		esschan_t *es = list_entry(p, esschan_t, list);

		struct esschan *es = list_entry(p, struct esschan, list);

		switch (es->mode) {

		case ESM_MODE_PLAY:

			snd_es1968_playback_setup(chip, es, es->substream->runtime);
@@ -2445,7 +2441,7 @@ static int es1968_resume(snd_card_t *card) 


#ifdef SUPPORT_JOYSTICK

#define JOYSTICK_ADDR	0x200

static int __devinit snd_es1968_create_gameport(es1968_t *chip, int dev)

static int __devinit snd_es1968_create_gameport(struct es1968 *chip, int dev)

{

	struct gameport *gp;

	struct resource *r;
@@ -2479,7 +2475,7 @@ static int __devinit snd_es1968_create_gameport(es1968_t *chip, int dev) 
	return 0;

}



static void snd_es1968_free_gameport(es1968_t *chip)

static void snd_es1968_free_gameport(struct es1968 *chip)

{

	if (chip->gameport) {

		struct resource *r = gameport_get_port_data(chip->gameport);
@@ -2491,11 +2487,11 @@ static void snd_es1968_free_gameport(es1968_t *chip) 
	}

}

#else

static inline int snd_es1968_create_gameport(es1968_t *chip, int dev) { return -ENOSYS; }

static inline void snd_es1968_free_gameport(es1968_t *chip) { }

static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; }

static inline void snd_es1968_free_gameport(struct es1968 *chip) { }

#endif



static int snd_es1968_free(es1968_t *chip)

static int snd_es1968_free(struct es1968 *chip)

{

	if (chip->io_port) {

		synchronize_irq(chip->irq);
@@ -2515,9 +2511,9 @@ static int snd_es1968_free(es1968_t *chip) 
	return 0;

}



static int snd_es1968_dev_free(snd_device_t *device)

static int snd_es1968_dev_free(struct snd_device *device)

{

	es1968_t *chip = device->device_data;

	struct es1968 *chip = device->device_data;

	return snd_es1968_free(chip);

}
@@ -2539,19 +2535,19 @@ static struct ess_device_list mpu_blacklist[] __devinitdata = { 
	{ TYPE_MAESTRO2, 0x125d },

};



static int __devinit snd_es1968_create(snd_card_t * card,

static int __devinit snd_es1968_create(struct snd_card *card,

				       struct pci_dev *pci,

				       int total_bufsize,

				       int play_streams,

				       int capt_streams,

				       int chip_type,

				       int do_pm,

				       es1968_t **chip_ret)

				       struct es1968 **chip_ret)

{

	static snd_device_ops_t ops = {

	static struct snd_device_ops ops = {

		.dev_free =	snd_es1968_dev_free,

	};

	es1968_t *chip;

	struct es1968 *chip;

	int i, err;



	*chip_ret = NULL;
@@ -2657,8 +2653,8 @@ static int __devinit snd_es1968_probe(struct pci_dev *pci, 
				      const struct pci_device_id *pci_id)

{

	static int dev;

	snd_card_t *card;

	es1968_t *chip;

	struct snd_card *card;

	struct es1968 *chip;

	unsigned int i;

	int err;