]>
Commit | Line | Data |
---|---|---|
9d45e514 AY |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | |
3 | * virtio-snd: Virtio sound device | |
4 | * Copyright (C) 2021 OpenSynergy GmbH | |
5 | */ | |
6 | #include <linux/moduleparam.h> | |
7 | #include <linux/virtio_config.h> | |
8 | ||
9 | #include "virtio_card.h" | |
10 | ||
11 | /** | |
12 | * struct virtio_snd_msg - Control message. | |
13 | * @sg_request: Scattergather list containing a device request (header). | |
14 | * @sg_response: Scattergather list containing a device response (status). | |
15 | * @list: Pending message list entry. | |
16 | * @notify: Request completed notification. | |
17 | * @ref_count: Reference count used to manage a message lifetime. | |
18 | */ | |
19 | struct virtio_snd_msg { | |
20 | struct scatterlist sg_request; | |
21 | struct scatterlist sg_response; | |
22 | struct list_head list; | |
23 | struct completion notify; | |
24 | refcount_t ref_count; | |
25 | }; | |
26 | ||
27 | /** | |
28 | * virtsnd_ctl_msg_ref() - Increment reference counter for the message. | |
29 | * @msg: Control message. | |
30 | * | |
31 | * Context: Any context. | |
32 | */ | |
33 | void virtsnd_ctl_msg_ref(struct virtio_snd_msg *msg) | |
34 | { | |
35 | refcount_inc(&msg->ref_count); | |
36 | } | |
37 | ||
38 | /** | |
39 | * virtsnd_ctl_msg_unref() - Decrement reference counter for the message. | |
40 | * @msg: Control message. | |
41 | * | |
42 | * The message will be freed when the ref_count value is 0. | |
43 | * | |
44 | * Context: Any context. | |
45 | */ | |
46 | void virtsnd_ctl_msg_unref(struct virtio_snd_msg *msg) | |
47 | { | |
48 | if (refcount_dec_and_test(&msg->ref_count)) | |
49 | kfree(msg); | |
50 | } | |
51 | ||
52 | /** | |
53 | * virtsnd_ctl_msg_request() - Get a pointer to the request header. | |
54 | * @msg: Control message. | |
55 | * | |
56 | * Context: Any context. | |
57 | */ | |
58 | void *virtsnd_ctl_msg_request(struct virtio_snd_msg *msg) | |
59 | { | |
60 | return sg_virt(&msg->sg_request); | |
61 | } | |
62 | ||
63 | /** | |
e8614313 | 64 | * virtsnd_ctl_msg_response() - Get a pointer to the response header. |
9d45e514 AY |
65 | * @msg: Control message. |
66 | * | |
67 | * Context: Any context. | |
68 | */ | |
69 | void *virtsnd_ctl_msg_response(struct virtio_snd_msg *msg) | |
70 | { | |
71 | return sg_virt(&msg->sg_response); | |
72 | } | |
73 | ||
74 | /** | |
75 | * virtsnd_ctl_msg_alloc() - Allocate and initialize a control message. | |
76 | * @request_size: Size of request header. | |
77 | * @response_size: Size of response header. | |
78 | * @gfp: Kernel flags for memory allocation. | |
79 | * | |
80 | * The message will be automatically freed when the ref_count value is 0. | |
81 | * | |
82 | * Context: Any context. May sleep if @gfp flags permit. | |
83 | * Return: Allocated message on success, NULL on failure. | |
84 | */ | |
85 | struct virtio_snd_msg *virtsnd_ctl_msg_alloc(size_t request_size, | |
86 | size_t response_size, gfp_t gfp) | |
87 | { | |
88 | struct virtio_snd_msg *msg; | |
89 | ||
90 | if (!request_size || !response_size) | |
91 | return NULL; | |
92 | ||
93 | msg = kzalloc(sizeof(*msg) + request_size + response_size, gfp); | |
94 | if (!msg) | |
95 | return NULL; | |
96 | ||
97 | sg_init_one(&msg->sg_request, (u8 *)msg + sizeof(*msg), request_size); | |
98 | sg_init_one(&msg->sg_response, (u8 *)msg + sizeof(*msg) + request_size, | |
99 | response_size); | |
100 | ||
101 | INIT_LIST_HEAD(&msg->list); | |
102 | init_completion(&msg->notify); | |
103 | /* This reference is dropped in virtsnd_ctl_msg_complete(). */ | |
104 | refcount_set(&msg->ref_count, 1); | |
105 | ||
106 | return msg; | |
107 | } | |
108 | ||
109 | /** | |
110 | * virtsnd_ctl_msg_send() - Send a control message. | |
111 | * @snd: VirtIO sound device. | |
112 | * @msg: Control message. | |
113 | * @out_sgs: Additional sg-list to attach to the request header (may be NULL). | |
114 | * @in_sgs: Additional sg-list to attach to the response header (may be NULL). | |
115 | * @nowait: Flag indicating whether to wait for completion. | |
116 | * | |
117 | * Context: Any context. Takes and releases the control queue spinlock. | |
118 | * May sleep if @nowait is false. | |
119 | * Return: 0 on success, -errno on failure. | |
120 | */ | |
121 | int virtsnd_ctl_msg_send(struct virtio_snd *snd, struct virtio_snd_msg *msg, | |
122 | struct scatterlist *out_sgs, | |
123 | struct scatterlist *in_sgs, bool nowait) | |
124 | { | |
125 | struct virtio_device *vdev = snd->vdev; | |
126 | struct virtio_snd_queue *queue = virtsnd_control_queue(snd); | |
127 | unsigned int js = msecs_to_jiffies(virtsnd_msg_timeout_ms); | |
128 | struct virtio_snd_hdr *request = virtsnd_ctl_msg_request(msg); | |
129 | struct virtio_snd_hdr *response = virtsnd_ctl_msg_response(msg); | |
130 | unsigned int nouts = 0; | |
131 | unsigned int nins = 0; | |
132 | struct scatterlist *psgs[4]; | |
133 | bool notify = false; | |
134 | unsigned long flags; | |
135 | int rc; | |
136 | ||
137 | virtsnd_ctl_msg_ref(msg); | |
138 | ||
139 | /* Set the default status in case the message was canceled. */ | |
140 | response->code = cpu_to_le32(VIRTIO_SND_S_IO_ERR); | |
141 | ||
142 | psgs[nouts++] = &msg->sg_request; | |
143 | if (out_sgs) | |
144 | psgs[nouts++] = out_sgs; | |
145 | ||
146 | psgs[nouts + nins++] = &msg->sg_response; | |
147 | if (in_sgs) | |
148 | psgs[nouts + nins++] = in_sgs; | |
149 | ||
150 | spin_lock_irqsave(&queue->lock, flags); | |
151 | rc = virtqueue_add_sgs(queue->vqueue, psgs, nouts, nins, msg, | |
152 | GFP_ATOMIC); | |
153 | if (!rc) { | |
154 | notify = virtqueue_kick_prepare(queue->vqueue); | |
155 | ||
156 | list_add_tail(&msg->list, &snd->ctl_msgs); | |
157 | } | |
158 | spin_unlock_irqrestore(&queue->lock, flags); | |
159 | ||
160 | if (rc) { | |
161 | dev_err(&vdev->dev, "failed to send control message (0x%08x)\n", | |
162 | le32_to_cpu(request->code)); | |
163 | ||
164 | /* | |
165 | * Since in this case virtsnd_ctl_msg_complete() will not be | |
166 | * called, it is necessary to decrement the reference count. | |
167 | */ | |
168 | virtsnd_ctl_msg_unref(msg); | |
169 | ||
170 | goto on_exit; | |
171 | } | |
172 | ||
173 | if (notify) | |
174 | virtqueue_notify(queue->vqueue); | |
175 | ||
176 | if (nowait) | |
177 | goto on_exit; | |
178 | ||
179 | rc = wait_for_completion_interruptible_timeout(&msg->notify, js); | |
180 | if (rc <= 0) { | |
181 | if (!rc) { | |
182 | dev_err(&vdev->dev, | |
183 | "control message (0x%08x) timeout\n", | |
184 | le32_to_cpu(request->code)); | |
185 | rc = -ETIMEDOUT; | |
186 | } | |
187 | ||
188 | goto on_exit; | |
189 | } | |
190 | ||
191 | switch (le32_to_cpu(response->code)) { | |
192 | case VIRTIO_SND_S_OK: | |
193 | rc = 0; | |
194 | break; | |
195 | case VIRTIO_SND_S_NOT_SUPP: | |
196 | rc = -EOPNOTSUPP; | |
197 | break; | |
198 | case VIRTIO_SND_S_IO_ERR: | |
199 | rc = -EIO; | |
200 | break; | |
201 | default: | |
202 | rc = -EINVAL; | |
203 | break; | |
204 | } | |
205 | ||
206 | on_exit: | |
207 | virtsnd_ctl_msg_unref(msg); | |
208 | ||
209 | return rc; | |
210 | } | |
211 | ||
212 | /** | |
213 | * virtsnd_ctl_msg_complete() - Complete a control message. | |
214 | * @msg: Control message. | |
215 | * | |
216 | * Context: Any context. Expects the control queue spinlock to be held by | |
217 | * caller. | |
218 | */ | |
219 | void virtsnd_ctl_msg_complete(struct virtio_snd_msg *msg) | |
220 | { | |
221 | list_del(&msg->list); | |
222 | complete(&msg->notify); | |
223 | ||
224 | virtsnd_ctl_msg_unref(msg); | |
225 | } | |
226 | ||
227 | /** | |
228 | * virtsnd_ctl_msg_cancel_all() - Cancel all pending control messages. | |
229 | * @snd: VirtIO sound device. | |
230 | * | |
231 | * Context: Any context. | |
232 | */ | |
233 | void virtsnd_ctl_msg_cancel_all(struct virtio_snd *snd) | |
234 | { | |
235 | struct virtio_snd_queue *queue = virtsnd_control_queue(snd); | |
236 | unsigned long flags; | |
237 | ||
238 | spin_lock_irqsave(&queue->lock, flags); | |
239 | while (!list_empty(&snd->ctl_msgs)) { | |
240 | struct virtio_snd_msg *msg = | |
241 | list_first_entry(&snd->ctl_msgs, struct virtio_snd_msg, | |
242 | list); | |
243 | ||
244 | virtsnd_ctl_msg_complete(msg); | |
245 | } | |
246 | spin_unlock_irqrestore(&queue->lock, flags); | |
247 | } | |
248 | ||
249 | /** | |
250 | * virtsnd_ctl_query_info() - Query the item configuration from the device. | |
251 | * @snd: VirtIO sound device. | |
252 | * @command: Control request code (VIRTIO_SND_R_XXX_INFO). | |
253 | * @start_id: Item start identifier. | |
254 | * @count: Item count to query. | |
255 | * @size: Item information size in bytes. | |
256 | * @info: Buffer for storing item information. | |
257 | * | |
258 | * Context: Any context that permits to sleep. | |
259 | * Return: 0 on success, -errno on failure. | |
260 | */ | |
261 | int virtsnd_ctl_query_info(struct virtio_snd *snd, int command, int start_id, | |
262 | int count, size_t size, void *info) | |
263 | { | |
264 | struct virtio_snd_msg *msg; | |
265 | struct virtio_snd_query_info *query; | |
266 | struct scatterlist sg; | |
267 | ||
268 | msg = virtsnd_ctl_msg_alloc(sizeof(*query), | |
269 | sizeof(struct virtio_snd_hdr), GFP_KERNEL); | |
270 | if (!msg) | |
271 | return -ENOMEM; | |
272 | ||
273 | query = virtsnd_ctl_msg_request(msg); | |
274 | query->hdr.code = cpu_to_le32(command); | |
275 | query->start_id = cpu_to_le32(start_id); | |
276 | query->count = cpu_to_le32(count); | |
277 | query->size = cpu_to_le32(size); | |
278 | ||
279 | sg_init_one(&sg, info, count * size); | |
280 | ||
281 | return virtsnd_ctl_msg_send(snd, msg, NULL, &sg, false); | |
282 | } | |
283 | ||
284 | /** | |
285 | * virtsnd_ctl_notify_cb() - Process all completed control messages. | |
286 | * @vqueue: Underlying control virtqueue. | |
287 | * | |
288 | * This callback function is called upon a vring interrupt request from the | |
289 | * device. | |
290 | * | |
291 | * Context: Interrupt context. Takes and releases the control queue spinlock. | |
292 | */ | |
293 | void virtsnd_ctl_notify_cb(struct virtqueue *vqueue) | |
294 | { | |
295 | struct virtio_snd *snd = vqueue->vdev->priv; | |
296 | struct virtio_snd_queue *queue = virtsnd_control_queue(snd); | |
297 | struct virtio_snd_msg *msg; | |
298 | u32 length; | |
299 | unsigned long flags; | |
300 | ||
301 | spin_lock_irqsave(&queue->lock, flags); | |
302 | do { | |
303 | virtqueue_disable_cb(vqueue); | |
304 | while ((msg = virtqueue_get_buf(vqueue, &length))) | |
305 | virtsnd_ctl_msg_complete(msg); | |
306 | if (unlikely(virtqueue_is_broken(vqueue))) | |
307 | break; | |
308 | } while (!virtqueue_enable_cb(vqueue)); | |
309 | spin_unlock_irqrestore(&queue->lock, flags); | |
310 | } |