Commit | Line | Data |
---|---|---|
a33c1ec5 JY |
1 | /* |
2 | * Intel SST generic IPC Support | |
3 | * | |
4 | * Copyright (C) 2015, Intel Corporation. All rights reserved. | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License version | |
8 | * 2 as published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | */ | |
16 | ||
17 | #include <linux/types.h> | |
18 | #include <linux/kernel.h> | |
19 | #include <linux/list.h> | |
20 | #include <linux/wait.h> | |
21 | #include <linux/module.h> | |
22 | #include <linux/spinlock.h> | |
23 | #include <linux/device.h> | |
24 | #include <linux/slab.h> | |
25 | #include <linux/workqueue.h> | |
26 | #include <linux/sched.h> | |
27 | #include <linux/delay.h> | |
28 | #include <linux/platform_device.h> | |
a33c1ec5 JY |
29 | #include <sound/asound.h> |
30 | ||
31 | #include "sst-dsp.h" | |
32 | #include "sst-dsp-priv.h" | |
33 | #include "sst-ipc.h" | |
34 | ||
35 | /* IPC message timeout (msecs) */ | |
36 | #define IPC_TIMEOUT_MSECS 300 | |
37 | ||
38 | #define IPC_EMPTY_LIST_SIZE 8 | |
39 | ||
40 | /* locks held by caller */ | |
41 | static struct ipc_message *msg_get_empty(struct sst_generic_ipc *ipc) | |
42 | { | |
43 | struct ipc_message *msg = NULL; | |
44 | ||
45 | if (!list_empty(&ipc->empty_list)) { | |
46 | msg = list_first_entry(&ipc->empty_list, struct ipc_message, | |
47 | list); | |
48 | list_del(&msg->list); | |
49 | } | |
50 | ||
51 | return msg; | |
52 | } | |
53 | ||
54 | static int tx_wait_done(struct sst_generic_ipc *ipc, | |
55 | struct ipc_message *msg, void *rx_data) | |
56 | { | |
57 | unsigned long flags; | |
58 | int ret; | |
59 | ||
60 | /* wait for DSP completion (in all cases atm inc pending) */ | |
61 | ret = wait_event_timeout(msg->waitq, msg->complete, | |
62 | msecs_to_jiffies(IPC_TIMEOUT_MSECS)); | |
63 | ||
64 | spin_lock_irqsave(&ipc->dsp->spinlock, flags); | |
65 | if (ret == 0) { | |
66 | if (ipc->ops.shim_dbg != NULL) | |
67 | ipc->ops.shim_dbg(ipc, "message timeout"); | |
68 | ||
69 | list_del(&msg->list); | |
70 | ret = -ETIMEDOUT; | |
71 | } else { | |
72 | ||
73 | /* copy the data returned from DSP */ | |
74 | if (msg->rx_size) | |
75 | memcpy(rx_data, msg->rx_data, msg->rx_size); | |
76 | ret = msg->errno; | |
77 | } | |
78 | ||
79 | list_add_tail(&msg->list, &ipc->empty_list); | |
80 | spin_unlock_irqrestore(&ipc->dsp->spinlock, flags); | |
81 | return ret; | |
82 | } | |
83 | ||
84 | static int ipc_tx_message(struct sst_generic_ipc *ipc, u64 header, | |
85 | void *tx_data, size_t tx_bytes, void *rx_data, | |
86 | size_t rx_bytes, int wait) | |
87 | { | |
88 | struct ipc_message *msg; | |
89 | unsigned long flags; | |
90 | ||
91 | spin_lock_irqsave(&ipc->dsp->spinlock, flags); | |
92 | ||
93 | msg = msg_get_empty(ipc); | |
94 | if (msg == NULL) { | |
95 | spin_unlock_irqrestore(&ipc->dsp->spinlock, flags); | |
96 | return -EBUSY; | |
97 | } | |
98 | ||
99 | msg->header = header; | |
100 | msg->tx_size = tx_bytes; | |
101 | msg->rx_size = rx_bytes; | |
102 | msg->wait = wait; | |
103 | msg->errno = 0; | |
104 | msg->pending = false; | |
105 | msg->complete = false; | |
106 | ||
107 | if ((tx_bytes) && (ipc->ops.tx_data_copy != NULL)) | |
108 | ipc->ops.tx_data_copy(msg, tx_data, tx_bytes); | |
109 | ||
110 | list_add_tail(&msg->list, &ipc->tx_list); | |
786e1c37 | 111 | schedule_work(&ipc->kwork); |
a33c1ec5 JY |
112 | spin_unlock_irqrestore(&ipc->dsp->spinlock, flags); |
113 | ||
a33c1ec5 JY |
114 | if (wait) |
115 | return tx_wait_done(ipc, msg, rx_data); | |
116 | else | |
117 | return 0; | |
118 | } | |
119 | ||
120 | static int msg_empty_list_init(struct sst_generic_ipc *ipc) | |
121 | { | |
122 | int i; | |
123 | ||
6396bb22 KC |
124 | ipc->msg = kcalloc(IPC_EMPTY_LIST_SIZE, sizeof(struct ipc_message), |
125 | GFP_KERNEL); | |
a33c1ec5 JY |
126 | if (ipc->msg == NULL) |
127 | return -ENOMEM; | |
128 | ||
129 | for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) { | |
859c34bd SP |
130 | ipc->msg[i].tx_data = kzalloc(ipc->tx_data_max_size, GFP_KERNEL); |
131 | if (ipc->msg[i].tx_data == NULL) | |
132 | goto free_mem; | |
133 | ||
134 | ipc->msg[i].rx_data = kzalloc(ipc->rx_data_max_size, GFP_KERNEL); | |
135 | if (ipc->msg[i].rx_data == NULL) { | |
136 | kfree(ipc->msg[i].tx_data); | |
137 | goto free_mem; | |
138 | } | |
139 | ||
a33c1ec5 JY |
140 | init_waitqueue_head(&ipc->msg[i].waitq); |
141 | list_add(&ipc->msg[i].list, &ipc->empty_list); | |
142 | } | |
143 | ||
144 | return 0; | |
859c34bd SP |
145 | |
146 | free_mem: | |
147 | while (i > 0) { | |
148 | kfree(ipc->msg[i-1].tx_data); | |
149 | kfree(ipc->msg[i-1].rx_data); | |
150 | --i; | |
151 | } | |
152 | kfree(ipc->msg); | |
153 | ||
154 | return -ENOMEM; | |
a33c1ec5 JY |
155 | } |
156 | ||
786e1c37 | 157 | static void ipc_tx_msgs(struct work_struct *work) |
a33c1ec5 JY |
158 | { |
159 | struct sst_generic_ipc *ipc = | |
160 | container_of(work, struct sst_generic_ipc, kwork); | |
161 | struct ipc_message *msg; | |
a33c1ec5 | 162 | |
786e1c37 | 163 | spin_lock_irq(&ipc->dsp->spinlock); |
a33c1ec5 | 164 | |
786e1c37 TI |
165 | while (!list_empty(&ipc->tx_list) && !ipc->pending) { |
166 | /* if the DSP is busy, we will TX messages after IRQ. | |
167 | * also postpone if we are in the middle of processing | |
168 | * completion irq | |
169 | */ | |
170 | if (ipc->ops.is_dsp_busy && ipc->ops.is_dsp_busy(ipc->dsp)) { | |
171 | dev_dbg(ipc->dev, "ipc_tx_msgs dsp busy\n"); | |
172 | break; | |
173 | } | |
a33c1ec5 | 174 | |
786e1c37 TI |
175 | msg = list_first_entry(&ipc->tx_list, struct ipc_message, list); |
176 | list_move(&msg->list, &ipc->rx_list); | |
a33c1ec5 | 177 | |
786e1c37 TI |
178 | if (ipc->ops.tx_msg != NULL) |
179 | ipc->ops.tx_msg(ipc, msg); | |
180 | } | |
a33c1ec5 | 181 | |
786e1c37 | 182 | spin_unlock_irq(&ipc->dsp->spinlock); |
a33c1ec5 JY |
183 | } |
184 | ||
185 | int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc, u64 header, | |
186 | void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes) | |
187 | { | |
f999d1fd VK |
188 | int ret; |
189 | ||
190 | /* | |
191 | * DSP maybe in lower power active state, so | |
192 | * check if the DSP supports DSP lp On method | |
193 | * if so invoke that before sending IPC | |
194 | */ | |
195 | if (ipc->ops.check_dsp_lp_on) | |
196 | if (ipc->ops.check_dsp_lp_on(ipc->dsp, true)) | |
197 | return -EIO; | |
198 | ||
199 | ret = ipc_tx_message(ipc, header, tx_data, tx_bytes, | |
a33c1ec5 | 200 | rx_data, rx_bytes, 1); |
f999d1fd VK |
201 | |
202 | if (ipc->ops.check_dsp_lp_on) | |
203 | if (ipc->ops.check_dsp_lp_on(ipc->dsp, false)) | |
204 | return -EIO; | |
205 | ||
206 | return ret; | |
a33c1ec5 JY |
207 | } |
208 | EXPORT_SYMBOL_GPL(sst_ipc_tx_message_wait); | |
209 | ||
210 | int sst_ipc_tx_message_nowait(struct sst_generic_ipc *ipc, u64 header, | |
211 | void *tx_data, size_t tx_bytes) | |
212 | { | |
213 | return ipc_tx_message(ipc, header, tx_data, tx_bytes, | |
214 | NULL, 0, 0); | |
215 | } | |
216 | EXPORT_SYMBOL_GPL(sst_ipc_tx_message_nowait); | |
217 | ||
80a0df18 VK |
218 | int sst_ipc_tx_message_nopm(struct sst_generic_ipc *ipc, u64 header, |
219 | void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes) | |
220 | { | |
221 | return ipc_tx_message(ipc, header, tx_data, tx_bytes, | |
222 | rx_data, rx_bytes, 1); | |
223 | } | |
224 | EXPORT_SYMBOL_GPL(sst_ipc_tx_message_nopm); | |
225 | ||
a33c1ec5 JY |
226 | struct ipc_message *sst_ipc_reply_find_msg(struct sst_generic_ipc *ipc, |
227 | u64 header) | |
228 | { | |
229 | struct ipc_message *msg; | |
230 | u64 mask; | |
231 | ||
232 | if (ipc->ops.reply_msg_match != NULL) | |
233 | header = ipc->ops.reply_msg_match(header, &mask); | |
234 | ||
235 | if (list_empty(&ipc->rx_list)) { | |
236 | dev_err(ipc->dev, "error: rx list empty but received 0x%llx\n", | |
237 | header); | |
238 | return NULL; | |
239 | } | |
240 | ||
241 | list_for_each_entry(msg, &ipc->rx_list, list) { | |
242 | if ((msg->header & mask) == header) | |
243 | return msg; | |
244 | } | |
245 | ||
246 | return NULL; | |
247 | } | |
248 | EXPORT_SYMBOL_GPL(sst_ipc_reply_find_msg); | |
249 | ||
250 | /* locks held by caller */ | |
251 | void sst_ipc_tx_msg_reply_complete(struct sst_generic_ipc *ipc, | |
252 | struct ipc_message *msg) | |
253 | { | |
254 | msg->complete = true; | |
255 | ||
256 | if (!msg->wait) | |
257 | list_add_tail(&msg->list, &ipc->empty_list); | |
258 | else | |
259 | wake_up(&msg->waitq); | |
260 | } | |
261 | EXPORT_SYMBOL_GPL(sst_ipc_tx_msg_reply_complete); | |
262 | ||
263 | void sst_ipc_drop_all(struct sst_generic_ipc *ipc) | |
264 | { | |
265 | struct ipc_message *msg, *tmp; | |
266 | unsigned long flags; | |
267 | int tx_drop_cnt = 0, rx_drop_cnt = 0; | |
268 | ||
269 | /* drop all TX and Rx messages before we stall + reset DSP */ | |
270 | spin_lock_irqsave(&ipc->dsp->spinlock, flags); | |
271 | ||
272 | list_for_each_entry_safe(msg, tmp, &ipc->tx_list, list) { | |
273 | list_move(&msg->list, &ipc->empty_list); | |
274 | tx_drop_cnt++; | |
275 | } | |
276 | ||
277 | list_for_each_entry_safe(msg, tmp, &ipc->rx_list, list) { | |
278 | list_move(&msg->list, &ipc->empty_list); | |
279 | rx_drop_cnt++; | |
280 | } | |
281 | ||
282 | spin_unlock_irqrestore(&ipc->dsp->spinlock, flags); | |
283 | ||
284 | if (tx_drop_cnt || rx_drop_cnt) | |
285 | dev_err(ipc->dev, "dropped IPC msg RX=%d, TX=%d\n", | |
286 | tx_drop_cnt, rx_drop_cnt); | |
287 | } | |
288 | EXPORT_SYMBOL_GPL(sst_ipc_drop_all); | |
289 | ||
290 | int sst_ipc_init(struct sst_generic_ipc *ipc) | |
291 | { | |
292 | int ret; | |
293 | ||
294 | INIT_LIST_HEAD(&ipc->tx_list); | |
295 | INIT_LIST_HEAD(&ipc->rx_list); | |
296 | INIT_LIST_HEAD(&ipc->empty_list); | |
297 | init_waitqueue_head(&ipc->wait_txq); | |
298 | ||
299 | ret = msg_empty_list_init(ipc); | |
300 | if (ret < 0) | |
301 | return -ENOMEM; | |
302 | ||
786e1c37 | 303 | INIT_WORK(&ipc->kwork, ipc_tx_msgs); |
a33c1ec5 JY |
304 | return 0; |
305 | } | |
306 | EXPORT_SYMBOL_GPL(sst_ipc_init); | |
307 | ||
308 | void sst_ipc_fini(struct sst_generic_ipc *ipc) | |
309 | { | |
859c34bd SP |
310 | int i; |
311 | ||
786e1c37 | 312 | cancel_work_sync(&ipc->kwork); |
a33c1ec5 | 313 | |
859c34bd SP |
314 | if (ipc->msg) { |
315 | for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) { | |
316 | kfree(ipc->msg[i].tx_data); | |
317 | kfree(ipc->msg[i].rx_data); | |
318 | } | |
a33c1ec5 | 319 | kfree(ipc->msg); |
859c34bd | 320 | } |
a33c1ec5 JY |
321 | } |
322 | EXPORT_SYMBOL_GPL(sst_ipc_fini); | |
323 | ||
324 | /* Module information */ | |
325 | MODULE_AUTHOR("Jin Yao"); | |
326 | MODULE_DESCRIPTION("Intel SST IPC generic"); | |
327 | MODULE_LICENSE("GPL v2"); |