Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cb3b04de authored by Takashi Iwai's avatar Takashi Iwai
Browse files

Merge branch 'fix/misc' into topic/misc

parents ee7c343c db8cf334

sound/arm/aaci.c

+59 −118
Original line number Original line Diff line number Diff line
@@ -172,14 +172,15 @@ static unsigned short aaci_ac97_read(struct snd_ac97 *ac97, unsigned short reg) 
	return v;

	return v;

}

}





static inline void aaci_chan_wait_ready(struct aaci_runtime *aacirun)

static inline void

aaci_chan_wait_ready(struct aaci_runtime *aacirun, unsigned long mask)

{

{

	u32 val;

	u32 val;

	int timeout = 5000;

	int timeout = 5000;





	do {

	do {

		val = readl(aacirun->base + AACI_SR);

		val = readl(aacirun->base + AACI_SR);

	} while (val & (SR_TXB|SR_RXB) && timeout--);

	} while (val & mask && timeout--);

}

}
@@ -208,8 +209,10 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask) 
			writel(0, aacirun->base + AACI_IE);

			writel(0, aacirun->base + AACI_IE);

			return;

			return;

		}

		}

		ptr = aacirun->ptr;





		spin_lock(&aacirun->lock);



		ptr = aacirun->ptr;

		do {

		do {

			unsigned int len = aacirun->fifosz;

			unsigned int len = aacirun->fifosz;

			u32 val;

			u32 val;
@@ -217,9 +220,9 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask) 
			if (aacirun->bytes <= 0) {

			if (aacirun->bytes <= 0) {

				aacirun->bytes += aacirun->period;

				aacirun->bytes += aacirun->period;

				aacirun->ptr = ptr;

				aacirun->ptr = ptr;

				spin_unlock(&aaci->lock);

				spin_unlock(&aacirun->lock);

				snd_pcm_period_elapsed(aacirun->substream);

				snd_pcm_period_elapsed(aacirun->substream);

				spin_lock(&aaci->lock);

				spin_lock(&aacirun->lock);

			}

			}

			if (!(aacirun->cr & CR_EN))

			if (!(aacirun->cr & CR_EN))

				break;

				break;
@@ -245,7 +248,10 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask) 
					ptr = aacirun->start;

					ptr = aacirun->start;

			}

			}

		} while(1);

		} while(1);



		aacirun->ptr = ptr;

		aacirun->ptr = ptr;



		spin_unlock(&aacirun->lock);

	}

	}





	if (mask & ISR_URINTR) {

	if (mask & ISR_URINTR) {
@@ -263,6 +269,8 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask) 
			return;

			return;

		}

		}





		spin_lock(&aacirun->lock);



		ptr = aacirun->ptr;

		ptr = aacirun->ptr;

		do {

		do {

			unsigned int len = aacirun->fifosz;

			unsigned int len = aacirun->fifosz;
@@ -271,9 +279,9 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask) 
			if (aacirun->bytes <= 0) {

			if (aacirun->bytes <= 0) {

				aacirun->bytes += aacirun->period;

				aacirun->bytes += aacirun->period;

				aacirun->ptr = ptr;

				aacirun->ptr = ptr;

				spin_unlock(&aaci->lock);

				spin_unlock(&aacirun->lock);

				snd_pcm_period_elapsed(aacirun->substream);

				snd_pcm_period_elapsed(aacirun->substream);

				spin_lock(&aaci->lock);

				spin_lock(&aacirun->lock);

			}

			}

			if (!(aacirun->cr & CR_EN))

			if (!(aacirun->cr & CR_EN))

				break;

				break;
@@ -301,6 +309,8 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask) 
		} while (1);

		} while (1);





		aacirun->ptr = ptr;

		aacirun->ptr = ptr;



		spin_unlock(&aacirun->lock);

	}

	}

}

}
@@ -310,7 +320,6 @@ static irqreturn_t aaci_irq(int irq, void *devid) 
	u32 mask;

	u32 mask;

	int i;

	int i;





	spin_lock(&aaci->lock);

	mask = readl(aaci->base + AACI_ALLINTS);

	mask = readl(aaci->base + AACI_ALLINTS);

	if (mask) {

	if (mask) {

		u32 m = mask;

		u32 m = mask;
@@ -320,7 +329,6 @@ static irqreturn_t aaci_irq(int irq, void *devid) 
			}

			}

		}

		}

	}

	}

	spin_unlock(&aaci->lock);





	return mask ? IRQ_HANDLED : IRQ_NONE;

	return mask ? IRQ_HANDLED : IRQ_NONE;

}

}
@@ -330,63 +338,6 @@ static irqreturn_t aaci_irq(int irq, void *devid) 
/*

/*

 * ALSA support.

 * ALSA support.

 */

 */



