1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * virtio-snd: Virtio sound device 4 * Copyright (C) 2021 OpenSynergy GmbH 5 */ 6 #include <sound/pcm_params.h> 7 8 #include "virtio_card.h" 9 10 /** 11 * struct virtio_pcm_msg - VirtIO I/O message. 12 * @substream: VirtIO PCM substream. 13 * @xfer: Request header payload. 14 * @status: Response header payload. 15 * @length: Data length in bytes. 16 * @sgs: Payload scatter-gather table. 17 */ 18 struct 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[]; 24 }; 25 26 /** 27 * enum pcm_msg_sg_index - Index values for the virtio_pcm_msg->sgs field in 28 * an I/O message. 29 * @PCM_MSG_SG_XFER: Element containing a virtio_snd_pcm_xfer structure. 30 * @PCM_MSG_SG_STATUS: Element containing a virtio_snd_pcm_status structure. 31 * @PCM_MSG_SG_DATA: The first element containing a data buffer. 32 */ 33 enum pcm_msg_sg_index { 34 PCM_MSG_SG_XFER = 0, 35 PCM_MSG_SG_STATUS, 36 PCM_MSG_SG_DATA 37 }; 38 39 /** 40 * virtsnd_pcm_sg_num() - Count the number of sg-elements required to represent 41 * vmalloc'ed buffer. 42 * @data: Pointer to vmalloc'ed buffer. 43 * @length: Buffer size. 44 * 45 * Context: Any context. 46 * Return: Number of physically contiguous parts in the @data. 47 */ 48 static 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 * virtsnd_pcm_sg_from() - Build sg-list from vmalloc'ed buffer. 80 * @sgs: Preallocated sg-list to populate. 81 * @nsgs: The maximum number of elements in the @sgs. 82 * @data: Pointer to vmalloc'ed buffer. 83 * @length: Buffer size. 84 * 85 * Splits the buffer into physically contiguous parts and makes an sg-list of 86 * such parts. 87 * 88 * Context: Any context. 89 */ 90 static 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 * virtsnd_pcm_msg_alloc() - Allocate I/O messages. 122 * @vss: VirtIO PCM substream. 123 * @periods: Current number of periods. 124 * @period_bytes: Current period size in bytes. 125 * 126 * The function slices the buffer into @periods parts (each with the size of 127 * @period_bytes), and creates @periods corresponding I/O messages. 128 * 129 * Context: Any context that permits to sleep. 130 * Return: 0 on success, -ENOMEM on failure. 131 */ 132 int 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(struct_size(msg, sgs, sg_num + 2), GFP_KERNEL); 150 if (!msg) 151 return -ENOMEM; 152 153 msg->substream = vss; 154 sg_init_one(&msg->sgs[PCM_MSG_SG_XFER], &msg->xfer, 155 sizeof(msg->xfer)); 156 sg_init_one(&msg->sgs[PCM_MSG_SG_STATUS], &msg->status, 157 sizeof(msg->status)); 158 virtsnd_pcm_sg_from(&msg->sgs[PCM_MSG_SG_DATA], sg_num, data, 159 period_bytes); 160 161 vss->msgs[i] = msg; 162 } 163 164 return 0; 165 } 166 167 /** 168 * virtsnd_pcm_msg_free() - Free all allocated I/O messages. 169 * @vss: VirtIO PCM substream. 170 * 171 * Context: Any context. 172 */ 173 void virtsnd_pcm_msg_free(struct virtio_pcm_substream *vss) 174 { 175 unsigned int i; 176 177 for (i = 0; vss->msgs && i < vss->nmsgs; ++i) 178 kfree(vss->msgs[i]); 179 kfree(vss->msgs); 180 181 vss->msgs = NULL; 182 vss->nmsgs = 0; 183 } 184 185 /** 186 * virtsnd_pcm_msg_send() - Send asynchronous I/O messages. 187 * @vss: VirtIO PCM substream. 188 * @offset: starting position that has been updated 189 * @bytes: number of bytes that has been updated 190 * 191 * All messages are organized in an ordered circular list. Each time the 192 * function is called, all currently non-enqueued messages are added to the 193 * virtqueue. For this, the function uses offset and bytes to calculate the 194 * messages that need to be added. 195 * 196 * Context: Any context. Expects the tx/rx queue and the VirtIO substream 197 * spinlocks to be held by caller. 198 * Return: 0 on success, -errno on failure. 199 */ 200 int virtsnd_pcm_msg_send(struct virtio_pcm_substream *vss, unsigned long offset, 201 unsigned long bytes) 202 { 203 struct virtio_snd *snd = vss->snd; 204 struct virtio_device *vdev = snd->vdev; 205 struct virtqueue *vqueue = virtsnd_pcm_queue(vss)->vqueue; 206 unsigned long period_bytes = snd_pcm_lib_period_bytes(vss->substream); 207 unsigned long start, end, i; 208 unsigned int msg_count = vss->msg_count; 209 bool notify = false; 210 int rc; 211 212 start = offset / period_bytes; 213 end = (offset + bytes - 1) / period_bytes; 214 215 for (i = start; i <= end; i++) { 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 unsigned long n; 223 224 n = period_bytes - (offset % period_bytes); 225 if (n > bytes) 226 n = bytes; 227 228 msg->length += n; 229 if (msg->length == period_bytes) { 230 msg->xfer.stream_id = cpu_to_le32(vss->sid); 231 memset(&msg->status, 0, sizeof(msg->status)); 232 233 if (vss->direction == SNDRV_PCM_STREAM_PLAYBACK) 234 rc = virtqueue_add_sgs(vqueue, psgs, 2, 1, msg, 235 GFP_ATOMIC); 236 else 237 rc = virtqueue_add_sgs(vqueue, psgs, 1, 2, msg, 238 GFP_ATOMIC); 239 240 if (rc) { 241 dev_err(&vdev->dev, 242 "SID %u: failed to send I/O message\n", 243 vss->sid); 244 return rc; 245 } 246 247 vss->msg_count++; 248 } 249 250 offset = 0; 251 bytes -= n; 252 } 253 254 if (msg_count == vss->msg_count) 255 return 0; 256 257 if (!(vss->features & (1U << VIRTIO_SND_PCM_F_MSG_POLLING))) 258 notify = virtqueue_kick_prepare(vqueue); 259 260 if (notify) 261 virtqueue_notify(vqueue); 262 263 return 0; 264 } 265 266 /** 267 * virtsnd_pcm_msg_pending_num() - Returns the number of pending I/O messages. 268 * @vss: VirtIO substream. 269 * 270 * Context: Any context. 271 * Return: Number of messages. 272 */ 273 unsigned int virtsnd_pcm_msg_pending_num(struct virtio_pcm_substream *vss) 274 { 275 unsigned int num; 276 unsigned long flags; 277 278 spin_lock_irqsave(&vss->lock, flags); 279 num = vss->msg_count; 280 spin_unlock_irqrestore(&vss->lock, flags); 281 282 return num; 283 } 284 285 /** 286 * virtsnd_pcm_msg_complete() - Complete an I/O message. 287 * @msg: I/O message. 288 * @written_bytes: Number of bytes written to the message. 289 * 290 * Completion of the message means the elapsed period. If transmission is 291 * allowed, then each completed message is immediately placed back at the end 292 * of the queue. 293 * 294 * For the playback substream, @written_bytes is equal to sizeof(msg->status). 295 * 296 * For the capture substream, @written_bytes is equal to sizeof(msg->status) 297 * plus the number of captured bytes. 298 * 299 * Context: Interrupt context. Takes and releases the VirtIO substream spinlock. 300 */ 301 static void virtsnd_pcm_msg_complete(struct virtio_pcm_msg *msg, 302 size_t written_bytes) 303 { 304 struct virtio_pcm_substream *vss = msg->substream; 305 306 /* 307 * hw_ptr always indicates the buffer position of the first I/O message 308 * in the virtqueue. Therefore, on each completion of an I/O message, 309 * the hw_ptr value is unconditionally advanced. 310 */ 311 spin_lock(&vss->lock); 312 /* 313 * If the capture substream returned an incorrect status, then just 314 * increase the hw_ptr by the message size. 315 */ 316 if (vss->direction == SNDRV_PCM_STREAM_PLAYBACK || 317 written_bytes <= sizeof(msg->status)) 318 vss->hw_ptr += msg->length; 319 else 320 vss->hw_ptr += written_bytes - sizeof(msg->status); 321 322 if (vss->hw_ptr >= vss->buffer_bytes) 323 vss->hw_ptr -= vss->buffer_bytes; 324 325 msg->length = 0; 326 327 vss->xfer_xrun = false; 328 vss->msg_count--; 329 330 if (vss->xfer_enabled) { 331 struct snd_pcm_runtime *runtime = vss->substream->runtime; 332 333 runtime->delay = 334 bytes_to_frames(runtime, 335 le32_to_cpu(msg->status.latency_bytes)); 336 337 schedule_work(&vss->elapsed_period); 338 } else if (!vss->msg_count) { 339 wake_up_all(&vss->msg_empty); 340 } 341 spin_unlock(&vss->lock); 342 } 343 344 /** 345 * virtsnd_pcm_notify_cb() - Process all completed I/O messages. 346 * @queue: Underlying tx/rx virtqueue. 347 * 348 * Context: Interrupt context. Takes and releases the tx/rx queue spinlock. 349 */ 350 static inline void virtsnd_pcm_notify_cb(struct virtio_snd_queue *queue) 351 { 352 struct virtio_pcm_msg *msg; 353 u32 written_bytes; 354 unsigned long flags; 355 356 spin_lock_irqsave(&queue->lock, flags); 357 do { 358 virtqueue_disable_cb(queue->vqueue); 359 while ((msg = virtqueue_get_buf(queue->vqueue, &written_bytes))) 360 virtsnd_pcm_msg_complete(msg, written_bytes); 361 if (unlikely(virtqueue_is_broken(queue->vqueue))) 362 break; 363 } while (!virtqueue_enable_cb(queue->vqueue)); 364 spin_unlock_irqrestore(&queue->lock, flags); 365 } 366 367 /** 368 * virtsnd_pcm_tx_notify_cb() - Process all completed TX messages. 369 * @vqueue: Underlying tx virtqueue. 370 * 371 * Context: Interrupt context. 372 */ 373 void virtsnd_pcm_tx_notify_cb(struct virtqueue *vqueue) 374 { 375 struct virtio_snd *snd = vqueue->vdev->priv; 376 377 virtsnd_pcm_notify_cb(virtsnd_tx_queue(snd)); 378 } 379 380 /** 381 * virtsnd_pcm_rx_notify_cb() - Process all completed RX messages. 382 * @vqueue: Underlying rx virtqueue. 383 * 384 * Context: Interrupt context. 385 */ 386 void virtsnd_pcm_rx_notify_cb(struct virtqueue *vqueue) 387 { 388 struct virtio_snd *snd = vqueue->vdev->priv; 389 390 virtsnd_pcm_notify_cb(virtsnd_rx_queue(snd)); 391 } 392 393 /** 394 * virtsnd_pcm_ctl_msg_alloc() - Allocate and initialize the PCM device control 395 * message for the specified substream. 396 * @vss: VirtIO PCM substream. 397 * @command: Control request code (VIRTIO_SND_R_PCM_XXX). 398 * @gfp: Kernel flags for memory allocation. 399 * 400 * Context: Any context. May sleep if @gfp flags permit. 401 * Return: Allocated message on success, NULL on failure. 402 */ 403 struct virtio_snd_msg * 404 virtsnd_pcm_ctl_msg_alloc(struct virtio_pcm_substream *vss, 405 unsigned int command, gfp_t gfp) 406 { 407 size_t request_size = sizeof(struct virtio_snd_pcm_hdr); 408 size_t response_size = sizeof(struct virtio_snd_hdr); 409 struct virtio_snd_msg *msg; 410 411 switch (command) { 412 case VIRTIO_SND_R_PCM_SET_PARAMS: 413 request_size = sizeof(struct virtio_snd_pcm_set_params); 414 break; 415 } 416 417 msg = virtsnd_ctl_msg_alloc(request_size, response_size, gfp); 418 if (msg) { 419 struct virtio_snd_pcm_hdr *hdr = virtsnd_ctl_msg_request(msg); 420 421 hdr->hdr.code = cpu_to_le32(command); 422 hdr->stream_id = cpu_to_le32(vss->sid); 423 } 424 425 return msg; 426 } 427