[ALSA] aoa i2sbus: Stop Apple i2s DMA gracefully (547ac2ae) · Commits · 戴 / test

sound/aoa/soundbus/i2sbus/i2sbus-core.c

+10 −12

Original line number	Original line	Diff line number	Diff line
	@@ -41,8 +41,8 @@ static int alloc_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev,
	struct dbdma_command_mem *r,		struct dbdma_command_mem *r,
	int numcmds)		int numcmds)
	{		{
	/* one more for rounding */		/* one more for rounding, one for branch back, one for stop command */
	r->size = (numcmds+1) * sizeof(struct dbdma_cmd);		r->size = (numcmds + 3) * sizeof(struct dbdma_cmd);
	/* We use the PCI APIs for now until the generic one gets fixed		/* We use the PCI APIs for now until the generic one gets fixed
	* enough or until we get some macio-specific versions		* enough or until we get some macio-specific versions
	*/		*/
	@@ -377,11 +377,8 @@ static int i2sbus_suspend(struct macio_dev* dev, pm_message_t state)
	if (i2sdev->sound.pcm) {		if (i2sdev->sound.pcm) {
	/* Suspend PCM streams */		/* Suspend PCM streams */
	snd_pcm_suspend_all(i2sdev->sound.pcm);		snd_pcm_suspend_all(i2sdev->sound.pcm);
	/* Probably useless as we handle
	* power transitions ourselves */
	snd_power_change_state(i2sdev->sound.pcm->card,
	SNDRV_CTL_POWER_D3hot);
	}		}

	/* Notify codecs */		/* Notify codecs */
	list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {		list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
	err = 0;		err = 0;
	@@ -390,7 +387,11 @@ static int i2sbus_suspend(struct macio_dev* dev, pm_message_t state)
	if (err)		if (err)
	ret = err;		ret = err;
	}		}

			/* wait until streams are stopped */
			i2sbus_wait_for_stop_both(i2sdev);
	}		}

	return ret;		return ret;
	}		}

	@@ -402,6 +403,9 @@ static int i2sbus_resume(struct macio_dev* dev)
	int err, ret = 0;		int err, ret = 0;

	list_for_each_entry(i2sdev, &control->list, item) {		list_for_each_entry(i2sdev, &control->list, item) {
			/* reset i2s bus format etc. */
			i2sbus_pcm_prepare_both(i2sdev);

	/* Notify codecs so they can re-initialize */		/* Notify codecs so they can re-initialize */
	list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {		list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
	err = 0;		err = 0;
	@@ -410,12 +414,6 @@ static int i2sbus_resume(struct macio_dev* dev)
	if (err)		if (err)
	ret = err;		ret = err;
	}		}
	/* Notify Alsa */
	if (i2sdev->sound.pcm) {
	/* Same comment as above, probably useless */
	snd_power_change_state(i2sdev->sound.pcm->card,
	SNDRV_CTL_POWER_D0);
	}
	}		}

	return ret;		return ret;

sound/aoa/soundbus/i2sbus/i2sbus-pcm.c

+194 −134