struct aaci_stream {

	unsigned char codec_idx;

	unsigned char rate_idx;

};



static struct aaci_stream aaci_streams[] = {

	[ACSTREAM_FRONT] = {

		.codec_idx	= 0,

		.rate_idx	= AC97_RATES_FRONT_DAC,

	},

	[ACSTREAM_SURROUND] = {

		.codec_idx	= 0,

		.rate_idx	= AC97_RATES_SURR_DAC,

	},

	[ACSTREAM_LFE] = {

		.codec_idx	= 0,

		.rate_idx	= AC97_RATES_LFE_DAC,

	},

};



static inline unsigned int aaci_rate_mask(struct aaci *aaci, int streamid)

{

	struct aaci_stream *s = aaci_streams + streamid;

	return aaci->ac97_bus->codec[s->codec_idx]->rates[s->rate_idx];

}



static unsigned int rate_list[] = {

	5512, 8000, 11025, 16000, 22050, 32000, 44100,

	48000, 64000, 88200, 96000, 176400, 192000

};



/*

 * Double-rate rule: we can support double rate iff channels == 2

 *  (unimplemented)

 */

static int

aaci_rule_rate_by_channels(struct snd_pcm_hw_params *p, struct snd_pcm_hw_rule *rule)

{

	struct aaci *aaci = rule->private;

	unsigned int rate_mask = SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_5512;

	struct snd_interval *c = hw_param_interval(p, SNDRV_PCM_HW_PARAM_CHANNELS);



	switch (c->max) {

	case 6:

		rate_mask &= aaci_rate_mask(aaci, ACSTREAM_LFE);

	case 4:

		rate_mask &= aaci_rate_mask(aaci, ACSTREAM_SURROUND);

	case 2:

		rate_mask &= aaci_rate_mask(aaci, ACSTREAM_FRONT);

	}



	return snd_interval_list(hw_param_interval(p, rule->var),

				 ARRAY_SIZE(rate_list), rate_list,

				 rate_mask);

}



static struct snd_pcm_hardware aaci_hw_info = {

static struct snd_pcm_hardware aaci_hw_info = {

	.info			= SNDRV_PCM_INFO_MMAP |

	.info			= SNDRV_PCM_INFO_MMAP |

				  SNDRV_PCM_INFO_MMAP_VALID |

