1 files changed, 0 insertions, 75 deletions
diff --git a/crypto/async_tx/async_tx.c b/crypto/async_tx/async_tx.c
index dcbf1be149f3..8cfac182165d 100644
--- a/crypto/async_tx/async_tx.c
+++ b/crypto/async_tx/async_tx.c
@@ -72,81 +72,6 @@ void async_tx_issue_pending_all(void)
 }
 EXPORT_SYMBOL_GPL(async_tx_issue_pending_all);
-/* dma_wait_for_async_tx - spin wait for a transcation to complete
- * @tx: transaction to wait on
- */
-enum dma_status
-dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx)
-{
-        enum dma_status status;
-        struct dma_async_tx_descriptor *iter;
-        struct dma_async_tx_descriptor *parent;
-        if (!tx)
-                return DMA_SUCCESS;
-        /* poll through the dependency chain, return when tx is complete */
-        do {
-                iter = tx;
-                /* find the root of the unsubmitted dependency chain */
-                do {
-                        parent = iter->parent;
-                        if (!parent)
-                                break;
-                        else
-                                iter = parent;
-                } while (parent);
-                /* there is a small window for ->parent == NULL and
-                 * ->cookie == -EBUSY
-                 */
-                while (iter->cookie == -EBUSY)
-                        cpu_relax();
-                status = dma_sync_wait(iter->chan, iter->cookie);
-        } while (status == DMA_IN_PROGRESS || (iter != tx));
-        return status;
-}
-EXPORT_SYMBOL_GPL(dma_wait_for_async_tx);
-/* async_tx_run_dependencies - helper routine for dma drivers to process
- *      (start) dependent operations on their target channel
- * @tx: transaction with dependencies
- */
-void async_tx_run_dependencies(struct dma_async_tx_descriptor *tx)
-{
-        struct dma_async_tx_descriptor *dep = tx->next;
-        struct dma_async_tx_descriptor *dep_next;
-        struct dma_chan *chan;
-        if (!dep)
-                return;
-        chan = dep->chan;
-        /* keep submitting up until a channel switch is detected
-         * in that case we will be called again as a result of
-         * processing the interrupt from async_tx_channel_switch
-         */
-        for (; dep; dep = dep_next) {
-                spin_lock_bh(&dep->lock);
-                dep->parent = NULL;
-                dep_next = dep->next;
-                if (dep_next && dep_next->chan == chan)
-                        dep->next = NULL; /* ->next will be submitted */
-                else
-                        dep_next = NULL; /* submit current dep and terminate */
-                spin_unlock_bh(&dep->lock);
-                dep->tx_submit(dep);
-        }
-        chan->device->device_issue_pending(chan);
-}
-EXPORT_SYMBOL_GPL(async_tx_run_dependencies);
 static void
 free_dma_chan_ref(struct rcu_head *rcu)
 {

diff --git a/crypto/async_tx/async_tx.c b/crypto/async_tx/async_tx.c index dcbf1be149f3..8cfac182165d 100644 --- a/crypto/async_tx/async_tx.c +++ b/crypto/async_tx/async_tx.c
@@ -72,81 +72,6 @@ void async_tx_issue_pending_all(void)
72	}	72	}
73	EXPORT_SYMBOL_GPL(async_tx_issue_pending_all);	73	EXPORT_SYMBOL_GPL(async_tx_issue_pending_all);
74		74
75	/* dma_wait_for_async_tx - spin wait for a transcation to complete
76	* @tx: transaction to wait on
77	*/
78	enum dma_status
79	dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx)
80	{
81	enum dma_status status;
82	struct dma_async_tx_descriptor *iter;
83	struct dma_async_tx_descriptor *parent;
84
85	if (!tx)
86	return DMA_SUCCESS;
87
88	/* poll through the dependency chain, return when tx is complete */
89	do {
90	iter = tx;
91
92	/* find the root of the unsubmitted dependency chain */
93	do {
94	parent = iter->parent;
95	if (!parent)
96	break;
97	else
98	iter = parent;
99	} while (parent);
100
101	/* there is a small window for ->parent == NULL and
102	* ->cookie == -EBUSY
103	*/
104	while (iter->cookie == -EBUSY)
105	cpu_relax();
106
107	status = dma_sync_wait(iter->chan, iter->cookie);
108	} while (status == DMA_IN_PROGRESS \|\| (iter != tx));
109
110	return status;
111	}
112	EXPORT_SYMBOL_GPL(dma_wait_for_async_tx);
113
114	/* async_tx_run_dependencies - helper routine for dma drivers to process
115	* (start) dependent operations on their target channel
116	* @tx: transaction with dependencies
117	*/
118	void async_tx_run_dependencies(struct dma_async_tx_descriptor *tx)
119	{
120	struct dma_async_tx_descriptor *dep = tx->next;
121	struct dma_async_tx_descriptor *dep_next;
122	struct dma_chan *chan;
123
124	if (!dep)
125	return;
126
127	chan = dep->chan;
128
129	/* keep submitting up until a channel switch is detected
130	* in that case we will be called again as a result of
131	* processing the interrupt from async_tx_channel_switch
132	*/
133	for (; dep; dep = dep_next) {
134	spin_lock_bh(&dep->lock);
135	dep->parent = NULL;
136	dep_next = dep->next;
137	if (dep_next && dep_next->chan == chan)
138	dep->next = NULL; /* ->next will be submitted */
139	else
140	dep_next = NULL; /* submit current dep and terminate */
141	spin_unlock_bh(&dep->lock);
142
143	dep->tx_submit(dep);
144	}
145
146	chan->device->device_issue_pending(chan);
147	}
148	EXPORT_SYMBOL_GPL(async_tx_run_dependencies);
149
150	static void	75	static void
151	free_dma_chan_ref(struct rcu_head *rcu)	76	free_dma_chan_ref(struct rcu_head *rcu)
152	{	77	{