1 files changed, 76 insertions, 140 deletions
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index c1c1556105c0..b406630d8fdf 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -1591,6 +1591,71 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
 EXPORT_SYMBOL(snd_pcm_period_elapsed);
+/*
+ * Wait until avail_min data becomes available
+ * Returns a negative error code if any error occurs during operation.
+ * The available space is stored on availp.  When err = 0 and avail = 0
+ * on the capture stream, it indicates the stream is in DRAINING state.
+ */
+static int wait_for_avail_min(struct snd_pcm_substream *substream,
+                              snd_pcm_uframes_t *availp)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
+        wait_queue_t wait;
+        int err = 0;
+        snd_pcm_uframes_t avail = 0;
+        long tout;
+        init_waitqueue_entry(&wait, current);
+        add_wait_queue(&runtime->sleep, &wait);
+        for (;;) {
+                if (signal_pending(current)) {
+                        err = -ERESTARTSYS;
+                        break;
+                }
+                set_current_state(TASK_INTERRUPTIBLE);
+                snd_pcm_stream_unlock_irq(substream);
+                tout = schedule_timeout(msecs_to_jiffies(10000));
+                snd_pcm_stream_lock_irq(substream);
+                switch (runtime->status->state) {
+                case SNDRV_PCM_STATE_SUSPENDED:
+                        err = -ESTRPIPE;
+                        goto _endloop;
+                case SNDRV_PCM_STATE_XRUN:
+                        err = -EPIPE;
+                        goto _endloop;
+                case SNDRV_PCM_STATE_DRAINING:
+                        if (is_playback)
+                                err = -EPIPE;
+                        else 
+                                avail = 0; /* indicate draining */
+                        goto _endloop;
+                case SNDRV_PCM_STATE_OPEN:
+                case SNDRV_PCM_STATE_SETUP:
+                case SNDRV_PCM_STATE_DISCONNECTED:
+                        err = -EBADFD;
+                        goto _endloop;
+                }
+                if (!tout) {
+                        snd_printd("%s write error (DMA or IRQ trouble?)\n",
+                                   is_playback ? "playback" : "capture");
+                        err = -EIO;
+                        break;
+                }
+                if (is_playback)
+                        avail = snd_pcm_playback_avail(runtime);
+                else
+                        avail = snd_pcm_capture_avail(runtime);
+                if (avail >= runtime->control->avail_min)
+                        break;
+        }
+ _endloop:
+        remove_wait_queue(&runtime->sleep, &wait);
+        *availp = avail;
+        return err;
+}
+        
 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
                                      unsigned int hwoff,
                                      unsigned long data, unsigned int off,
@@ -1653,79 +1718,14 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING)
                        snd_pcm_update_hw_ptr(substream);
                avail = snd_pcm_playback_avail(runtime);
-                if (!avail ||
+                if (!avail) {
-                    (snd_pcm_running(substream) &&
-                     (avail < runtime->control->avail_min && size > avail))) {
-                        wait_queue_t wait;
-                        enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state;
-                        long tout;
                        if (nonblock) {
                                err = -EAGAIN;
                                goto _end_unlock;
                        }
+                        err = wait_for_avail_min(substream, &avail);
-                        init_waitqueue_entry(&wait, current);
+                        if (err < 0)
-                        add_wait_queue(&runtime->sleep, &wait);
-                        while (1) {
-                                if (signal_pending(current)) {
-                                        state = SIGNALED;
-                                        break;
-                                }
-                                set_current_state(TASK_INTERRUPTIBLE);
-                                snd_pcm_stream_unlock_irq(substream);
-                                tout = schedule_timeout(10 * HZ);
-                                snd_pcm_stream_lock_irq(substream);
-                                if (tout == 0) {
-                                        if (runtime->status->state != SNDRV_PCM_STATE_PREPARED &&
-                                            runtime->status->state != SNDRV_PCM_STATE_PAUSED) {
-                                                state = runtime->status->state == SNDRV_PCM_STATE_SUSPENDED ? SUSPENDED : EXPIRED;
-                                                break;
-                                        }
-                                }
-                                switch (runtime->status->state) {
-                                case SNDRV_PCM_STATE_XRUN:
-                                case SNDRV_PCM_STATE_DRAINING:
-                                        state = ERROR;
-                                        goto _end_loop;
-                                case SNDRV_PCM_STATE_SUSPENDED:
-                                        state = SUSPENDED;
-                                        goto _end_loop;
-                                case SNDRV_PCM_STATE_SETUP:
-                                        state = DROPPED;
-                                        goto _end_loop;
-                                default:
-                                        break;
-                                }
-                                avail = snd_pcm_playback_avail(runtime);
-                                if (avail >= runtime->control->avail_min) {
-                                        state = READY;
-                                        break;
-                                }
-                        }
-                       _end_loop:
-                        remove_wait_queue(&runtime->sleep, &wait);
-                        switch (state) {
-                        case ERROR:
-                                err = -EPIPE;
-                                goto _end_unlock;
-                        case SUSPENDED:
-                                err = -ESTRPIPE;
-                                goto _end_unlock;
-                        case SIGNALED:
-                                err = -ERESTARTSYS;
-                                goto _end_unlock;
-                        case EXPIRED:
-                                snd_printd("playback write error (DMA or IRQ trouble?)\n");
-                                err = -EIO;
-                                goto _end_unlock;
-                        case DROPPED:
-                                err = -EBADFD;
                                goto _end_unlock;
-                        default:
-                                break;
-                        }
                }
                frames = size > avail ? avail : size;
                cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
@@ -1925,86 +1925,22 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                snd_pcm_uframes_t cont;
                if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING)
                        snd_pcm_update_hw_ptr(substream);