				  SNDRV_PCM_INFO_MMAP_VALID |
@@ -400,10 +351,7 @@ static struct snd_pcm_hardware aaci_hw_info = { 
	 */

	 */

	.formats		= SNDRV_PCM_FMTBIT_S16_LE,

	.formats		= SNDRV_PCM_FMTBIT_S16_LE,





	/* should this be continuous or knot? */

	/* rates are setup from the AC'97 codec */

	.rates			= SNDRV_PCM_RATE_CONTINUOUS,

	.rate_max		= 48000,

	.rate_min		= 4000,

	.channels_min		= 2,

	.channels_min		= 2,

	.channels_max		= 6,

	.channels_max		= 6,

	.buffer_bytes_max	= 64 * 1024,

	.buffer_bytes_max	= 64 * 1024,
@@ -423,6 +371,12 @@ static int __aaci_pcm_open(struct aaci *aaci, 
	aacirun->substream = substream;

	aacirun->substream = substream;

	runtime->private_data = aacirun;

	runtime->private_data = aacirun;

	runtime->hw = aaci_hw_info;

	runtime->hw = aaci_hw_info;

	runtime->hw.rates = aacirun->pcm->rates;

	snd_pcm_limit_hw_rates(runtime);



	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&

	    aacirun->pcm->r[1].slots)

		snd_ac97_pcm_double_rate_rules(runtime);





	/*

	/*

	 * FIXME: ALSA specifies fifo_size in bytes.  If we're in normal

	 * FIXME: ALSA specifies fifo_size in bytes.  If we're in normal
@@ -433,17 +387,6 @@ static int __aaci_pcm_open(struct aaci *aaci, 
	 */

	 */

	runtime->hw.fifo_size = aaci->fifosize * 2;

	runtime->hw.fifo_size = aaci->fifosize * 2;





	/*

	 * Add rule describing hardware rate dependency

	 * on the number of channels.

	 */

	ret = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,

				  aaci_rule_rate_by_channels, aaci,

				  SNDRV_PCM_HW_PARAM_CHANNELS,

				  SNDRV_PCM_HW_PARAM_RATE, -1);

	if (ret)

		goto out;



	ret = request_irq(aaci->dev->irq[0], aaci_irq, IRQF_SHARED|IRQF_DISABLED,

	ret = request_irq(aaci->dev->irq[0], aaci_irq, IRQF_SHARED|IRQF_DISABLED,

			  DRIVER_NAME, aaci);

			  DRIVER_NAME, aaci);

	if (ret)

	if (ret)
@@ -507,18 +450,22 @@ static int aaci_pcm_hw_params(struct snd_pcm_substream *substream, 




	err = snd_pcm_lib_malloc_pages(substream,

	err = snd_pcm_lib_malloc_pages(substream,

				       params_buffer_bytes(params));

				       params_buffer_bytes(params));

	if (err < 0)

	if (err >= 0) {

		goto out;

		unsigned int rate = params_rate(params);

		int dbl = rate > 48000;





	err = snd_ac97_pcm_open(aacirun->pcm, params_rate(params),

		err = snd_ac97_pcm_open(aacirun->pcm, rate,

					params_channels(params),

					params_channels(params),

				aacirun->pcm->r[0].slots);

					aacirun->pcm->r[dbl].slots);

	if (err)

		goto out;





	aacirun->pcm_open = 1;

		aacirun->pcm_open = err == 0;

		aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;

		aacirun->fifosz = aaci->fifosize * 4;



		if (aacirun->cr & CR_COMPACT)

			aacirun->fifosz >>= 1;

	}





 out:

	return err;

	return err;

}

}
@@ -527,7 +474,7 @@ static int aaci_pcm_prepare(struct snd_pcm_substream *substream) 
	struct snd_pcm_runtime *runtime = substream->runtime;

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct aaci_runtime *aacirun = runtime->private_data;

	struct aaci_runtime *aacirun = runtime->private_data;





	aacirun->start	= (void *)runtime->dma_area;

	aacirun->start	= runtime->dma_area;

	aacirun->end	= aacirun->start + snd_pcm_lib_buffer_bytes(substream);

	aacirun->end	= aacirun->start + snd_pcm_lib_buffer_bytes(substream);

	aacirun->ptr	= aacirun->start;

	aacirun->ptr	= aacirun->start;

	aacirun->period	=

