1
2
3
4
5
6#include <sound/pcm_params.h>
7
8#include "virtio_card.h"
9
10
11
12
13
14
15
16
17
18struct virtio_pcm_msg {
19 struct virtio_pcm_substream *substream;
20 struct virtio_snd_pcm_xfer xfer;
21 struct virtio_snd_pcm_status status;
22 size_t length;
23 struct scatterlist sgs[0];
24};
25
26
27
28
29
30
31
32
33enum pcm_msg_sg_index {
34 PCM_MSG_SG_XFER = 0,
35 PCM_MSG_SG_STATUS,
36 PCM_MSG_SG_DATA
37};
38
39
40
41
42
43
44
45
46
47
48static int virtsnd_pcm_sg_num(u8 *data, unsigned int length)
49{
50 phys_addr_t sg_address;
51 unsigned int sg_length;
52 int num = 0;
53
54 while (length) {
55 struct page *pg = vmalloc_to_page(data);
56 phys_addr_t pg_address = page_to_phys(pg);
57 size_t pg_length;
58
59 pg_length = PAGE_SIZE - offset_in_page(data);
60 if (pg_length > length)
61 pg_length = length;
62
63 if (!num || sg_address + sg_length != pg_address) {
64 sg_address = pg_address;
65 sg_length = pg_length;
66 num++;
67 } else {
68 sg_length += pg_length;
69 }
70
71 data += pg_length;
72 length -= pg_length;
73 }
74
75 return num;
76}
77
78
79
80
81
82
83
84
85
86
87
88
89
90static void virtsnd_pcm_sg_from(struct scatterlist *sgs, int nsgs, u8 *data,
91 unsigned int length)
92{
93 int idx = -1;
94
95 while (length) {
96 struct page *pg = vmalloc_to_page(data);
97 size_t pg_length;
98
99 pg_length = PAGE_SIZE - offset_in_page(data);
100 if (pg_length > length)
101 pg_length = length;
102
103 if (idx == -1 ||
104 sg_phys(&sgs[idx]) + sgs[idx].length != page_to_phys(pg)) {
105 if (idx + 1 == nsgs)
106 break;
107 sg_set_page(&sgs[++idx], pg, pg_length,
108 offset_in_page(data));
109 } else {
110 sgs[idx].length += pg_length;
111 }
112
113 data += pg_length;
114 length -= pg_length;
115 }
116
117 sg_mark_end(&sgs[idx]);
118}
119
120
121
122
123
124
125
126
127
128
129
130
131
132int virtsnd_pcm_msg_alloc(struct virtio_pcm_substream *vss,
133 unsigned int periods, unsigned int period_bytes)
134{
135 struct snd_pcm_runtime *runtime = vss->substream->runtime;
136 unsigned int i;
137
138 vss->msgs = kcalloc(periods, sizeof(*vss->msgs), GFP_KERNEL);
139 if (!vss->msgs)
140 return -ENOMEM;
141
142 vss->nmsgs = periods;
143
144 for (i = 0; i < periods; ++i) {
145 u8 *data = runtime->dma_area + period_bytes * i;
146 int sg_num = virtsnd_pcm_sg_num(data, period_bytes);
147 struct virtio_pcm_msg *msg;
148
149 msg = kzalloc(sizeof(*msg) + sizeof(*msg->sgs) * (sg_num + 2),
150 GFP_KERNEL);
151 if (!msg)
152 return -ENOMEM;
153
154 msg->substream = vss;
155 sg_init_one(&msg->sgs[PCM_MSG_SG_XFER], &msg->xfer,
156 sizeof(msg->xfer));
157 sg_init_one(&msg->sgs[PCM_MSG_SG_STATUS], &msg->status,
158 sizeof(msg->status));
159 msg->length = period_bytes;
160 virtsnd_pcm_sg_from(&msg->sgs[PCM_MSG_SG_DATA], sg_num, data,
161 period_bytes);
162
163 vss->msgs[i] = msg;
164 }
165
166 return 0;
167}
168
169
170
171
172
173
174
175void virtsnd_pcm_msg_free(struct virtio_pcm_substream *vss)
176{
177 unsigned int i;
178
179 for (i = 0; vss->msgs && i < vss->nmsgs; ++i)
180 kfree(vss->msgs[i]);
181 kfree(vss->msgs);
182
183 vss->msgs = NULL;
184 vss->nmsgs = 0;
185}
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202int virtsnd_pcm_msg_send(struct virtio_pcm_substream *vss)
203{
204 struct snd_pcm_runtime *runtime = vss->substream->runtime;
205 struct virtio_snd *snd = vss->snd;
206 struct virtio_device *vdev = snd->vdev;
207 struct virtqueue *vqueue = virtsnd_pcm_queue(vss)->vqueue;
208 int i;
209 int n;
210 bool notify = false;
211
212 i = (vss->msg_last_enqueued + 1) % runtime->periods;
213 n = runtime->periods - vss->msg_count;
214
215 for (; n; --n, i = (i + 1) % runtime->periods) {
216 struct virtio_pcm_msg *msg = vss->msgs[i];
217 struct scatterlist *psgs[] = {
218 &msg->sgs[PCM_MSG_SG_XFER],
219 &msg->sgs[PCM_MSG_SG_DATA],
220 &msg->sgs[PCM_MSG_SG_STATUS]
221 };
222 int rc;
223
224 msg->xfer.stream_id = cpu_to_le32(vss->sid);
225 memset(&msg->status, 0, sizeof(msg->status));
226
227 if (vss->direction == SNDRV_PCM_STREAM_PLAYBACK)
228 rc = virtqueue_add_sgs(vqueue, psgs, 2, 1, msg,
229 GFP_ATOMIC);
230 else
231 rc = virtqueue_add_sgs(vqueue, psgs, 1, 2, msg,
232 GFP_ATOMIC);
233
234 if (rc) {
235 dev_err(&vdev->dev,
236 "SID %u: failed to send I/O message\n",
237 vss->sid);
238 return rc;
239 }
240
241 vss->msg_last_enqueued = i;
242 vss->msg_count++;
243 }
244
245 if (!(vss->features & (1U << VIRTIO_SND_PCM_F_MSG_POLLING)))
246 notify = virtqueue_kick_prepare(vqueue);
247
248 if (notify)
249 virtqueue_notify(vqueue);
250
251 return 0;
252}
253
254
255
256
257
258
259
260
261unsigned int virtsnd_pcm_msg_pending_num(struct virtio_pcm_substream *vss)
262{
263 unsigned int num;
264 unsigned long flags;
265
266 spin_lock_irqsave(&vss->lock, flags);
267 num = vss->msg_count;
268 spin_unlock_irqrestore(&vss->lock, flags);
269
270 return num;
271}
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289static void virtsnd_pcm_msg_complete(struct virtio_pcm_msg *msg,
290 size_t written_bytes)
291{
292 struct virtio_pcm_substream *vss = msg->substream;
293
294
295
296
297
298
299 spin_lock(&vss->lock);
300
301
302
303
304 if (vss->direction == SNDRV_PCM_STREAM_PLAYBACK ||
305 written_bytes <= sizeof(msg->status))
306 vss->hw_ptr += msg->length;
307 else
308 vss->hw_ptr += written_bytes - sizeof(msg->status);
309
310 if (vss->hw_ptr >= vss->buffer_bytes)
311 vss->hw_ptr -= vss->buffer_bytes;
312
313 vss->xfer_xrun = false;
314 vss->msg_count--;
315
316 if (vss->xfer_enabled) {
317 struct snd_pcm_runtime *runtime = vss->substream->runtime;
318
319 runtime->delay =
320 bytes_to_frames(runtime,
321 le32_to_cpu(msg->status.latency_bytes));
322
323 schedule_work(&vss->elapsed_period);
324
325 virtsnd_pcm_msg_send(vss);
326 } else if (!vss->msg_count) {
327 wake_up_all(&vss->msg_empty);
328 }
329 spin_unlock(&vss->lock);
330}
331
332
333
334
335
336
337
338static inline void virtsnd_pcm_notify_cb(struct virtio_snd_queue *queue)
339{
340 struct virtio_pcm_msg *msg;
341 u32 written_bytes;
342 unsigned long flags;
343
344 spin_lock_irqsave(&queue->lock, flags);
345 do {
346 virtqueue_disable_cb(queue->vqueue);
347 while ((msg = virtqueue_get_buf(queue->vqueue, &written_bytes)))
348 virtsnd_pcm_msg_complete(msg, written_bytes);
349 if (unlikely(virtqueue_is_broken(queue->vqueue)))
350 break;
351 } while (!virtqueue_enable_cb(queue->vqueue));
352 spin_unlock_irqrestore(&queue->lock, flags);
353}
354
355
356
357
358
359
360
361void virtsnd_pcm_tx_notify_cb(struct virtqueue *vqueue)
362{
363 struct virtio_snd *snd = vqueue->vdev->priv;
364
365 virtsnd_pcm_notify_cb(virtsnd_tx_queue(snd));
366}
367
368
369
370
371
372
373
374void virtsnd_pcm_rx_notify_cb(struct virtqueue *vqueue)
375{
376 struct virtio_snd *snd = vqueue->vdev->priv;
377
378 virtsnd_pcm_notify_cb(virtsnd_rx_queue(snd));
379}
380
381
382
383
384
385
386
387
388
389
390
391struct virtio_snd_msg *
392virtsnd_pcm_ctl_msg_alloc(struct virtio_pcm_substream *vss,
393 unsigned int command, gfp_t gfp)
394{
395 size_t request_size = sizeof(struct virtio_snd_pcm_hdr);
396 size_t response_size = sizeof(struct virtio_snd_hdr);
397 struct virtio_snd_msg *msg;
398
399 switch (command) {
400 case VIRTIO_SND_R_PCM_SET_PARAMS:
401 request_size = sizeof(struct virtio_snd_pcm_set_params);
402 break;
403 }
404
405 msg = virtsnd_ctl_msg_alloc(request_size, response_size, gfp);
406 if (msg) {
407 struct virtio_snd_pcm_hdr *hdr = virtsnd_ctl_msg_request(msg);
408
409 hdr->hdr.code = cpu_to_le32(command);
410 hdr->stream_id = cpu_to_le32(vss->sid);
411 }
412
413 return msg;
414}
415