Code Review / AGL / meta-agl-devel.git / blob
? search:


35ea04f8f59f31e8a0e01a0cb38a9843ddfc05ac
[AGL/meta-agl-devel.git] /
1 From 7b9f3fe0766d6d36ca7465e54754df51ca175079 Mon Sep 17 00:00:00 2001
2 From: Igor Skalkin <igor.skalkin@opensynergy.com>
3 Date: Thu, 5 Nov 2020 22:21:16 +0100
4 Subject: [PATCH] firmware: arm_scmi: Add virtio transport
5
6 This transport enables accessing an SCMI platform as a virtio device.
7
8 Implement an SCMI virtio driver according to the virtio SCMI device spec
9 patch v5 [1]. Virtio device id 32 has been reserved for the SCMI device
10 [2].
11
12 The virtio transport has one tx channel (virtio cmdq, A2P channel) and
13 at most one rx channel (virtio eventq, P2A channel).
14
15 The following feature bit defined in [1] is not implemented:
16 VIRTIO_SCMI_F_SHARED_MEMORY.
17
18 After the preparatory patches, implement the virtio transport as
19 paraphrased:
20
21 Only support a single arm-scmi device (which is consistent with the SCMI
22 spec). Call scmi-virtio init from arm-scmi module init. During the
23 arm-scmi probing, link to the first probed scmi-virtio device. Defer
24 arm-scmi probing if no scmi-virtio device is bound yet.
25
26 Use the scmi_xfer tx/rx buffers for data exchange with the virtio device
27 in order to avoid redundant maintenance of additional buffers. Allocate
28 the buffers in the SCMI transport, and prepend room for a small header
29 used by the virtio transport to the tx/rx buffers.
30
31 For simplicity, restrict the number of messages which can be pending
32 simultaneously according to the virtqueue capacity. (The virtqueue sizes
33 are negotiated with the virtio device.)
34
35 As soon as rx channel message buffers are allocated or have been read
36 out by the arm-scmi driver, feed them to the virtio device.
37
38 Since some virtio devices may not have the short response time exhibited
39 by SCMI platforms using other transports, set a generous response
40 timeout.
41
42 Limitations:
43
44 Do not adjust the other SCMI timeouts for delayed response and polling
45 for now, since these timeouts are only relevant in special cases which
46 are not yet deemed relevant for this transport.
47
48 To do (as discussed in the cover letter):
49
50 - Avoid re-use of buffers still being used by the virtio device on
51   timeouts.
52
53 - Avoid race conditions on receiving messages during/after channel free
54   on driver probe failure or remove.
55
56 [1] https://lists.oasis-open.org/archives/virtio-comment/202005/msg00096.html
57 [2] https://www.oasis-open.org/committees/ballot.php?id=3496
58
59 Co-developed-by: Peter Hilber <peter.hilber@opensynergy.com>
60 Signed-off-by: Peter Hilber <peter.hilber@opensynergy.com>
61 Signed-off-by: Igor Skalkin <igor.skalkin@opensynergy.com>
62 Signed-off-by: Vasyl Vavrychuk <vasyl.vavrychuk@opensynergy.com>
63 ---
64  MAINTAINERS                        |   1 +
65  drivers/firmware/Kconfig           |  12 +-
66  drivers/firmware/arm_scmi/Makefile |   1 +
67  drivers/firmware/arm_scmi/common.h |  14 +
68  drivers/firmware/arm_scmi/driver.c |  11 +
69  drivers/firmware/arm_scmi/virtio.c | 493 +++++++++++++++++++++++++++++
70  include/uapi/linux/virtio_ids.h    |   1 +
71  include/uapi/linux/virtio_scmi.h   |  41 +++
72  8 files changed, 573 insertions(+), 1 deletion(-)
73  create mode 100644 drivers/firmware/arm_scmi/virtio.c
74  create mode 100644 include/uapi/linux/virtio_scmi.h
75
76 diff --git a/MAINTAINERS b/MAINTAINERS
77 index 49772b741967..d223a5c3f465 100644
78 --- a/MAINTAINERS
79 +++ b/MAINTAINERS
80 @@ -16973,6 +16973,7 @@ F:      drivers/firmware/arm_scpi.c
81  F:     drivers/reset/reset-scmi.c
82  F:     include/linux/sc[mp]i_protocol.h
83  F:     include/trace/events/scmi.h
84 +F:     include/uapi/linux/virtio_scmi.h
85  
86  SYSTEM RESET/SHUTDOWN DRIVERS
87  M:     Sebastian Reichel <sre@kernel.org>
88 diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
89 index 30a85d38d0c0..82e97904bcae 100644
90 --- a/drivers/firmware/Kconfig
91 +++ b/drivers/firmware/Kconfig
92 @@ -9,7 +9,7 @@ menu "Firmware Drivers"
93  config ARM_SCMI_PROTOCOL
94         tristate "ARM System Control and Management Interface (SCMI) Message Protocol"
95         depends on ARM || ARM64 || COMPILE_TEST
96 -       depends on ARM_SCMI_HAVE_SHMEM
97 +       depends on ARM_SCMI_HAVE_SHMEM || VIRTIO_SCMI
98         help
99           ARM System Control and Management Interface (SCMI) protocol is a
100           set of operating system-independent software interfaces that are
101 @@ -34,6 +34,16 @@ config ARM_SCMI_HAVE_SHMEM
102           This declares whether a shared memory based transport for SCMI is
103           available.
104  
105 +config VIRTIO_SCMI
106 +       bool "Virtio transport for SCMI"
107 +       default n
108 +       depends on VIRTIO
109 +       help
110 +         This enables the virtio based transport for SCMI.
111 +
112 +         If you want to use the ARM SCMI protocol between the virtio guest and
113 +         a host providing a virtio SCMI device, answer Y.
114 +
115  config ARM_SCMI_POWER_DOMAIN
116         tristate "SCMI power domain driver"
117         depends on ARM_SCMI_PROTOCOL || (COMPILE_TEST && OF)
118 diff --git a/drivers/firmware/arm_scmi/Makefile b/drivers/firmware/arm_scmi/Makefile
119 index 3cc7fa40a464..25caea5e1969 100644
120 --- a/drivers/firmware/arm_scmi/Makefile
121 +++ b/drivers/firmware/arm_scmi/Makefile
122 @@ -4,6 +4,7 @@ scmi-driver-y = driver.o notify.o
123  scmi-transport-$(CONFIG_ARM_SCMI_HAVE_SHMEM) = shmem.o
124  scmi-transport-$(CONFIG_MAILBOX) += mailbox.o
125  scmi-transport-$(CONFIG_HAVE_ARM_SMCCC_DISCOVERY) += smc.o
126 +scmi-transport-$(CONFIG_VIRTIO_SCMI) += virtio.o
127  scmi-protocols-y = base.o clock.o perf.o power.o reset.o sensors.o system.o
128  scmi-module-objs := $(scmi-bus-y) $(scmi-driver-y) $(scmi-protocols-y) \
129                     $(scmi-transport-y)
130 diff --git a/drivers/firmware/arm_scmi/common.h b/drivers/firmware/arm_scmi/common.h
131 index 13c9ac176b23..b46dfe84e78b 100644
132 --- a/drivers/firmware/arm_scmi/common.h
133 +++ b/drivers/firmware/arm_scmi/common.h
134 @@ -165,6 +165,17 @@ int scmi_base_protocol_init(struct scmi_handle *h);
135  int __init scmi_bus_init(void);
136  void __exit scmi_bus_exit(void);
137  
138 +#ifdef CONFIG_VIRTIO_SCMI
139 +int __init virtio_scmi_init(void);
140 +void __exit virtio_scmi_exit(void);
141 +#else
142 +static inline int __init virtio_scmi_init(void)
143 +{
144 +       return 0;
145 +}
146 +#define virtio_scmi_exit() do { } while (0)
147 +#endif
148 +
149  #define DECLARE_SCMI_REGISTER_UNREGISTER(func)         \
150         int __init scmi_##func##_register(void);        \
151         void __exit scmi_##func##_unregister(void)
152 @@ -263,6 +274,9 @@ extern const struct scmi_desc scmi_mailbox_desc;
153  #ifdef CONFIG_HAVE_ARM_SMCCC
154  extern const struct scmi_desc scmi_smc_desc;
155  #endif
156 +#ifdef CONFIG_VIRTIO_SCMI
157 +extern const struct scmi_desc scmi_virtio_desc;
158 +#endif
159  
160  int scmi_set_transport_info(struct device *dev, void *transport_info);
161  void *scmi_get_transport_info(struct device *dev);
162 diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c
163 index 93ce17bb4079..540a55285349 100644
164 --- a/drivers/firmware/arm_scmi/driver.c
165 +++ b/drivers/firmware/arm_scmi/driver.c
166 @@ -996,6 +996,9 @@ static const struct of_device_id scmi_of_match[] = {
167  #endif
168  #ifdef CONFIG_HAVE_ARM_SMCCC_DISCOVERY
169         { .compatible = "arm,scmi-smc", .data = &scmi_smc_desc},
170 +#endif
171 +#ifdef CONFIG_VIRTIO_SCMI
172 +       { .compatible = "arm,scmi-virtio", .data = &scmi_virtio_desc},
173  #endif
174         { /* Sentinel */ },
175  };
176 @@ -1014,8 +1017,14 @@ static struct platform_driver scmi_driver = {
177  
178  static int __init scmi_driver_init(void)
179  {
180 +       int ret;
181 +
182         scmi_bus_init();
183  
184 +       ret = virtio_scmi_init();
185 +       if (ret)
186 +               return ret;
187 +
188         scmi_clock_register();
189         scmi_perf_register();
190         scmi_power_register();
191 @@ -1038,6 +1047,8 @@ static void __exit scmi_driver_exit(void)
192         scmi_sensors_unregister();
193         scmi_system_unregister();
194  
195 +       virtio_scmi_exit();
196 +
197         platform_driver_unregister(&scmi_driver);
198  }
199  module_exit(scmi_driver_exit);
200 diff --git a/drivers/firmware/arm_scmi/virtio.c b/drivers/firmware/arm_scmi/virtio.c
201 new file mode 100644
202 index 000000000000..f70aa72f34f1
203 --- /dev/null
204 +++ b/drivers/firmware/arm_scmi/virtio.c
205 @@ -0,0 +1,493 @@
206 +// SPDX-License-Identifier: GPL-2.0
207 +/*
208 + * Virtio Transport driver for Arm System Control and Management Interface
209 + * (SCMI).
210 + *
211 + * Copyright (C) 2020 OpenSynergy.
212 + */
213 +
214 +/**
215 + * DOC: Theory of Operation
216 + *
217 + * The scmi-virtio transport implements a driver for the virtio SCMI device
218 + * proposed in virtio spec patch v5[1].
219 + *
220 + * There is one tx channel (virtio cmdq, A2P channel) and at most one rx
221 + * channel (virtio eventq, P2A channel). Each channel is implemented through a
222 + * virtqueue. Access to each virtqueue is protected by a spinlock.
223 + *
224 + * This SCMI transport uses the scmi_xfer tx/rx buffers for data exchange with
225 + * the virtio device to avoid maintenance of additional buffers.
226 + *
227 + * [1] https://lists.oasis-open.org/archives/virtio-comment/202005/msg00096.html
228 + */
229 +
230 +#include <linux/errno.h>
231 +#include <linux/of.h>
232 +#include <linux/of_platform.h>
233 +#include <linux/platform_device.h>
234 +#include <linux/module.h>
235 +#include <linux/slab.h>
236 +#include <linux/virtio.h>
237 +#include <linux/virtio_config.h>
238 +#include <uapi/linux/virtio_ids.h>
239 +#include <uapi/linux/virtio_scmi.h>
240 +
241 +#include "common.h"
242 +
243 +#define VIRTIO_SCMI_MAX_MSG_SIZE 128 /* Value may be increased. */
244 +#define DESCR_PER_TX_MSG 2
245 +
246 +struct scmi_vio_channel {
247 +       spinlock_t lock;
248 +       struct virtqueue *vqueue;
249 +       struct scmi_chan_info *cinfo;
250 +       u8 is_rx;
251 +};
252 +
253 +union virtio_scmi_input {
254 +       __virtio32 hdr;
255 +       struct virtio_scmi_response response;
256 +       struct virtio_scmi_notification notification;
257 +};
258 +
259 +struct scmi_vio_msg {
260 +       struct virtio_scmi_request *request;
261 +       union virtio_scmi_input *input;
262 +       u8 completed;
263 +};
264 +
265 +static int scmi_vio_populate_vq_rx(struct scmi_vio_channel *vioch,
266 +                                  struct scmi_xfer *xfer)
267 +{
268 +       struct scatterlist sg_in;
269 +       struct scmi_vio_msg *msg = xfer->extra_data;
270 +       int rc;
271 +
272 +       msg->completed = false;
273 +
274 +       sg_init_one(&sg_in, msg->input,
275 +                   sizeof(*msg->input) + VIRTIO_SCMI_MAX_MSG_SIZE);
276 +
277 +       rc = virtqueue_add_inbuf(vioch->vqueue, &sg_in, 1, xfer, GFP_ATOMIC);
278 +       if (rc)
279 +               dev_err(vioch->cinfo->dev, "%s() rc=%d\n", __func__, rc);
280 +       else
281 +               virtqueue_kick(vioch->vqueue);
282 +
283 +       return rc;
284 +}
285 +
286 +static void scmi_vio_complete_cb(struct virtqueue *vqueue)
287 +{
288 +       struct scmi_vio_channel *vioch = vqueue->priv;
289 +       unsigned long iflags;
290 +       unsigned int length;
291 +
292 +       spin_lock_irqsave(&vioch->lock, iflags);
293 +
294 +       do {
295 +               struct scmi_xfer *xfer;
296 +
297 +               virtqueue_disable_cb(vqueue);
298 +
299 +               while ((xfer = virtqueue_get_buf(vqueue, &length))) {
300 +                       struct scmi_vio_msg *msg = xfer->extra_data;
301 +                       u32 msg_hdr =
302 +                               virtio32_to_cpu(vqueue->vdev, msg->input->hdr);
303 +                       u8 msg_type = MSG_XTRACT_TYPE(msg_hdr);
304 +
305 +                       if (!vioch->is_rx) { /* tx queue response */
306 +                               msg->completed = true;
307 +                               xfer->rx.len =
308 +                                       length - sizeof(msg->input->response);
309 +                               if (!xfer->hdr.poll_completion)
310 +                                       scmi_rx_callback(vioch->cinfo, msg_hdr);
311 +                               continue;
312 +                       }
313 +
314 +                       /* rx queue - notification or delayed response */
315 +                       switch (msg_type) {
316 +                       case MSG_TYPE_NOTIFICATION:
317 +                               xfer->rx.len = length -
318 +                                              sizeof(msg->input->notification);
319 +                               xfer->rx.buf = msg->input->notification.data;
320 +                               break;
321 +                       case MSG_TYPE_DELAYED_RESP:
322 +                               xfer->rx.len =
323 +                                       length - sizeof(msg->input->response);
324 +                               xfer->rx.buf = msg->input->response.data;
325 +                               break;
326 +                       default:
327 +                               dev_warn_once(vioch->cinfo->dev,
328 +                                             "rx: unknown message_type %d\n",
329 +                                             msg_type);
330 +                               scmi_vio_populate_vq_rx(vioch, xfer);
331 +                               continue;
332 +                       }
333 +
334 +                       scmi_rx_callback(vioch->cinfo, msg_hdr);
335 +                       scmi_vio_populate_vq_rx(vioch, xfer);
336 +               }
337 +
338 +               if (unlikely(virtqueue_is_broken(vqueue)))
339 +                       break;
340 +       } while (!virtqueue_enable_cb(vqueue));
341 +
342 +       spin_unlock_irqrestore(&vioch->lock, iflags);
343 +}
344 +
345 +static const char *const scmi_vio_vqueue_names[] = { "tx", "rx" };
346 +
347 +static vq_callback_t *scmi_vio_complete_callbacks[] = {
348 +       scmi_vio_complete_cb,
349 +       scmi_vio_complete_cb
350 +};
351 +
352 +static int scmi_vio_match_any_dev(struct device *dev, const void *data)
353 +{
354 +       (void)dev;
355 +       (void)data;
356 +
357 +       return 1;
358 +}
359 +
360 +static struct virtio_driver virtio_scmi_driver; /* Forward declaration */
361 +
362 +static int virtio_link_supplier(struct device *dev)
363 +{
364 +       struct device *vdev = driver_find_device(
365 +               &virtio_scmi_driver.driver, NULL, NULL, scmi_vio_match_any_dev);
366 +
367 +       if (!vdev) {
368 +               dev_notice_once(
369 +                       dev,
370 +                       "Deferring probe after not finding a bound scmi-virtio device\n");
371 +               return -EPROBE_DEFER;
372 +       }
373 +
374 +       /*
375 +        * Add plain device link for completeness. It might have no effect
376 +        * beyond sysfs.
377 +        */
378 +       if (!device_link_add(dev, vdev, DL_FLAG_AUTOREMOVE_CONSUMER)) {
379 +               put_device(vdev);
380 +               dev_err(dev, "Adding link to supplier virtio device failed\n");
381 +               return -ECANCELED;
382 +       }
383 +
384 +       put_device(vdev);
385 +       return scmi_set_transport_info(dev, dev_to_virtio(vdev));
386 +}
387 +
388 +static bool virtio_chan_available(struct device *dev, int idx)
389 +{
390 +       struct virtio_device *vdev;
391 +       struct scmi_vio_channel **vioch;
392 +
393 +       /* scmi-virtio doesn't support per-protocol channels */
394 +       if (is_scmi_protocol_device(dev))
395 +               return false;
396 +
397 +       vdev = scmi_get_transport_info(dev);
398 +       if (!vdev)
399 +               return false;
400 +
401 +       vioch = vdev->priv;
402 +       if (!vioch)
403 +               return false;
404 +
405 +       return vioch[idx] && vioch[idx]->vqueue;
406 +}
407 +
408 +static int virtio_chan_setup(struct scmi_chan_info *cinfo, struct device *dev,
409 +                            bool tx)
410 +{
411 +       struct virtio_device *vdev;
412 +       struct scmi_vio_channel **vioch;
413 +       int vioch_index = tx ? VIRTIO_SCMI_VQ_TX : VIRTIO_SCMI_VQ_RX;
414 +
415 +       /* scmi-virtio doesn't support per-protocol channels */
416 +       if (is_scmi_protocol_device(dev))
417 +               return -1;
418 +
419 +       vdev = scmi_get_transport_info(dev);
420 +       if (!vdev)
421 +               return -1;
422 +
423 +       vioch = vdev->priv;
424 +       if (!vioch) {
425 +               dev_err(dev, "Data from scmi-virtio probe not found\n");
426 +               return -1;
427 +       }
428 +       cinfo->transport_info = vioch[vioch_index];
429 +       vioch[vioch_index]->cinfo = cinfo;
430 +
431 +       return 0;
432 +}
433 +
434 +static int virtio_chan_free(int id, void *p, void *data)
435 +{
436 +       struct scmi_chan_info *cinfo = p;
437 +       struct scmi_vio_channel *vioch = cinfo->transport_info;
438 +
439 +       if (vioch) {
440 +               cinfo->transport_info = NULL;
441 +               kfree(vioch);
442 +       }
443 +
444 +       scmi_free_channel(cinfo, data, id);
445 +       return 0;
446 +}
447 +
448 +static int virtio_get_max_msg(bool tx, struct scmi_chan_info *base_cinfo,
449 +                             int *max_msg)
450 +{
451 +       struct scmi_vio_channel *vioch = base_cinfo->transport_info;
452 +
453 +       *max_msg = virtqueue_get_vring_size(vioch->vqueue);
454 +
455 +       /* Tx messages need multiple descriptors. */
456 +       if (tx)
457 +               *max_msg /= DESCR_PER_TX_MSG;
458 +
459 +       if (*max_msg > MSG_TOKEN_MAX) {
460 +               dev_notice(
461 +                       base_cinfo->dev,
462 +                       "Only %ld messages can be pending simultaneously, while the virtqueue could hold %d\n",
463 +                       MSG_TOKEN_MAX, *max_msg);
464 +               *max_msg = MSG_TOKEN_MAX;
465 +       }
466 +
467 +       return 0;
468 +}
469 +
470 +static int virtio_xfer_init_buffers(struct scmi_chan_info *cinfo,
471 +                                   struct scmi_xfer *xfer, int max_msg_size)
472 +{
473 +       struct scmi_vio_channel *vioch = cinfo->transport_info;
474 +       struct scmi_vio_msg *msg;
475 +
476 +       msg = devm_kzalloc(cinfo->dev, sizeof(*msg), GFP_KERNEL);
477 +       if (!msg)
478 +               return -ENOMEM;
479 +
480 +       xfer->extra_data = msg;
481 +
482 +       if (vioch->is_rx) {
483 +               int rc;
484 +               unsigned long iflags;
485 +
486 +               msg->input = devm_kzalloc(cinfo->dev,
487 +                                         sizeof(*msg->input) + max_msg_size,
488 +                                         GFP_KERNEL);
489 +               if (!msg->input)
490 +                       return -ENOMEM;
491 +
492 +               /*
493 +                * xfer->rx.buf will be set to notification or delayed response
494 +                * specific values in the receive callback, according to the
495 +                * type of the received message.
496 +                */
497 +
498 +               spin_lock_irqsave(&vioch->lock, iflags);
499 +               rc = scmi_vio_populate_vq_rx(vioch, xfer);
500 +               spin_unlock_irqrestore(&vioch->lock, iflags);
501 +               if (rc)
502 +                       return rc;
503 +       } else {
504 +               msg->request =
505 +                       devm_kzalloc(cinfo->dev,
506 +                                    sizeof(*msg->request) + max_msg_size,
507 +                                    GFP_KERNEL);
508 +               if (!msg->request)
509 +                       return -ENOMEM;
510 +
511 +               xfer->tx.buf = msg->request->data;
512 +
513 +               msg->input = devm_kzalloc(
514 +                       cinfo->dev, sizeof(msg->input->response) + max_msg_size,
515 +                       GFP_KERNEL);
516 +               if (!msg->input)
517 +                       return -ENOMEM;
518 +
519 +               xfer->rx.buf = msg->input->response.data;
520 +       }
521 +
522 +       return 0;
523 +}
524 +
525 +static int scmi_vio_send(struct scmi_vio_channel *vioch, struct scmi_xfer *xfer)
526 +{
527 +       struct scatterlist sg_out;
528 +       struct scatterlist sg_in;
529 +       struct scatterlist *sgs[DESCR_PER_TX_MSG] = { &sg_out, &sg_in };
530 +       struct scmi_vio_msg *msg = xfer->extra_data;
531 +       unsigned long iflags;
532 +       int rc;
533 +
534 +       msg->completed = false;
535 +
536 +       sg_init_one(&sg_out, msg->request,
537 +                   sizeof(*msg->request) + xfer->tx.len);
538 +       sg_init_one(&sg_in, &msg->input->response,
539 +                   sizeof(msg->input->response) + xfer->rx.len);
540 +
541 +       spin_lock_irqsave(&vioch->lock, iflags);
542 +       rc = virtqueue_add_sgs(vioch->vqueue, sgs, 1, 1, xfer, GFP_ATOMIC);
543 +       if (rc)
544 +               dev_err(vioch->cinfo->dev, "%s() rc=%d\n", __func__, rc);
545 +       else
546 +               virtqueue_kick(vioch->vqueue);
547 +       spin_unlock_irqrestore(&vioch->lock, iflags);
548 +
549 +       return rc;
550 +}
551 +
552 +static int virtio_send_message(struct scmi_chan_info *cinfo,
553 +                              struct scmi_xfer *xfer)
554 +{
555 +       uint32_t hdr;
556 +       struct scmi_vio_channel *vioch = cinfo->transport_info;
557 +       struct virtio_device *vdev = vioch->vqueue->vdev;
558 +       struct scmi_vio_msg *msg = xfer->extra_data;
559 +
560 +       hdr = pack_scmi_header(&xfer->hdr);
561 +
562 +       msg->request->hdr = cpu_to_virtio32(vdev, hdr);
563 +
564 +       return scmi_vio_send(vioch, xfer);
565 +}
566 +
567 +static void virtio_fetch_response(struct scmi_chan_info *cinfo,
568 +                                 struct scmi_xfer *xfer)
569 +{
570 +       struct scmi_vio_channel *vioch = cinfo->transport_info;
571 +       struct scmi_vio_msg *msg = xfer->extra_data;
572 +
573 +       xfer->hdr.status = virtio32_to_cpu(vioch->vqueue->vdev,
574 +                                          msg->input->response.status);
575 +}
576 +
577 +static void dummy_fetch_notification(struct scmi_chan_info *cinfo,
578 +                                    size_t max_len, struct scmi_xfer *xfer)
579 +{
580 +       (void)cinfo;
581 +       (void)max_len;
582 +       (void)xfer;
583 +}
584 +
585 +static void dummy_clear_channel(struct scmi_chan_info *cinfo)
586 +{
587 +       (void)cinfo;
588 +}
589 +
590 +static bool virtio_poll_done(struct scmi_chan_info *cinfo,
591 +                            struct scmi_xfer *xfer)
592 +{
593 +       struct scmi_vio_channel *vioch = cinfo->transport_info;
594 +       struct scmi_vio_msg *msg = xfer->extra_data;
595 +       unsigned long iflags;
596 +       bool completed;
597 +
598 +       spin_lock_irqsave(&vioch->lock, iflags);
599 +       completed = msg->completed;
600 +       spin_unlock_irqrestore(&vioch->lock, iflags);
601 +
602 +       return completed;
603 +}
604 +
605 +static const struct scmi_transport_ops scmi_virtio_ops = {
606 +       .link_supplier = virtio_link_supplier,
607 +       .chan_available = virtio_chan_available,
608 +       .chan_setup = virtio_chan_setup,
609 +       .chan_free = virtio_chan_free,
610 +       .get_max_msg = virtio_get_max_msg,
611 +       .send_message = virtio_send_message,
612 +       .fetch_response = virtio_fetch_response,
613 +       .fetch_notification = dummy_fetch_notification,
614 +       .clear_channel = dummy_clear_channel,
615 +       .poll_done = virtio_poll_done,
616 +       .xfer_init_buffers = virtio_xfer_init_buffers,
617 +};
618 +
619 +const struct scmi_desc scmi_virtio_desc = {
620 +       .ops = &scmi_virtio_ops,
621 +       .max_rx_timeout_ms = 60000, /* for non-realtime virtio devices */
622 +       .max_msg = 0, /* overridden by virtio_get_max_msg() */
623 +       .max_msg_size = VIRTIO_SCMI_MAX_MSG_SIZE,
624 +};
625 +
626 +static int scmi_vio_probe(struct virtio_device *vdev)
627 +{
628 +       struct device *dev = &vdev->dev;
629 +       struct scmi_vio_channel **vioch;
630 +       bool have_vq_rx;
631 +       int vq_cnt;
632 +       int i;
633 +       struct virtqueue *vqs[VIRTIO_SCMI_VQ_MAX_CNT];
634 +
635 +       vioch = devm_kcalloc(dev, VIRTIO_SCMI_VQ_MAX_CNT, sizeof(*vioch),
636 +                            GFP_KERNEL);
637 +       if (!vioch)
638 +               return -ENOMEM;
639 +
640 +       have_vq_rx = virtio_has_feature(vdev, VIRTIO_SCMI_F_P2A_CHANNELS);
641 +       vq_cnt = have_vq_rx ? VIRTIO_SCMI_VQ_MAX_CNT : 1;
642 +
643 +       for (i = 0; i < vq_cnt; i++) {
644 +               vioch[i] = devm_kzalloc(dev, sizeof(**vioch), GFP_KERNEL);
645 +               if (!vioch[i])
646 +                       return -ENOMEM;
647 +       }
648 +
649 +       if (have_vq_rx)
650 +               vioch[VIRTIO_SCMI_VQ_RX]->is_rx = true;
651 +
652 +       if (virtio_find_vqs(vdev, vq_cnt, vqs, scmi_vio_complete_callbacks,
653 +                           scmi_vio_vqueue_names, NULL)) {
654 +               dev_err(dev, "Failed to get %d virtqueue(s)\n", vq_cnt);
655 +               return -1;
656 +       }
657 +       dev_info(dev, "Found %d virtqueue(s)\n", vq_cnt);
658 +
659 +       for (i = 0; i < vq_cnt; i++) {
660 +               spin_lock_init(&vioch[i]->lock);
661 +               vioch[i]->vqueue = vqs[i];
662 +               vioch[i]->vqueue->priv = vioch[i];
663 +       }
664 +
665 +       vdev->priv = vioch;
666 +
667 +       virtio_device_ready(vdev);
668 +
669 +       return 0;
670 +}
671 +
672 +static unsigned int features[] = {
673 +       VIRTIO_SCMI_F_P2A_CHANNELS,
674 +};
675 +
676 +static const struct virtio_device_id id_table[] = {
677 +       { VIRTIO_ID_SCMI, VIRTIO_DEV_ANY_ID },
678 +       { 0 }
679 +};
680 +
681 +static struct virtio_driver virtio_scmi_driver = {
682 +       .driver.name = "scmi-virtio",
683 +       .driver.owner = THIS_MODULE,
684 +       .feature_table = features,
685 +       .feature_table_size = ARRAY_SIZE(features),
686 +       .id_table = id_table,
687 +       .probe = scmi_vio_probe,
688 +};
689 +
690 +int __init virtio_scmi_init(void)
691 +{
692 +       return register_virtio_driver(&virtio_scmi_driver);
693 +}
694 +
695 +void __exit virtio_scmi_exit(void)
696 +{
697 +       unregister_virtio_driver(&virtio_scmi_driver);
698 +}
699 diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.h
700 index bc740d6d2259..287daba2abdb 100644
701 --- a/include/uapi/linux/virtio_ids.h
702 +++ b/include/uapi/linux/virtio_ids.h
703 @@ -49,5 +49,6 @@
704  #define VIRTIO_ID_FS           26 /* virtio filesystem */
705  #define VIRTIO_ID_PMEM         27 /* virtio pmem */
706  #define VIRTIO_ID_MAC80211_HWSIM 29 /* virtio mac80211-hwsim */
707 +#define VIRTIO_ID_SCMI         32 /* virtio SCMI */
708  
709  #endif /* _LINUX_VIRTIO_IDS_H */
710 diff --git a/include/uapi/linux/virtio_scmi.h b/include/uapi/linux/virtio_scmi.h
711 new file mode 100644
712 index 000000000000..9f21b3dbbfe2
713 --- /dev/null
714 +++ b/include/uapi/linux/virtio_scmi.h
715 @@ -0,0 +1,41 @@
716 +/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
717 +/*
718 + * Copyright (C) 2020 OpenSynergy GmbH
719 + */
720 +
721 +#ifndef _UAPI_LINUX_VIRTIO_SCMI_H
722 +#define _UAPI_LINUX_VIRTIO_SCMI_H
723 +
724 +#include <linux/virtio_types.h>
725 +
726 +/* Feature bits */
727 +
728 +/* Device implements some SCMI notifications, or delayed responses. */
729 +#define VIRTIO_SCMI_F_P2A_CHANNELS 0
730 +
731 +/* Device implements any SCMI statistics shared memory region */
732 +#define VIRTIO_SCMI_F_SHARED_MEMORY 1
733 +
734 +/* Virtqueues */
735 +
736 +#define VIRTIO_SCMI_VQ_TX 0 /* cmdq */
737 +#define VIRTIO_SCMI_VQ_RX 1 /* eventq */
738 +#define VIRTIO_SCMI_VQ_MAX_CNT 2
739 +
740 +struct virtio_scmi_request {
741 +       __virtio32 hdr;
742 +       __u8 data[];
743 +};
744 +
745 +struct virtio_scmi_response {
746 +       __virtio32 hdr;
747 +       __virtio32 status;
748 +       __u8 data[];
749 +};
750 +
751 +struct virtio_scmi_notification {
752 +       __virtio32 hdr;
753 +       __u8 data[];
754 +};
755 +
756 +#endif /* _UAPI_LINUX_VIRTIO_SCMI_H */
meta-agl-devel (Development and Community BSPs)