	aacirun->period	=
@@ -627,14 +574,9 @@ static int aaci_pcm_playback_hw_params(struct snd_pcm_substream *substream, 
	 * Enable FIFO, compact mode, 16 bits per sample.

	 * Enable FIFO, compact mode, 16 bits per sample.

	 * FIXME: double rate slots?

	 * FIXME: double rate slots?

	 */

	 */

	if (ret >= 0) {

	if (ret >= 0)

		aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;

		aacirun->cr |= channels_to_txmask[channels];

		aacirun->cr |= channels_to_txmask[channels];





		aacirun->fifosz	= aaci->fifosize * 4;

		if (aacirun->cr & CR_COMPACT)

			aacirun->fifosz >>= 1;

	}

	return ret;

	return ret;

}

}
@@ -646,7 +588,7 @@ static void aaci_pcm_playback_stop(struct aaci_runtime *aacirun) 
	ie &= ~(IE_URIE|IE_TXIE);

	ie &= ~(IE_URIE|IE_TXIE);

	writel(ie, aacirun->base + AACI_IE);

	writel(ie, aacirun->base + AACI_IE);

	aacirun->cr &= ~CR_EN;

	aacirun->cr &= ~CR_EN;

	aaci_chan_wait_ready(aacirun);

	aaci_chan_wait_ready(aacirun, SR_TXB);

	writel(aacirun->cr, aacirun->base + AACI_TXCR);

	writel(aacirun->cr, aacirun->base + AACI_TXCR);

}

}
@@ -654,7 +596,7 @@ static void aaci_pcm_playback_start(struct aaci_runtime *aacirun) 
{

{

	u32 ie;

	u32 ie;





	aaci_chan_wait_ready(aacirun);

	aaci_chan_wait_ready(aacirun, SR_TXB);

	aacirun->cr |= CR_EN;

	aacirun->cr |= CR_EN;





	ie = readl(aacirun->base + AACI_IE);

	ie = readl(aacirun->base + AACI_IE);
@@ -665,12 +607,12 @@ static void aaci_pcm_playback_start(struct aaci_runtime *aacirun) 




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

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

{

{

	struct aaci *aaci = substream->private_data;

	struct aaci_runtime *aacirun = substream->runtime->private_data;

	struct aaci_runtime *aacirun = substream->runtime->private_data;

	unsigned long flags;

	unsigned long flags;

	int ret = 0;

	int ret = 0;





	spin_lock_irqsave(&aaci->lock, flags);

	spin_lock_irqsave(&aacirun->lock, flags);



	switch (cmd) {

	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_START:

		aaci_pcm_playback_start(aacirun);

		aaci_pcm_playback_start(aacirun);
@@ -697,7 +639,8 @@ static int aaci_pcm_playback_trigger(struct snd_pcm_substream *substream, int cm 
	default:

	default:

		ret = -EINVAL;

		ret = -EINVAL;

	}

	}

	spin_unlock_irqrestore(&aaci->lock, flags);



	spin_unlock_irqrestore(&aacirun->lock, flags);





	return ret;

	return ret;

}

}
@@ -721,18 +664,10 @@ static int aaci_pcm_capture_hw_params(struct snd_pcm_substream *substream, 
	int ret;

	int ret;





	ret = aaci_pcm_hw_params(substream, aacirun, params);

	ret = aaci_pcm_hw_params(substream, aacirun, params);



	if (ret >= 0)

	if (ret >= 0) {

		aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;



		/* Line in record: slot 3 and 4 */

		/* Line in record: slot 3 and 4 */

		aacirun->cr |= CR_SL3 | CR_SL4;

		aacirun->cr |= CR_SL3 | CR_SL4;





		aacirun->fifosz = aaci->fifosize * 4;



		if (aacirun->cr & CR_COMPACT)

			aacirun->fifosz >>= 1;

	}

	return ret;

	return ret;

}

}
@@ -740,7 +675,7 @@ static void aaci_pcm_capture_stop(struct aaci_runtime *aacirun) 
{

{

	u32 ie;

	u32 ie;





	aaci_chan_wait_ready(aacirun);

	aaci_chan_wait_ready(aacirun, SR_RXB);





	ie = readl(aacirun->base + AACI_IE);

	ie = readl(aacirun->base + AACI_IE);

	ie &= ~(IE_ORIE | IE_RXIE);

	ie &= ~(IE_ORIE | IE_RXIE);
@@ -755,7 +690,7 @@ static void aaci_pcm_capture_start(struct aaci_runtime *aacirun) 
{

{

	u32 ie;

	u32 ie;





	aaci_chan_wait_ready(aacirun);

	aaci_chan_wait_ready(aacirun, SR_RXB);





#ifdef DEBUG

#ifdef DEBUG

	/* RX Timeout value: bits 28:17 in RXCR */

	/* RX Timeout value: bits 28:17 in RXCR */
@@ -772,12 +707,11 @@ static void aaci_pcm_capture_start(struct aaci_runtime *aacirun) 




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

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

{

{

	struct aaci *aaci = substream->private_data;

	struct aaci_runtime *aacirun = substream->runtime->private_data;

	struct aaci_runtime *aacirun = substream->runtime->private_data;

	unsigned long flags;

	unsigned long flags;

	int ret = 0;

	int ret = 0;





	spin_lock_irqsave(&aaci->lock, flags);

	spin_lock_irqsave(&aacirun->lock, flags);





	switch (cmd) {

	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_START:
@@ -806,7 +740,7 @@ static int aaci_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd 
		ret = -EINVAL;

		ret = -EINVAL;

	}

	}





	spin_unlock_irqrestore(&aaci->lock, flags);

	spin_unlock_irqrestore(&aacirun->lock, flags);





	return ret;

	return ret;

}

}
@@ -889,6 +823,12 @@ static struct ac97_pcm ac97_defs[] __devinitdata = { 
					  (1 << AC97_SLOT_PCM_SRIGHT) |

					  (1 << AC97_SLOT_PCM_SRIGHT) |

					  (1 << AC97_SLOT_LFE),

					  (1 << AC97_SLOT_LFE),

			},

			},

			[1] = {

				.slots	= (1 << AC97_SLOT_PCM_LEFT) |

					  (1 << AC97_SLOT_PCM_RIGHT) |

					  (1 << AC97_SLOT_PCM_LEFT_0) |

					  (1 << AC97_SLOT_PCM_RIGHT_0),

			},

		},

		},

	},

	},

	[1] = {	/* PCM in */

	[1] = {	/* PCM in */
@@ -1001,7 +941,6 @@ static struct aaci * __devinit aaci_init_card(struct amba_device *dev) 




	aaci = card->private_data;

	aaci = card->private_data;

	mutex_init(&aaci->ac97_sem);

	mutex_init(&aaci->ac97_sem);

	spin_lock_init(&aaci->lock);

	aaci->card = card;

	aaci->card = card;

	aaci->dev = dev;

	aaci->dev = dev;
@@ -1028,7 +967,7 @@ static int __devinit aaci_init_pcm(struct aaci *aaci) 
		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &aaci_playback_ops);

		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &aaci_playback_ops);

		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &aaci_capture_ops);

		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &aaci_capture_ops);

		snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,

		snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,

						      NULL, 0, 64 * 104);

						      NULL, 0, 64 * 1024);

	}

	}





	return ret;

	return ret;