-              __draining:
                avail = snd_pcm_capture_avail(runtime);
-                if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
+                if (!avail) {
-                        if (!avail) {
+                        if (runtime->status->state ==
-                                err = -EPIPE;
+                            SNDRV_PCM_STATE_DRAINING) {
+                                snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
                                goto _end_unlock;
                        }
-                } else if (avail < runtime->control->avail_min &&
-                           size > avail) {
-                        wait_queue_t wait;
-                        enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state;
-                        long tout;
                        if (nonblock) {
                                err = -EAGAIN;
                                goto _end_unlock;
                        }
+                        err = wait_for_avail_min(substream, &avail);
-                        init_waitqueue_entry(&wait, current);
+                        if (err < 0)
-                        add_wait_queue(&runtime->sleep, &wait);
-                        while (1) {
-                                if (signal_pending(current)) {
-                                        state = SIGNALED;
-                                        break;
-                                }
-                                set_current_state(TASK_INTERRUPTIBLE);
-                                snd_pcm_stream_unlock_irq(substream);
-                                tout = schedule_timeout(10 * HZ);
-                                snd_pcm_stream_lock_irq(substream);
-                                if (tout == 0) {
-                                        if (runtime->status->state != SNDRV_PCM_STATE_PREPARED &&
-                                            runtime->status->state != SNDRV_PCM_STATE_PAUSED) {
-                                                state = runtime->status->state == SNDRV_PCM_STATE_SUSPENDED ? SUSPENDED : EXPIRED;
-                                                break;
-                                        }
-                                }
-                                switch (runtime->status->state) {
-                                case SNDRV_PCM_STATE_XRUN:
-                                        state = ERROR;
-                                        goto _end_loop;
-                                case SNDRV_PCM_STATE_SUSPENDED:
-                                        state = SUSPENDED;
-                                        goto _end_loop;
-                                case SNDRV_PCM_STATE_DRAINING:
-                                        goto __draining;
-                                case SNDRV_PCM_STATE_SETUP:
-                                        state = DROPPED;
-                                        goto _end_loop;
-                                default:
-                                        break;
-                                }
-                                avail = snd_pcm_capture_avail(runtime);
-                                if (avail >= runtime->control->avail_min) {
-                                        state = READY;
-                                        break;
-                                }
-                        }
-                       _end_loop:
-                        remove_wait_queue(&runtime->sleep, &wait);
-                        switch (state) {
-                        case ERROR:
-                                err = -EPIPE;
-                                goto _end_unlock;
-                        case SUSPENDED:
-                                err = -ESTRPIPE;
-                                goto _end_unlock;
-                        case SIGNALED:
-                                err = -ERESTARTSYS;
-                                goto _end_unlock;
-                        case EXPIRED:
-                                snd_printd("capture read error (DMA or IRQ trouble?)\n");
-                                err = -EIO;
-                                goto _end_unlock;
-                        case DROPPED:
-                                err = -EBADFD;
                                goto _end_unlock;
-                        default:
+                        if (!avail)
-                                break;
+                                continue; /* draining */
-                        }
                }
                frames = size > avail ? avail : size;
                cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;

diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index c1c1556105c0..b406630d8fdf 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c
@@ -1591,6 +1591,71 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
1591		1591
1592	EXPORT_SYMBOL(snd_pcm_period_elapsed);	1592	EXPORT_SYMBOL(snd_pcm_period_elapsed);
1593		1593
		1594	/*
		1595	* Wait until avail_min data becomes available
		1596	* Returns a negative error code if any error occurs during operation.
		1597	* The available space is stored on availp. When err = 0 and avail = 0
		1598	* on the capture stream, it indicates the stream is in DRAINING state.
		1599	*/
		1600	static int wait_for_avail_min(struct snd_pcm_substream *substream,
		1601	snd_pcm_uframes_t *availp)
		1602	{
		1603	struct snd_pcm_runtime *runtime = substream->runtime;
		1604	int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
		1605	wait_queue_t wait;
		1606	int err = 0;
		1607	snd_pcm_uframes_t avail = 0;
		1608	long tout;
		1609
		1610	init_waitqueue_entry(&wait, current);
		1611	add_wait_queue(&runtime->sleep, &wait);
		1612	for (;;) {
		1613	if (signal_pending(current)) {
		1614	err = -ERESTARTSYS;
		1615	break;
		1616	}
		1617	set_current_state(TASK_INTERRUPTIBLE);
		1618	snd_pcm_stream_unlock_irq(substream);
		1619	tout = schedule_timeout(msecs_to_jiffies(10000));
		1620	snd_pcm_stream_lock_irq(substream);
		1621	switch (runtime->status->state) {
		1622	case SNDRV_PCM_STATE_SUSPENDED:
		1623	err = -ESTRPIPE;
		1624	goto _endloop;
		1625	case SNDRV_PCM_STATE_XRUN:
		1626	err = -EPIPE;
		1627	goto _endloop;
		1628	case SNDRV_PCM_STATE_DRAINING:
		1629	if (is_playback)
		1630	err = -EPIPE;
		1631	else
		1632	avail = 0; /* indicate draining */
		1633	goto _endloop;
		1634	case SNDRV_PCM_STATE_OPEN:
		1635	case SNDRV_PCM_STATE_SETUP:
		1636	case SNDRV_PCM_STATE_DISCONNECTED:
		1637	err = -EBADFD;
		1638	goto _endloop;
		1639	}
		1640	if (!tout) {
		1641	snd_printd("%s write error (DMA or IRQ trouble?)\n",
		1642	is_playback ? "playback" : "capture");
		1643	err = -EIO;
		1644	break;
		1645	}
		1646	if (is_playback)
		1647	avail = snd_pcm_playback_avail(runtime);
		1648	else
		1649	avail = snd_pcm_capture_avail(runtime);
		1650	if (avail >= runtime->control->avail_min)
		1651	break;
		1652	}
		1653	_endloop:
		1654	remove_wait_queue(&runtime->sleep, &wait);
		1655	*availp = avail;
		1656	return err;
		1657	}
		1658
1594	static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,	1659	static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
1595	unsigned int hwoff,	1660	unsigned int hwoff,
1596	unsigned long data, unsigned int off,	1661	unsigned long data, unsigned int off,
@@ -1653,79 +1718,14 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
1653	if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING)	1718	if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING)
1654	snd_pcm_update_hw_ptr(substream);	1719	snd_pcm_update_hw_ptr(substream);
1655	avail = snd_pcm_playback_avail(runtime);	1720	avail = snd_pcm_playback_avail(runtime);
1656	if (!avail \|\|	1721	if (!avail) {
1657	(snd_pcm_running(substream) &&
1658	(avail < runtime->control->avail_min && size > avail))) {
1659	wait_queue_t wait;
1660	enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state;
1661	long tout;
1662
1663	if (nonblock) {	1722	if (nonblock) {
1664	err = -EAGAIN;	1723	err = -EAGAIN;
1665	goto _end_unlock;	1724	goto _end_unlock;
1666	}	1725	}
1667		1726	err = wait_for_avail_min(substream, &avail);
1668	init_waitqueue_entry(&wait, current);	1727	if (err < 0)
1669	add_wait_queue(&runtime->sleep, &wait);
1670	while (1) {
1671	if (signal_pending(current)) {
1672	state = SIGNALED;
1673	break;
1674	}
1675	set_current_state(TASK_INTERRUPTIBLE);
1676	snd_pcm_stream_unlock_irq(substream);
1677	tout = schedule_timeout(10 * HZ);
1678	snd_pcm_stream_lock_irq(substream);
1679	if (tout == 0) {
1680	if (runtime->status->state != SNDRV_PCM_STATE_PREPARED &&
1681	runtime->status->state != SNDRV_PCM_STATE_PAUSED) {
1682	state = runtime->status->state == SNDRV_PCM_STATE_SUSPENDED ? SUSPENDED : EXPIRED;
1683	break;
1684	}
1685	}
1686	switch (runtime->status->state) {
1687	case SNDRV_PCM_STATE_XRUN:
1688	case SNDRV_PCM_STATE_DRAINING:
1689	state = ERROR;
1690	goto _end_loop;
1691	case SNDRV_PCM_STATE_SUSPENDED:
1692	state = SUSPENDED;
1693	goto _end_loop;
1694	case SNDRV_PCM_STATE_SETUP:
1695	state = DROPPED;
1696	goto _end_loop;
1697	default:
1698	break;
1699	}
1700	avail = snd_pcm_playback_avail(runtime);
1701	if (avail >= runtime->control->avail_min) {
1702	state = READY;
1703	break;
1704	}
1705	}
1706	_end_loop:
1707	remove_wait_queue(&runtime->sleep, &wait);
1708
1709	switch (state) {
1710	case ERROR:
1711	err = -EPIPE;
1712	goto _end_unlock;
1713	case SUSPENDED:
1714	err = -ESTRPIPE;
1715	goto _end_unlock;
1716	case SIGNALED:
1717	err = -ERESTARTSYS;
1718	goto _end_unlock;
1719	case EXPIRED:
1720	snd_printd("playback write error (DMA or IRQ trouble?)\n");
1721	err = -EIO;
1722	goto _end_unlock;
1723	case DROPPED:
1724	err = -EBADFD;
1725	goto _end_unlock;	1728	goto _end_unlock;
1726	default:
1727	break;
1728	}
1729	}	1729	}
1730	frames = size > avail ? avail : size;	1730	frames = size > avail ? avail : size;
1731	cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;	1731	cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
@@ -1925,86 +1925,22 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
1925	snd_pcm_uframes_t cont;	1925	snd_pcm_uframes_t cont;
1926	if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING)	1926	if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING)
1927	snd_pcm_update_hw_ptr(substream);	1927	snd_pcm_update_hw_ptr(substream);
1928	__draining:
1929	avail = snd_pcm_capture_avail(runtime);	1928	avail = snd_pcm_capture_avail(runtime);
1930	if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {	1929	if (!avail) {
1931	if (!avail) {	1930	if (runtime->status->state ==
1932	err = -EPIPE;	1931	SNDRV_PCM_STATE_DRAINING) {
		1932	snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1933	goto _end_unlock;	1933	goto _end_unlock;
1934	}	1934	}
1935	} else if (avail < runtime->control->avail_min &&
1936	size > avail) {
1937	wait_queue_t wait;
1938	enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state;
1939	long tout;
1940
1941	if (nonblock) {	1935	if (nonblock) {
1942	err = -EAGAIN;	1936	err = -EAGAIN;
1943	goto _end_unlock;	1937	goto _end_unlock;
1944	}	1938	}
1945		1939	err = wait_for_avail_min(substream, &avail);
1946	init_waitqueue_entry(&wait, current);	1940	if (err < 0)
1947	add_wait_queue(&runtime->sleep, &wait);
1948	while (1) {
1949	if (signal_pending(current)) {
1950	state = SIGNALED;
1951	break;
1952	}
1953	set_current_state(TASK_INTERRUPTIBLE);
1954	snd_pcm_stream_unlock_irq(substream);
1955	tout = schedule_timeout(10 * HZ);
1956	snd_pcm_stream_lock_irq(substream);
1957	if (tout == 0) {
1958	if (runtime->status->state != SNDRV_PCM_STATE_PREPARED &&
1959	runtime->status->state != SNDRV_PCM_STATE_PAUSED) {
1960	state = runtime->status->state == SNDRV_PCM_STATE_SUSPENDED ? SUSPENDED : EXPIRED;
1961	break;
1962	}
1963	}
1964	switch (runtime->status->state) {
1965	case SNDRV_PCM_STATE_XRUN:
1966	state = ERROR;
1967	goto _end_loop;
1968	case SNDRV_PCM_STATE_SUSPENDED:
1969	state = SUSPENDED;
1970	goto _end_loop;
1971	case SNDRV_PCM_STATE_DRAINING:
1972	goto __draining;
1973	case SNDRV_PCM_STATE_SETUP:
1974	state = DROPPED;
1975	goto _end_loop;
1976	default:
1977	break;
1978	}
1979	avail = snd_pcm_capture_avail(runtime);
1980	if (avail >= runtime->control->avail_min) {
1981	state = READY;
1982	break;
1983	}
1984	}
1985	_end_loop:
1986	remove_wait_queue(&runtime->sleep, &wait);
1987
1988	switch (state) {
1989	case ERROR:
1990	err = -EPIPE;
1991	goto _end_unlock;
1992	case SUSPENDED:
1993	err = -ESTRPIPE;
1994	goto _end_unlock;
1995	case SIGNALED:
1996	err = -ERESTARTSYS;
1997	goto _end_unlock;
1998	case EXPIRED:
1999	snd_printd("capture read error (DMA or IRQ trouble?)\n");
2000	err = -EIO;
2001	goto _end_unlock;
2002	case DROPPED:
2003	err = -EBADFD;
2004	goto _end_unlock;	1941	goto _end_unlock;
2005	default:	1942	if (!avail)
2006	break;	1943	continue; /* draining */
2007	}
2008	}	1944	}
2009	frames = size > avail ? avail : size;	1945	frames = size > avail ? avail : size;
2010	cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;	1946	cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;