Original line number	Original line	Diff line number	Diff line
	@@ -125,7 +125,8 @@ static int i2sbus_pcm_open(struct i2sbus_dev *i2sdev, int in)
	}		}
	/* bus dependent stuff */		/* bus dependent stuff */
	hw->info = SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID \|		hw->info = SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID \|
	SNDRV_PCM_INFO_INTERLEAVED \| SNDRV_PCM_INFO_RESUME;		SNDRV_PCM_INFO_INTERLEAVED \| SNDRV_PCM_INFO_RESUME \|
			SNDRV_PCM_INFO_JOINT_DUPLEX;

	CHECK_RATE(5512);		CHECK_RATE(5512);
	CHECK_RATE(8000);		CHECK_RATE(8000);
	@@ -245,18 +246,78 @@ static int i2sbus_pcm_close(struct i2sbus_dev *i2sdev, int in)
	return err;		return err;
	}		}

			static void i2sbus_wait_for_stop(struct i2sbus_dev *i2sdev,
			struct pcm_info *pi)
			{
			unsigned long flags;
			struct completion done;
			long timeout;

			spin_lock_irqsave(&i2sdev->low_lock, flags);
			if (pi->dbdma_ring.stopping) {
			init_completion(&done);
			pi->stop_completion = &done;
			spin_unlock_irqrestore(&i2sdev->low_lock, flags);
			timeout = wait_for_completion_timeout(&done, HZ);
			spin_lock_irqsave(&i2sdev->low_lock, flags);
			pi->stop_completion = NULL;
			if (timeout == 0) {
			/* timeout expired, stop dbdma forcefully */
			printk(KERN_ERR "i2sbus_wait_for_stop: timed out\n");
			/* make sure RUN, PAUSE and S0 bits are cleared */
			out_le32(&pi->dbdma->control, (RUN \| PAUSE \| 1) << 16);
			pi->dbdma_ring.stopping = 0;
			timeout = 10;
			while (in_le32(&pi->dbdma->status) & ACTIVE) {
			if (--timeout <= 0)
			break;
			udelay(1);
			}
			}
			}
			spin_unlock_irqrestore(&i2sdev->low_lock, flags);
			}

			#ifdef CONFIG_PM
			void i2sbus_wait_for_stop_both(struct i2sbus_dev *i2sdev)
			{
			struct pcm_info *pi;

			get_pcm_info(i2sdev, 0, &pi, NULL);
			i2sbus_wait_for_stop(i2sdev, pi);
			get_pcm_info(i2sdev, 1, &pi, NULL);
			i2sbus_wait_for_stop(i2sdev, pi);
			}
			#endif

	static int i2sbus_hw_params(struct snd_pcm_substream *substream,		static int i2sbus_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *params)		struct snd_pcm_hw_params *params)
	{		{
	return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));		return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
	}		}

	static int i2sbus_hw_free(struct snd_pcm_substream *substream)		static inline int i2sbus_hw_free(struct snd_pcm_substream *substream, int in)
	{		{
			struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
			struct pcm_info *pi;

			get_pcm_info(i2sdev, in, &pi, NULL);
			if (pi->dbdma_ring.stopping)
			i2sbus_wait_for_stop(i2sdev, pi);
	snd_pcm_lib_free_pages(substream);		snd_pcm_lib_free_pages(substream);
	return 0;		return 0;
	}		}

			static int i2sbus_playback_hw_free(struct snd_pcm_substream *substream)
			{
			return i2sbus_hw_free(substream, 0);
			}

			static int i2sbus_record_hw_free(struct snd_pcm_substream *substream)
			{
			return i2sbus_hw_free(substream, 1);
			}

	static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)		static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
	{		{
	/* whee. Hard work now. The user has selected a bitrate		/* whee. Hard work now. The user has selected a bitrate
	@@ -264,7 +325,7 @@ static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
	* I2S controller appropriately. */		* I2S controller appropriately. */
	struct snd_pcm_runtime *runtime;		struct snd_pcm_runtime *runtime;
	struct dbdma_cmd *command;		struct dbdma_cmd *command;
	int i, periodsize;		int i, periodsize, nperiods;
	dma_addr_t offset;		dma_addr_t offset;
	struct bus_info bi;		struct bus_info bi;
	struct codec_info_item *cii;		struct codec_info_item *cii;
	@@ -274,6 +335,7 @@ static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
	struct pcm_info pi, other;		struct pcm_info pi, other;
	int cnt;		int cnt;
	int result = 0;		int result = 0;
			unsigned int cmd, stopaddr;

	mutex_lock(&i2sdev->lock);		mutex_lock(&i2sdev->lock);

	@@ -283,6 +345,13 @@ static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
	result = -EBUSY;		result = -EBUSY;
	goto out_unlock;		goto out_unlock;
	}		}
			if (pi->dbdma_ring.stopping)
			i2sbus_wait_for_stop(i2sdev, pi);

			if (!pi->substream \|\| !pi->substream->runtime) {
			result = -EINVAL;
			goto out_unlock;
			}

	runtime = pi->substream->runtime;		runtime = pi->substream->runtime;
	pi->active = 1;		pi->active = 1;
	@@ -297,24 +366,43 @@ static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
	i2sdev->rate = runtime->rate;		i2sdev->rate = runtime->rate;

	periodsize = snd_pcm_lib_period_bytes(pi->substream);		periodsize = snd_pcm_lib_period_bytes(pi->substream);
			nperiods = pi->substream->runtime->periods;
	pi->current_period = 0;		pi->current_period = 0;

	/* generate dbdma command ring first */		/* generate dbdma command ring first */
	command = pi->dbdma_ring.cmds;		command = pi->dbdma_ring.cmds;
			memset(command, 0, (nperiods + 2) * sizeof(struct dbdma_cmd));

			/* commands to DMA to/from the ring */
			/*
			* For input, we need to do a graceful stop; if we abort
			* the DMA, we end up with leftover bytes that corrupt
			* the next recording. To do this we set the S0 status
			* bit and wait for the DMA controller to stop. Each
			* command has a branch condition to
			* make it branch to a stop command if S0 is set.
			* On input we also need to wait for the S7 bit to be
			* set before turning off the DMA controller.
			* In fact we do the graceful stop for output as well.
			*/
	offset = runtime->dma_addr;		offset = runtime->dma_addr;
	for (i = 0; i < pi->substream->runtime->periods;		cmd = (in? INPUT_MORE: OUTPUT_MORE) \| BR_IFSET \| INTR_ALWAYS;
	i++, command++, offset += periodsize) {		stopaddr = pi->dbdma_ring.bus_cmd_start +
	memset(command, 0, sizeof(struct dbdma_cmd));		(nperiods + 1) * sizeof(struct dbdma_cmd);
	command->command =		for (i = 0; i < nperiods; i++, command++, offset += periodsize) {
	cpu_to_le16((in ? INPUT_MORE : OUTPUT_MORE) \| INTR_ALWAYS);		command->command = cpu_to_le16(cmd);
			command->cmd_dep = cpu_to_le32(stopaddr);
	command->phy_addr = cpu_to_le32(offset);		command->phy_addr = cpu_to_le32(offset);
	command->req_count = cpu_to_le16(periodsize);		command->req_count = cpu_to_le16(periodsize);
	command->xfer_status = cpu_to_le16(0);
	}		}
	/* last one branches back to first */
	command--;		/* branch back to beginning of ring */
	command->command \|= cpu_to_le16(BR_ALWAYS);		command->command = cpu_to_le16(DBDMA_NOP \| BR_ALWAYS);
	command->cmd_dep = cpu_to_le32(pi->dbdma_ring.bus_cmd_start);		command->cmd_dep = cpu_to_le32(pi->dbdma_ring.bus_cmd_start);
			command++;

			/* set stop command */
			command->command = cpu_to_le16(DBDMA_STOP);

	/* ok, let's set the serial format and stuff */		/* ok, let's set the serial format and stuff */
	switch (runtime->format) {		switch (runtime->format) {
	@@ -435,16 +523,18 @@ static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
	return result;		return result;
	}		}

	static struct dbdma_cmd STOP_CMD = {		#ifdef CONFIG_PM
	.command = __constant_cpu_to_le16(DBDMA_STOP),		void i2sbus_pcm_prepare_both(struct i2sbus_dev *i2sdev)
	};		{
			i2sbus_pcm_prepare(i2sdev, 0);
			i2sbus_pcm_prepare(i2sdev, 1);
			}
			#endif

	static int i2sbus_pcm_trigger(struct i2sbus_dev *i2sdev, int in, int cmd)		static int i2sbus_pcm_trigger(struct i2sbus_dev *i2sdev, int in, int cmd)
	{		{
	struct codec_info_item *cii;		struct codec_info_item *cii;
	struct pcm_info *pi;		struct pcm_info *pi;
	int timeout;
	struct dbdma_cmd tmp;
	int result = 0;		int result = 0;
	unsigned long flags;		unsigned long flags;

	@@ -464,92 +554,50 @@ static int i2sbus_pcm_trigger(struct i2sbus_dev *i2sdev, int in, int cmd)
	cii->codec->start(cii, pi->substream);		cii->codec->start(cii, pi->substream);
	pi->dbdma_ring.running = 1;		pi->dbdma_ring.running = 1;

	/* reset dma engine */		if (pi->dbdma_ring.stopping) {
	out_le32(&pi->dbdma->control,		/* Clear the S0 bit, then see if we stopped yet */
	0 \| (RUN \| PAUSE \| FLUSH \| WAKE) << 16);		out_le32(&pi->dbdma->control, 1 << 16);
	timeout = 100;		if (in_le32(&pi->dbdma->status) & ACTIVE) {
	while (in_le32(&pi->dbdma->status) & RUN && timeout--)		/* possible race here? */
	udelay(1);		udelay(10);
	if (timeout <= 0) {		if (in_le32(&pi->dbdma->status) & ACTIVE) {
	printk(KERN_ERR		pi->dbdma_ring.stopping = 0;
	"i2sbus: error waiting for dma reset\n");		goto out_unlock; /* keep running */
	result = -ENXIO;		}
	goto out_unlock;		}
	}		}

			/* make sure RUN, PAUSE and S0 bits are cleared */
			out_le32(&pi->dbdma->control, (RUN \| PAUSE \| 1) << 16);

			/* set branch condition select register */
			out_le32(&pi->dbdma->br_sel, (1 << 16) \| 1);

	/* write dma command buffer address to the dbdma chip */		/* write dma command buffer address to the dbdma chip */
	out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start);		out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start);
	/* post PCI write */
	mb();
	(void)in_le32(&pi->dbdma->status);

	/* change first command to STOP */
	tmp = *pi->dbdma_ring.cmds;
	*pi->dbdma_ring.cmds = STOP_CMD;

	/* set running state, remember that the first command is STOP */
	out_le32(&pi->dbdma->control, RUN \| (RUN << 16));
	timeout = 100;
	/* wait for STOP to be executed */
	while (in_le32(&pi->dbdma->status) & ACTIVE && timeout--)
	udelay(1);
	if (timeout <= 0) {
	printk(KERN_ERR "i2sbus: error waiting for dma stop\n");
	result = -ENXIO;
	goto out_unlock;
	}
	/* again, write dma command buffer address to the dbdma chip,
	* this time of the first real command */
	*pi->dbdma_ring.cmds = tmp;
	out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start);
	/* post write */
	mb();
	(void)in_le32(&pi->dbdma->status);

	/* reset dma engine again */
	out_le32(&pi->dbdma->control,
	0 \| (RUN \| PAUSE \| FLUSH \| WAKE) << 16);
	timeout = 100;
	while (in_le32(&pi->dbdma->status) & RUN && timeout--)
	udelay(1);
	if (timeout <= 0) {
	printk(KERN_ERR
	"i2sbus: error waiting for dma reset\n");
	result = -ENXIO;
	goto out_unlock;
	}

	/* wake up the chip with the next descriptor */		/* initialize the frame count and current period */
	out_le32(&pi->dbdma->control,		pi->current_period = 0;
	(RUN \| WAKE) \| ((RUN \| WAKE) << 16));
	/* get the frame count */
	pi->frame_count = in_le32(&i2sdev->intfregs->frame_count);		pi->frame_count = in_le32(&i2sdev->intfregs->frame_count);

			/* set the DMA controller running */
			out_le32(&pi->dbdma->control, (RUN << 16) \| RUN);

	/* off you go! */		/* off you go! */
	break;		break;

	case SNDRV_PCM_TRIGGER_STOP:		case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:		case SNDRV_PCM_TRIGGER_SUSPEND:
	if (!pi->dbdma_ring.running) {		if (!pi->dbdma_ring.running) {
	result = -EALREADY;		result = -EALREADY;
	goto out_unlock;		goto out_unlock;
	}		}
			pi->dbdma_ring.running = 0;

	/* turn off all relevant bits */		/* Set the S0 bit to make the DMA branch to the stop cmd */
	out_le32(&pi->dbdma->control,		out_le32(&pi->dbdma->control, (1 << 16) \| 1);
	(RUN \| WAKE \| FLUSH \| PAUSE) << 16);		pi->dbdma_ring.stopping = 1;
	{
	/* FIXME: move to own function */
	int timeout = 5000;
	while ((in_le32(&pi->dbdma->status) & RUN)
	&& --timeout > 0)
	udelay(1);
	if (!timeout)
	printk(KERN_ERR
	"i2sbus: timed out turning "
	"off dbdma engine!\n");
	}

	pi->dbdma_ring.running = 0;
	list_for_each_entry(cii, &i2sdev->sound.codec_list, list)		list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
	if (cii->codec->stop)		if (cii->codec->stop)
	cii->codec->stop(cii, pi->substream);		cii->codec->stop(cii, pi->substream);
	@@ -574,70 +622,82 @@ static snd_pcm_uframes_t i2sbus_pcm_pointer(struct i2sbus_dev *i2sdev, int in)
	fc = in_le32(&i2sdev->intfregs->frame_count);		fc = in_le32(&i2sdev->intfregs->frame_count);
	fc = fc - pi->frame_count;		fc = fc - pi->frame_count;

	return (bytes_to_frames(pi->substream->runtime,		if (fc >= pi->substream->runtime->buffer_size)
	pi->current_period *		fc %= pi->substream->runtime->buffer_size;
	snd_pcm_lib_period_bytes(pi->substream))		return fc;
	+ fc) % pi->substream->runtime->buffer_size;
	}		}

	static inline void handle_interrupt(struct i2sbus_dev *i2sdev, int in)		static inline void handle_interrupt(struct i2sbus_dev *i2sdev, int in)
	{		{
	struct pcm_info *pi;		struct pcm_info *pi;
	u32 fc;		u32 fc, nframes;
	u32 delta;		u32 status;
			int timeout, i;
			int dma_stopped = 0;
			struct snd_pcm_runtime *runtime;

	spin_lock(&i2sdev->low_lock);		spin_lock(&i2sdev->low_lock);
	get_pcm_info(i2sdev, in, &pi, NULL);		get_pcm_info(i2sdev, in, &pi, NULL);
			if (!pi->dbdma_ring.running && !pi->dbdma_ring.stopping)
	if (!pi->dbdma_ring.running) {
	/* there was still an interrupt pending
	* while we stopped. or maybe another
	* processor (not the one that was stopping
	* the DMA engine) was spinning above
	* waiting for the lock. */
	goto out_unlock;		goto out_unlock;
	}

	fc = in_le32(&i2sdev->intfregs->frame_count);		i = pi->current_period;
	/* a counter overflow does not change the calculation. */		runtime = pi->substream->runtime;
	delta = fc - pi->frame_count;		while (pi->dbdma_ring.cmds[i].xfer_status) {
			if (le16_to_cpu(pi->dbdma_ring.cmds[i].xfer_status) & BT)
			/*
			* BT is the branch taken bit. If it took a branch
			* it is because we set the S0 bit to make it
			* branch to the stop command.
			*/
			dma_stopped = 1;
			pi->dbdma_ring.cmds[i].xfer_status = 0;

	/* update current_period */		if (++i >= runtime->periods) {
	while (delta >= pi->substream->runtime->period_size) {		i = 0;
	pi->current_period++;		pi->frame_count += runtime->buffer_size;
	delta = delta - pi->substream->runtime->period_size;
	}		}
			pi->current_period = i;

	if (unlikely(delta)) {		/*
	/* Some interrupt came late, so check the dbdma.		* Check the frame count. The DMA tends to get a bit
	* This special case exists to syncronize the frame_count with		* ahead of the frame counter, which confuses the core.
	* the dbdma transfer, but is hit every once in a while. */		*/
	int period;		fc = in_le32(&i2sdev->intfregs->frame_count);
			nframes = i * runtime->period_size;
	period = (in_le32(&pi->dbdma->cmdptr)		if (fc < pi->frame_count + nframes)
	- pi->dbdma_ring.bus_cmd_start)		pi->frame_count = fc - nframes;
	/ sizeof(struct dbdma_cmd);		}
	pi->current_period = pi->current_period
	% pi->substream->runtime->periods;

	while (pi->current_period != period) {		if (dma_stopped) {
	pi->current_period++;		timeout = 1000;
	pi->current_period %= pi->substream->runtime->periods;		for (;;) {
	/* Set delta to zero, as the frame_count value is too		status = in_le32(&pi->dbdma->status);
	* high (otherwise the code path will not be executed).		if (!(status & ACTIVE) && (!in \|\| (status & 0x80)))
	* This corrects the fact that the frame_count is too		break;
	* low at the beginning due to buffering. */		if (--timeout <= 0) {
	delta = 0;		printk(KERN_ERR "i2sbus: timed out "
			"waiting for DMA to stop!\n");
			break;
	}		}
			udelay(1);
	}		}

	pi->frame_count = fc - delta;		/* Turn off DMA controller, clear S0 bit */
	pi->current_period %= pi->substream->runtime->periods;		out_le32(&pi->dbdma->control, (RUN \| PAUSE \| 1) << 16);

			pi->dbdma_ring.stopping = 0;
			if (pi->stop_completion)
			complete(pi->stop_completion);
			}

			if (!pi->dbdma_ring.running)
			goto out_unlock;
	spin_unlock(&i2sdev->low_lock);		spin_unlock(&i2sdev->low_lock);
	/* may call _trigger again, hence needs to be unlocked */		/* may call _trigger again, hence needs to be unlocked */
	snd_pcm_period_elapsed(pi->substream);		snd_pcm_period_elapsed(pi->substream);
	return;		return;

	out_unlock:		out_unlock:
	spin_unlock(&i2sdev->low_lock);		spin_unlock(&i2sdev->low_lock);
	}		}
	@@ -718,7 +778,7 @@ static struct snd_pcm_ops i2sbus_playback_ops = {
	.close = i2sbus_playback_close,		.close = i2sbus_playback_close,
	.ioctl = snd_pcm_lib_ioctl,		.ioctl = snd_pcm_lib_ioctl,
	.hw_params = i2sbus_hw_params,		.hw_params = i2sbus_hw_params,
	.hw_free = i2sbus_hw_free,		.hw_free = i2sbus_playback_hw_free,
	.prepare = i2sbus_playback_prepare,		.prepare = i2sbus_playback_prepare,
	.trigger = i2sbus_playback_trigger,		.trigger = i2sbus_playback_trigger,
	.pointer = i2sbus_playback_pointer,		.pointer = i2sbus_playback_pointer,
	@@ -788,7 +848,7 @@ static struct snd_pcm_ops i2sbus_record_ops = {
	.close = i2sbus_record_close,		.close = i2sbus_record_close,
	.ioctl = snd_pcm_lib_ioctl,		.ioctl = snd_pcm_lib_ioctl,
	.hw_params = i2sbus_hw_params,		.hw_params = i2sbus_hw_params,
	.hw_free = i2sbus_hw_free,		.hw_free = i2sbus_record_hw_free,
	.prepare = i2sbus_record_prepare,		.prepare = i2sbus_record_prepare,
	.trigger = i2sbus_record_trigger,		.trigger = i2sbus_record_trigger,
	.pointer = i2sbus_record_pointer,		.pointer = i2sbus_record_pointer,

sound/aoa/soundbus/i2sbus/i2sbus.h

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -10,6 +10,7 @@
	#include <linux/interrupt.h>		#include <linux/interrupt.h>
	#include <linux/spinlock.h>		#include <linux/spinlock.h>
	#include <linux/mutex.h>		#include <linux/mutex.h>
			#include <linux/completion.h>

	#include <sound/pcm.h>		#include <sound/pcm.h>

	@@ -34,6 +35,7 @@ struct dbdma_command_mem {
	void *space;		void *space;
	int size;		int size;
	u32 running:1;		u32 running:1;
			u32 stopping:1;
	};		};

	struct pcm_info {		struct pcm_info {
	@@ -45,6 +47,7 @@ struct pcm_info {
	u32 frame_count;		u32 frame_count;
	struct dbdma_command_mem dbdma_ring;		struct dbdma_command_mem dbdma_ring;
	volatile struct dbdma_regs __iomem *dbdma;		volatile struct dbdma_regs __iomem *dbdma;
			struct completion *stop_completion;
	};		};

	enum {		enum {
	@@ -101,6 +104,9 @@ i2sbus_tx_intr(int irq, void *devid);
	extern irqreturn_t		extern irqreturn_t
	i2sbus_rx_intr(int irq, void *devid);		i2sbus_rx_intr(int irq, void *devid);

			extern void i2sbus_wait_for_stop_both(struct i2sbus_dev *i2sdev);
			extern void i2sbus_pcm_prepare_both(struct i2sbus_dev *i2sdev);

	/* control specific functions */		/* control specific functions */
	extern int i2sbus_control_init(struct macio_dev* dev,		extern int i2sbus_control_init(struct macio_dev* dev,
	struct i2sbus_control **c);		struct i2sbus_control **c);

Admin message