@@ -1088,12 +1027,14 @@ static int __devinit aaci_probe(struct amba_device *dev, struct amba_id *id) 
	/*

	/*

	 * Playback uses AACI channel 0

	 * Playback uses AACI channel 0

	 */

	 */

	spin_lock_init(&aaci->playback.lock);

	aaci->playback.base = aaci->base + AACI_CSCH1;

	aaci->playback.base = aaci->base + AACI_CSCH1;

	aaci->playback.fifo = aaci->base + AACI_DR1;

	aaci->playback.fifo = aaci->base + AACI_DR1;





	/*

	/*

	 * Capture uses AACI channel 0

	 * Capture uses AACI channel 0

	 */

	 */

	spin_lock_init(&aaci->capture.lock);

	aaci->capture.base = aaci->base + AACI_CSCH1;

	aaci->capture.base = aaci->base + AACI_CSCH1;

	aaci->capture.fifo = aaci->base + AACI_DR1;

	aaci->capture.fifo = aaci->base + AACI_DR1;

sound/arm/aaci.h

+1 −1
Original line number Original line Diff line number Diff line
@@ -202,6 +202,7 @@ 
struct aaci_runtime {

struct aaci_runtime {

	void			__iomem *base;

	void			__iomem *base;

	void			__iomem *fifo;

	void			__iomem *fifo;

	spinlock_t		lock;





	struct ac97_pcm		*pcm;

	struct ac97_pcm		*pcm;

	int			pcm_open;

	int			pcm_open;
@@ -232,7 +233,6 @@ struct aaci { 
	struct snd_ac97		*ac97;

	struct snd_ac97		*ac97;





	u32			maincr;

	u32			maincr;

	spinlock_t		lock;





	struct aaci_runtime	playback;

	struct aaci_runtime	playback;

	struct aaci_runtime	capture;

	struct aaci_runtime	capture;

sound/core/pcm_lib.c

+2 −2
Original line number Original line Diff line number Diff line
@@ -758,7 +758,7 @@ int snd_interval_ratnum(struct snd_interval *i, 
		int diff;

		int diff;

		if (q == 0)

		if (q == 0)

			q = 1;

			q = 1;

		den = div_down(num, q);

		den = div_up(num, q);

		if (den < rats[k].den_min)

		if (den < rats[k].den_min)

			continue;

			continue;

		if (den > rats[k].den_max)

		if (den > rats[k].den_max)
@@ -794,7 +794,7 @@ int snd_interval_ratnum(struct snd_interval *i, 
			i->empty = 1;

			i->empty = 1;

			return -EINVAL;

			return -EINVAL;

		}

		}

		den = div_up(num, q);

		den = div_down(num, q);

		if (den > rats[k].den_max)

		if (den > rats[k].den_max)

			continue;

			continue;

		if (den < rats[k].den_min)

		if (den < rats[k].den_min)

sound/isa/msnd/msnd_midi.c

+1 −1
Original line number Original line Diff line number Diff line
@@ -162,7 +162,7 @@ int snd_msndmidi_new(struct snd_card *card, int device) 
	err = snd_rawmidi_new(card, "MSND-MIDI", device, 1, 1, &rmidi);

	err = snd_rawmidi_new(card, "MSND-MIDI", device, 1, 1, &rmidi);

	if (err < 0)

	if (err < 0)

		return err;

		return err;

	mpu = kcalloc(1, sizeof(*mpu), GFP_KERNEL);

	mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);

	if (mpu == NULL) {

	if (mpu == NULL) {

		snd_device_free(card, rmidi);

		snd_device_free(card, rmidi);

		return -ENOMEM;

		return -ENOMEM;

sound/isa/sb/emu8000.c

+3 −3
Original line number Original line Diff line number Diff line
@@ -393,8 +393,6 @@ size_dram(struct snd_emu8000 *emu) 




	while (size < EMU8000_MAX_DRAM) {

	while (size < EMU8000_MAX_DRAM) {





		size += 512 * 1024;  /* increment 512kbytes */



		/* Write a unique data on the test address.

		/* Write a unique data on the test address.

		 * if the address is out of range, the data is written on

		 * if the address is out of range, the data is written on

		 * 0x200000(=EMU8000_DRAM_OFFSET).  Then the id word is

		 * 0x200000(=EMU8000_DRAM_OFFSET).  Then the id word is
@@ -414,7 +412,9 @@ size_dram(struct snd_emu8000 *emu) 
		/*snd_emu8000_read_wait(emu);*/

		/*snd_emu8000_read_wait(emu);*/

		EMU8000_SMLD_READ(emu); /* discard stale data  */

		EMU8000_SMLD_READ(emu); /* discard stale data  */

		if (EMU8000_SMLD_READ(emu) != UNIQUE_ID2)

		if (EMU8000_SMLD_READ(emu) != UNIQUE_ID2)

			break; /* we must have wrapped around */

			break; /* no memory at this address */



		size += 512 * 1024;  /* increment 512kbytes */





		snd_emu8000_read_wait(emu);

		snd_emu8000_read_wait(emu);