kernel -- virtio: Implement virtio-layer lwkt_serializer for devices
[dragonfly.git] / sys / dev / virtual / virtio / pci / virtio_pci.c
1 /*-
2  * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice unmodified, this list of conditions, and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/virtio/pci/virtio_pci.c,v 1.3 2012/04/14 05:48:04 grehan Exp $
27  */
28
29 /* Driver for the VirtIO PCI interface. */
30
31 #include <sys/cdefs.h>
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/bus.h>
36 #include <sys/kernel.h>
37 #include <sys/module.h>
38 #include <sys/malloc.h>
39 #include <sys/serialize.h>
40
41 #include <bus/pci/pcivar.h>
42 #include <bus/pci/pcireg.h>
43
44 #include <sys/bus.h>
45 #include <sys/param.h>
46 #include <sys/rman.h>
47
48 #include <dev/virtual/virtio/virtio/virtio.h>
49 #include <dev/virtual/virtio/virtio/virtqueue.h>
50 #include "virtio_pci.h"
51 #include "virtio_if.h"
52 #include "virtio_bus_if.h"
53
54 struct vtpci_softc {
55         device_t                         vtpci_dev;
56         struct resource                 *vtpci_res;
57         struct resource                 *vtpci_msix_res;
58         uint64_t                         vtpci_features;
59         uint32_t                         vtpci_flags;
60         int                              vtpci_irq_type;
61         int                              vtpci_irq_rid;
62 #define VIRTIO_PCI_FLAG_NO_MSI           0x0001
63 #define VIRTIO_PCI_FLAG_MSI              0x0002
64 #define VIRTIO_PCI_FLAG_NO_MSIX          0x0010
65 #define VIRTIO_PCI_FLAG_MSIX             0x0020
66 #define VIRTIO_PCI_FLAG_SHARED_MSIX      0x0040
67
68         device_t                         vtpci_child_dev;
69         struct virtio_feature_desc      *vtpci_child_feat_desc;
70
71         /*
72          * Ideally, each virtqueue that the driver provides a callback for
73          * will receive its own MSIX vector. If there are not sufficient
74          * vectors available, we will then attempt to have all the VQs
75          * share one vector. Note that when using MSIX, the configuration
76          * changed notifications must be on their own vector.
77          *
78          * If MSIX is not available, we will attempt to have the whole
79          * device share one MSI vector, and then, finally, one legacy
80          * interrupt.
81          */
82         int                              vtpci_nvqs;
83         struct vtpci_virtqueue {
84                 struct virtqueue *vq;
85
86                 /* Index into vtpci_intr_res[] below. Unused, then -1. */
87                 int               ires_idx;
88         } vtpci_vqx[VIRTIO_MAX_VIRTQUEUES];
89
90         /*
91          * When using MSIX interrupts, the first element of vtpci_intr_res[]
92          * is always the configuration changed notifications. The remaining
93          * element(s) are used for the virtqueues.
94          *
95          * With MSI and legacy interrupts, only the first element of
96          * vtpci_intr_res[] is used.
97          */
98         int                              vtpci_nintr_res;
99         struct vtpci_intr_resource {
100                 struct resource *irq;
101                 int              rid;
102                 void            *intrhand;
103         } vtpci_intr_res[1 + VIRTIO_MAX_VIRTQUEUES];
104 };
105
106 static int      vtpci_probe(device_t);
107 static int      vtpci_attach(device_t);
108 static int      vtpci_detach(device_t);
109 static int      vtpci_suspend(device_t);
110 static int      vtpci_resume(device_t);
111 static int      vtpci_shutdown(device_t);
112 static void     vtpci_driver_added(device_t, driver_t *);
113 static void     vtpci_child_detached(device_t, device_t);
114 static int      vtpci_read_ivar(device_t, device_t, int, uintptr_t *);
115 static int      vtpci_write_ivar(device_t, device_t, int, uintptr_t);
116
117 static uint64_t vtpci_negotiate_features(device_t, uint64_t);
118 static int      vtpci_with_feature(device_t, uint64_t);
119 static int      vtpci_alloc_virtqueues(device_t, int, int,
120                     struct vq_alloc_info *);
121 static int      vtpci_setup_intr(device_t, lwkt_serialize_t);
122 static void     vtpci_stop(device_t);
123 static int      vtpci_reinit(device_t, uint64_t);
124 static void     vtpci_reinit_complete(device_t);
125 static void     vtpci_notify_virtqueue(device_t, uint16_t);
126 static uint8_t  vtpci_get_status(device_t);
127 static void     vtpci_set_status(device_t, uint8_t);
128 static void     vtpci_read_dev_config(device_t, bus_size_t, void *, int);
129 static void     vtpci_write_dev_config(device_t, bus_size_t, void *, int);
130
131 static void     vtpci_describe_features(struct vtpci_softc *, const char *,
132                     uint64_t);
133 static void     vtpci_probe_and_attach_child(struct vtpci_softc *);
134
135 static int      vtpci_alloc_interrupts(struct vtpci_softc *, int, int,
136                     struct vq_alloc_info *);
137 static int      vtpci_alloc_intr_resources(struct vtpci_softc *, int,
138                     struct vq_alloc_info *);
139 static int      vtpci_alloc_msi(struct vtpci_softc *);
140 static int      vtpci_alloc_msix(struct vtpci_softc *, int);
141 static int      vtpci_register_msix_vector(struct vtpci_softc *, int, int);
142
143 static void     vtpci_free_interrupts(struct vtpci_softc *);
144 static void     vtpci_free_virtqueues(struct vtpci_softc *);
145 static void     vtpci_release_child_resources(struct vtpci_softc *);
146 static void     vtpci_reset(struct vtpci_softc *);
147
148 static int      vtpci_legacy_intr(void *);
149 static int      vtpci_vq_shared_intr(void *);
150 static int      vtpci_vq_intr(void *);
151 static int      vtpci_config_intr(void *);
152
153 /*
154  * I/O port read/write wrappers.
155  */
156 #define vtpci_read_config_1(sc, o)      bus_read_1((sc)->vtpci_res, (o))
157 #define vtpci_read_config_2(sc, o)      bus_read_2((sc)->vtpci_res, (o))
158 #define vtpci_read_config_4(sc, o)      bus_read_4((sc)->vtpci_res, (o))
159 #define vtpci_write_config_1(sc, o, v)  bus_write_1((sc)->vtpci_res, (o), (v))
160 #define vtpci_write_config_2(sc, o, v)  bus_write_2((sc)->vtpci_res, (o), (v))
161 #define vtpci_write_config_4(sc, o, v)  bus_write_4((sc)->vtpci_res, (o), (v))
162
163 /* Tunables. */
164 static int vtpci_disable_msix = 0;
165 TUNABLE_INT("hw.virtio.pci.disable_msix", &vtpci_disable_msix);
166
167 static device_method_t vtpci_methods[] = {
168         /* Device interface. */
169         DEVMETHOD(device_probe,                   vtpci_probe),
170         DEVMETHOD(device_attach,                  vtpci_attach),
171         DEVMETHOD(device_detach,                  vtpci_detach),
172         DEVMETHOD(device_suspend,                 vtpci_suspend),
173         DEVMETHOD(device_resume,                  vtpci_resume),
174         DEVMETHOD(device_shutdown,                vtpci_shutdown),
175
176         /* Bus interface. */
177         DEVMETHOD(bus_driver_added,               vtpci_driver_added),
178         DEVMETHOD(bus_child_detached,             vtpci_child_detached),
179         DEVMETHOD(bus_read_ivar,                  vtpci_read_ivar),
180         DEVMETHOD(bus_write_ivar,                 vtpci_write_ivar),
181
182         /* VirtIO bus interface. */
183         DEVMETHOD(virtio_bus_negotiate_features,  vtpci_negotiate_features),
184         DEVMETHOD(virtio_bus_with_feature,        vtpci_with_feature),
185         DEVMETHOD(virtio_bus_alloc_virtqueues,    vtpci_alloc_virtqueues),
186         DEVMETHOD(virtio_bus_setup_intr,          vtpci_setup_intr),
187         DEVMETHOD(virtio_bus_stop,                vtpci_stop),
188         DEVMETHOD(virtio_bus_reinit,              vtpci_reinit),
189         DEVMETHOD(virtio_bus_reinit_complete,     vtpci_reinit_complete),
190         DEVMETHOD(virtio_bus_notify_vq,           vtpci_notify_virtqueue),
191         DEVMETHOD(virtio_bus_read_device_config,  vtpci_read_dev_config),
192         DEVMETHOD(virtio_bus_write_device_config, vtpci_write_dev_config),
193
194         { 0, 0 }
195 };
196
197 static driver_t vtpci_driver = {
198         "virtio_pci",
199         vtpci_methods,
200         sizeof(struct vtpci_softc)
201 };
202
203 devclass_t vtpci_devclass;
204
205 DRIVER_MODULE(virtio_pci, pci, vtpci_driver, vtpci_devclass, 0, 0);
206 MODULE_VERSION(virtio_pci, 1);
207 MODULE_DEPEND(virtio_pci, pci, 1, 1, 1);
208 MODULE_DEPEND(virtio_pci, virtio, 1, 1, 1);
209
210 static int
211 vtpci_probe(device_t dev)
212 {
213         char desc[36];
214         const char *name;
215
216         if (pci_get_vendor(dev) != VIRTIO_PCI_VENDORID)
217                 return (ENXIO);
218
219         if (pci_get_device(dev) < VIRTIO_PCI_DEVICEID_MIN ||
220             pci_get_device(dev) > VIRTIO_PCI_DEVICEID_MAX)
221                 return (ENXIO);
222
223         if (pci_get_revid(dev) != VIRTIO_PCI_ABI_VERSION)
224                 return (ENXIO);
225
226         name = virtio_device_name(pci_get_subdevice(dev));
227         if (name == NULL)
228                 name = "Unknown";
229
230         ksnprintf(desc, sizeof(desc), "VirtIO PCI %s adapter", name);
231         device_set_desc_copy(dev, desc);
232
233         return (BUS_PROBE_DEFAULT);
234 }
235
236 static int
237 vtpci_attach(device_t dev)
238 {
239         struct vtpci_softc *sc;
240         device_t child;
241         int rid;
242
243         sc = device_get_softc(dev);
244         sc->vtpci_dev = dev;
245
246         pci_enable_busmaster(dev);
247
248         rid = PCIR_BAR(0);
249         sc->vtpci_res = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid,
250             RF_ACTIVE);
251         if (sc->vtpci_res == NULL) {
252                 device_printf(dev, "cannot map I/O space\n");
253                 return (ENXIO);
254         }
255
256         if (pci_find_extcap(dev, PCIY_MSI, NULL) != 0)
257                 sc->vtpci_flags |= VIRTIO_PCI_FLAG_NO_MSI;
258         /* XXX(vsrinivas): Check out how to get MSI-X */
259 #if OLD_MSI
260         if (pci_find_extcap(dev, PCIY_MSIX, NULL) == 0) {
261                 rid = PCIR_BAR(1);
262                 sc->vtpci_msix_res = bus_alloc_resource_any(dev,
263                     SYS_RES_MEMORY, &rid, RF_ACTIVE);
264         }
265 #endif
266         if (sc->vtpci_msix_res == NULL)
267                 sc->vtpci_flags |= VIRTIO_PCI_FLAG_NO_MSIX;
268
269         vtpci_reset(sc);
270
271         /* Tell the host we've noticed this device. */
272         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
273
274         if ((child = device_add_child(dev, NULL, -1)) == NULL) {
275                 device_printf(dev, "cannot create child device\n");
276                 vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_FAILED);
277                 vtpci_detach(dev);
278                 return (ENOMEM);
279         }
280
281         sc->vtpci_child_dev = child;
282         vtpci_probe_and_attach_child(sc);
283
284         return (0);
285 }
286
287 static int
288 vtpci_detach(device_t dev)
289 {
290         struct vtpci_softc *sc;
291         device_t child;
292         int error;
293
294         sc = device_get_softc(dev);
295
296         if ((child = sc->vtpci_child_dev) != NULL) {
297                 error = device_delete_child(dev, child);
298                 if (error)
299                         return (error);
300                 sc->vtpci_child_dev = NULL;
301         }
302
303         vtpci_reset(sc);
304
305         if (sc->vtpci_msix_res != NULL) {
306                 bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(1),
307                     sc->vtpci_msix_res);
308                 sc->vtpci_msix_res = NULL;
309         }
310
311         if (sc->vtpci_res != NULL) {
312                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0),
313                     sc->vtpci_res);
314                 sc->vtpci_res = NULL;
315         }
316
317         return (0);
318 }
319
320 static int
321 vtpci_suspend(device_t dev)
322 {
323
324         return (bus_generic_suspend(dev));
325 }
326
327 static int
328 vtpci_resume(device_t dev)
329 {
330
331         return (bus_generic_resume(dev));
332 }
333
334 static int
335 vtpci_shutdown(device_t dev)
336 {
337
338         (void) bus_generic_shutdown(dev);
339         /* Forcibly stop the host device. */
340         vtpci_stop(dev);
341
342         return (0);
343 }
344
345 static void
346 vtpci_driver_added(device_t dev, driver_t *driver)
347 {
348         struct vtpci_softc *sc;
349
350         sc = device_get_softc(dev);
351
352         vtpci_probe_and_attach_child(sc);
353 }
354
355 static void
356 vtpci_child_detached(device_t dev, device_t child)
357 {
358         struct vtpci_softc *sc;
359
360         sc = device_get_softc(dev);
361
362         vtpci_reset(sc);
363         vtpci_release_child_resources(sc);
364 }
365
366 static int
367 vtpci_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
368 {
369         struct vtpci_softc *sc;
370
371         sc = device_get_softc(dev);
372
373         if (sc->vtpci_child_dev != child)
374                 return (ENOENT);
375
376         switch (index) {
377         case VIRTIO_IVAR_DEVTYPE:
378                 *result = pci_get_subdevice(dev);
379                 break;
380         default:
381                 return (ENOENT);
382         }
383
384         return (0);
385 }
386
387 static int
388 vtpci_write_ivar(device_t dev, device_t child, int index, uintptr_t value)
389 {
390         struct vtpci_softc *sc;
391
392         sc = device_get_softc(dev);
393
394         if (sc->vtpci_child_dev != child)
395                 return (ENOENT);
396
397         switch (index) {
398         case VIRTIO_IVAR_FEATURE_DESC:
399                 sc->vtpci_child_feat_desc = (void *) value;
400                 break;
401         default:
402                 return (ENOENT);
403         }
404
405         return (0);
406 }
407
408 static uint64_t
409 vtpci_negotiate_features(device_t dev, uint64_t child_features)
410 {
411         struct vtpci_softc *sc;
412         uint64_t host_features, features;
413
414         sc = device_get_softc(dev);
415
416         host_features = vtpci_read_config_4(sc, VIRTIO_PCI_HOST_FEATURES);
417         vtpci_describe_features(sc, "host", host_features);
418
419         /*
420          * Limit negotiated features to what the driver, virtqueue, and
421          * host all support.
422          */
423         features = host_features & child_features;
424         features = virtqueue_filter_features(features);
425         sc->vtpci_features = features;
426
427         vtpci_describe_features(sc, "negotiated", features);
428         vtpci_write_config_4(sc, VIRTIO_PCI_GUEST_FEATURES, features);
429
430         return (features);
431 }
432
433 static int
434 vtpci_with_feature(device_t dev, uint64_t feature)
435 {
436         struct vtpci_softc *sc;
437
438         sc = device_get_softc(dev);
439
440         return ((sc->vtpci_features & feature) != 0);
441 }
442
443 static int
444 vtpci_alloc_virtqueues(device_t dev, int flags, int nvqs,
445     struct vq_alloc_info *vq_info)
446 {
447         struct vtpci_softc *sc;
448         struct vtpci_virtqueue *vqx;
449         struct vq_alloc_info *info;
450         int queue, error;
451         uint16_t vq_size;
452
453         sc = device_get_softc(dev);
454
455         if (sc->vtpci_nvqs != 0 || nvqs <= 0 ||
456             nvqs > VIRTIO_MAX_VIRTQUEUES)
457                 return (EINVAL);
458
459         error = vtpci_alloc_interrupts(sc, flags, nvqs, vq_info);
460         if (error) {
461                 device_printf(dev, "cannot allocate interrupts\n");
462                 return (error);
463         }
464
465         if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
466                 error = vtpci_register_msix_vector(sc,
467                     VIRTIO_MSI_CONFIG_VECTOR, 0);
468                 if (error)
469                         return (error);
470         }
471
472         for (queue = 0; queue < nvqs; queue++) {
473                 vqx = &sc->vtpci_vqx[queue];
474                 info = &vq_info[queue];
475
476                 vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_SEL, queue);
477
478                 vq_size = vtpci_read_config_2(sc, VIRTIO_PCI_QUEUE_NUM);
479                 error = virtqueue_alloc(dev, queue, vq_size,
480                     VIRTIO_PCI_VRING_ALIGN, 0xFFFFFFFFUL, info, &vqx->vq);
481                 if (error)
482                         return (error);
483
484                 if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
485                         error = vtpci_register_msix_vector(sc,
486                             VIRTIO_MSI_QUEUE_VECTOR, vqx->ires_idx);
487                         if (error)
488                                 return (error);
489                 }
490
491                 vtpci_write_config_4(sc, VIRTIO_PCI_QUEUE_PFN,
492                     virtqueue_paddr(vqx->vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT);
493
494                 *info->vqai_vq = vqx->vq;
495                 sc->vtpci_nvqs++;
496         }
497
498         return (0);
499 }
500
501 static int
502 vtpci_setup_intr(device_t dev, lwkt_serialize_t slz)
503 {
504         struct vtpci_softc *sc;
505         struct vtpci_intr_resource *ires;
506         struct vtpci_virtqueue *vqx;
507         int i, flags, error;
508
509         sc = device_get_softc(dev);
510         flags = INTR_MPSAFE;
511         ires = &sc->vtpci_intr_res[0];
512
513         if ((sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) == 0) {
514                 error = bus_setup_intr(dev, ires->irq, flags,
515                                        (driver_intr_t *) vtpci_legacy_intr,
516                                        sc, &ires->intrhand, slz);
517                 return (error);
518         }
519
520         error = bus_setup_intr(dev, ires->irq, flags,
521                                (driver_intr_t *) vtpci_config_intr,
522                                sc, &ires->intrhand, slz);
523         if (error)
524                 return (error);
525
526         if (sc->vtpci_flags & VIRTIO_PCI_FLAG_SHARED_MSIX) {
527                 ires = &sc->vtpci_intr_res[1];
528                 error = bus_setup_intr(dev, ires->irq, flags,
529                                        (driver_intr_t *) vtpci_vq_shared_intr,
530                                        sc, &ires->intrhand, slz);
531
532                 return (error);
533         }
534
535         /* Setup an interrupt handler for each virtqueue. */
536         for (i = 0; i < sc->vtpci_nvqs; i++) {
537                 vqx = &sc->vtpci_vqx[i];
538                 if (vqx->ires_idx < 1)
539                         continue;
540
541                 ires = &sc->vtpci_intr_res[vqx->ires_idx];
542                 error = bus_setup_intr(dev, ires->irq, flags,
543                                        (driver_intr_t *) vtpci_vq_intr,
544                                        vqx->vq, &ires->intrhand, slz);
545                 if (error)
546                         return (error);
547         }
548
549         return (0);
550 }
551
552 static void
553 vtpci_stop(device_t dev)
554 {
555         vtpci_reset(device_get_softc(dev));
556 }
557
558 static int
559 vtpci_reinit(device_t dev, uint64_t features)
560 {
561         struct vtpci_softc *sc;
562         struct vtpci_virtqueue *vqx;
563         struct virtqueue *vq;
564         int queue, error;
565         uint16_t vq_size;
566
567         sc = device_get_softc(dev);
568
569         /*
570          * Redrive the device initialization. This is a bit of an abuse
571          * of the specification, but both VirtualBox and QEMU/KVM seem
572          * to play nice. We do not allow the host device to change from
573          * what was originally negotiated beyond what the guest driver
574          * changed (MSIX state should not change, number of virtqueues
575          * and their size remain the same, etc).
576          */
577
578         if (vtpci_get_status(dev) != VIRTIO_CONFIG_STATUS_RESET)
579                 vtpci_stop(dev);
580
581         /*
582          * Quickly drive the status through ACK and DRIVER. The device
583          * does not become usable again until vtpci_reinit_complete().
584          */
585         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
586         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER);
587
588         vtpci_negotiate_features(dev, features);
589
590         if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
591                 error = vtpci_register_msix_vector(sc,
592                     VIRTIO_MSI_CONFIG_VECTOR, 0);
593                 if (error)
594                         return (error);
595         }
596
597         for (queue = 0; queue < sc->vtpci_nvqs; queue++) {
598                 vqx = &sc->vtpci_vqx[queue];
599                 vq = vqx->vq;
600
601                 KASSERT(vq != NULL, ("vq %d not allocated", queue));
602                 vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_SEL, queue);
603
604                 vq_size = vtpci_read_config_2(sc, VIRTIO_PCI_QUEUE_NUM);
605                 error = virtqueue_reinit(vq, vq_size);
606                 if (error)
607                         return (error);
608
609                 if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
610                         error = vtpci_register_msix_vector(sc,
611                             VIRTIO_MSI_QUEUE_VECTOR, vqx->ires_idx);
612                         if (error)
613                                 return (error);
614                 }
615
616                 vtpci_write_config_4(sc, VIRTIO_PCI_QUEUE_PFN,
617                     virtqueue_paddr(vqx->vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT);
618         }
619
620         return (0);
621 }
622
623 static void
624 vtpci_reinit_complete(device_t dev)
625 {
626
627         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER_OK);
628 }
629
630 static void
631 vtpci_notify_virtqueue(device_t dev, uint16_t queue)
632 {
633         struct vtpci_softc *sc;
634
635         sc = device_get_softc(dev);
636
637         vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_NOTIFY, queue);
638 }
639
640 static uint8_t
641 vtpci_get_status(device_t dev)
642 {
643         struct vtpci_softc *sc;
644
645         sc = device_get_softc(dev);
646
647         return (vtpci_read_config_1(sc, VIRTIO_PCI_STATUS));
648 }
649
650 static void
651 vtpci_set_status(device_t dev, uint8_t status)
652 {
653         struct vtpci_softc *sc;
654
655         sc = device_get_softc(dev);
656
657         if (status != VIRTIO_CONFIG_STATUS_RESET)
658                 status |= vtpci_get_status(dev);
659
660         vtpci_write_config_1(sc, VIRTIO_PCI_STATUS, status);
661 }
662
663 static void
664 vtpci_read_dev_config(device_t dev, bus_size_t offset,
665     void *dst, int length)
666 {
667         struct vtpci_softc *sc;
668         bus_size_t off;
669         uint8_t *d;
670         int size;
671
672         sc = device_get_softc(dev);
673         off = VIRTIO_PCI_CONFIG(sc) + offset;
674
675         for (d = dst; length > 0; d += size, off += size, length -= size) {
676                 if (length >= 4) {
677                         size = 4;
678                         *(uint32_t *)d = vtpci_read_config_4(sc, off);
679                 } else if (length >= 2) {
680                         size = 2;
681                         *(uint16_t *)d = vtpci_read_config_2(sc, off);
682                 } else {
683                         size = 1;
684                         *d = vtpci_read_config_1(sc, off);
685                 }
686         }
687 }
688
689 static void
690 vtpci_write_dev_config(device_t dev, bus_size_t offset,
691     void *src, int length)
692 {
693         struct vtpci_softc *sc;
694         bus_size_t off;
695         uint8_t *s;
696         int size;
697
698         sc = device_get_softc(dev);
699         off = VIRTIO_PCI_CONFIG(sc) + offset;
700
701         for (s = src; length > 0; s += size, off += size, length -= size) {
702                 if (length >= 4) {
703                         size = 4;
704                         vtpci_write_config_4(sc, off, *(uint32_t *)s);
705                 } else if (length >= 2) {
706                         size = 2;
707                         vtpci_write_config_2(sc, off, *(uint16_t *)s);
708                 } else {
709                         size = 1;
710                         vtpci_write_config_1(sc, off, *s);
711                 }
712         }
713 }
714
715 static void
716 vtpci_describe_features(struct vtpci_softc *sc, const char *msg,
717     uint64_t features)
718 {
719         device_t dev, child;
720
721         dev = sc->vtpci_dev;
722         child = sc->vtpci_child_dev;
723
724         if (device_is_attached(child) && bootverbose == 0)
725                 return;
726
727         virtio_describe(dev, msg, features, sc->vtpci_child_feat_desc);
728 }
729
730 static void
731 vtpci_probe_and_attach_child(struct vtpci_softc *sc)
732 {
733         device_t dev, child;
734
735         dev = sc->vtpci_dev;
736         child = sc->vtpci_child_dev;
737
738         if (child == NULL)
739                 return;
740
741         if (device_get_state(child) != DS_NOTPRESENT)
742                 return;
743
744         if (device_probe_child(dev, child) != 0)
745                 return;
746
747         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER);
748         if (DEVICE_ATTACH(child) != 0) {
749                 vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_FAILED);
750                 vtpci_reset(sc);
751                 vtpci_release_child_resources(sc);
752
753                 /* Reset status for future attempt. */
754                 vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
755         } else
756                 vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER_OK);
757 }
758
759 static int
760 vtpci_alloc_interrupts(struct vtpci_softc *sc, int flags, int nvqs,
761     struct vq_alloc_info *vq_info)
762 {
763         int i, nvectors, error;
764
765         /*
766          * Only allocate a vector for virtqueues that are actually
767          * expecting an interrupt.
768          */
769         for (nvectors = 0, i = 0; i < nvqs; i++)
770                 if (vq_info[i].vqai_intr != NULL)
771                         nvectors++;
772
773         if (vtpci_disable_msix != 0 ||
774             sc->vtpci_flags & VIRTIO_PCI_FLAG_NO_MSIX ||
775             flags & VIRTIO_ALLOC_VQS_DISABLE_MSIX ||
776             vtpci_alloc_msix(sc, nvectors) != 0) {
777                 /*
778                  * Use MSI interrupts if available. Otherwise, we fallback
779                  * to legacy interrupts.
780                  */
781                 if ((sc->vtpci_flags & VIRTIO_PCI_FLAG_NO_MSI) == 0 &&
782                     vtpci_alloc_msi(sc) == 0)
783                         sc->vtpci_flags |= VIRTIO_PCI_FLAG_MSI;
784
785                 sc->vtpci_nintr_res = 1;
786         }
787
788         error = vtpci_alloc_intr_resources(sc, nvqs, vq_info);
789
790         return (error);
791 }
792
793 static int
794 vtpci_alloc_intr_resources(struct vtpci_softc *sc, int nvqs,
795     struct vq_alloc_info *vq_info)
796 {
797         device_t dev;
798         struct resource *irq;
799         struct vtpci_virtqueue *vqx;
800         int i, rid, flags, res_idx;
801
802         dev = sc->vtpci_dev;
803         flags = RF_ACTIVE;
804
805         if ((sc->vtpci_flags &
806             (VIRTIO_PCI_FLAG_MSI | VIRTIO_PCI_FLAG_MSIX)) == 0) {
807                 rid = 0;
808                 flags |= RF_SHAREABLE;
809         } else
810                 rid = 1;
811
812         for (i = 0; i < sc->vtpci_nintr_res; i++) {
813                 irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, flags);
814                 if (irq == NULL)
815                         return (ENXIO);
816
817                 sc->vtpci_intr_res[i].irq = irq;
818                 sc->vtpci_intr_res[i].rid = rid++;
819         }
820
821         /*
822          * Map the virtqueue into the correct index in vq_intr_res[]. Note the
823          * first index is reserved for configuration changes notifications.
824          */
825         for (i = 0, res_idx = 1; i < nvqs; i++) {
826                 vqx = &sc->vtpci_vqx[i];
827
828                 if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
829                         if (vq_info[i].vqai_intr == NULL)
830                                 vqx->ires_idx = -1;
831                         else if (sc->vtpci_flags & VIRTIO_PCI_FLAG_SHARED_MSIX)
832                                 vqx->ires_idx = res_idx;
833                         else
834                                 vqx->ires_idx = res_idx++;
835                 } else
836                         vqx->ires_idx = -1;
837         }
838
839         return (0);
840 }
841
842 static int
843 vtpci_alloc_msi(struct vtpci_softc *sc)
844 {
845         device_t dev;
846         int nmsi;
847         u_int irq_flags;
848
849         dev = sc->vtpci_dev;
850         nmsi = pci_msi_count(dev);
851
852         if (nmsi < 1)
853                 return (1);
854
855         sc->vtpci_irq_rid = 0;
856         sc->vtpci_irq_type = pci_alloc_1intr(dev, 1,
857             &sc->vtpci_irq_rid, &irq_flags);
858
859
860         return (1);
861 }
862
863 static int
864 vtpci_alloc_msix(struct vtpci_softc *sc, int nvectors)
865 {
866         /* XXX(vsrinivas): Huh? Is this how MSI-X works?*/
867         /* XXX(vsrinivas): All of this was disabled... */
868 #ifdef OLD_MSI
869         device_t dev;
870         int nmsix, cnt, required;
871
872         dev = sc->vtpci_dev;
873
874         nmsix = pci_msix_count(dev);
875         if (nmsix < 1)
876                 return (1);
877
878         /* An additional vector is needed for the config changes. */
879         required = nvectors + 1;
880         if (nmsix >= required) {
881                 cnt = required;
882                 if (pci_alloc_msix(dev, &cnt) == 0 && cnt >= required)
883                         goto out;
884
885                 pci_release_msi(dev);
886         }
887
888         /* Attempt shared MSIX configuration. */
889         required = 2;
890         if (nmsix >= required) {
891                 cnt = required;
892                 if (pci_alloc_msix(dev, &cnt) == 0 && cnt >= required) {
893                         sc->vtpci_flags |= VIRTIO_PCI_FLAG_SHARED_MSIX;
894                         goto out;
895                 }
896
897                 pci_release_msi(dev);
898         }
899
900         return (1);
901
902 out:
903         sc->vtpci_nintr_res = required;
904         sc->vtpci_flags |= VIRTIO_PCI_FLAG_MSIX;
905
906         if (bootverbose) {
907                 if (sc->vtpci_flags & VIRTIO_PCI_FLAG_SHARED_MSIX)
908                         device_printf(dev, "using shared virtqueue MSIX\n");
909                 else
910                         device_printf(dev, "using per virtqueue MSIX\n");
911         }
912 #endif
913         return (0);
914 }
915
916 static int
917 vtpci_register_msix_vector(struct vtpci_softc *sc, int offset, int res_idx)
918 {
919         device_t dev;
920         uint16_t vector;
921
922         dev = sc->vtpci_dev;
923
924         if (offset != VIRTIO_MSI_CONFIG_VECTOR &&
925             offset != VIRTIO_MSI_QUEUE_VECTOR)
926                 return (EINVAL);
927
928         if (res_idx != -1) {
929                 /* Map from rid to host vector. */
930                 vector = sc->vtpci_intr_res[res_idx].rid - 1;
931         } else
932                 vector = VIRTIO_MSI_NO_VECTOR;
933
934         /* The first resource is special; make sure it is used correctly. */
935         if (res_idx == 0) {
936                 KASSERT(vector == 0, ("unexpected config vector"));
937                 KASSERT(offset == VIRTIO_MSI_CONFIG_VECTOR,
938                     ("unexpected config offset"));
939         }
940
941         vtpci_write_config_2(sc, offset, vector);
942
943         if (vtpci_read_config_2(sc, offset) != vector) {
944                 device_printf(dev, "insufficient host resources for "
945                     "MSIX interrupts\n");
946                 return (ENODEV);
947         }
948
949         return (0);
950 }
951
952 static void
953 vtpci_free_interrupts(struct vtpci_softc *sc)
954 {
955         device_t dev;
956         struct vtpci_intr_resource *ires;
957         int i;
958
959         dev = sc->vtpci_dev;
960         sc->vtpci_nintr_res = 0;
961
962         if (sc->vtpci_flags & (VIRTIO_PCI_FLAG_MSI | VIRTIO_PCI_FLAG_MSIX)) {
963                 pci_release_msi(dev);
964                 sc->vtpci_flags &= ~(VIRTIO_PCI_FLAG_MSI |
965                     VIRTIO_PCI_FLAG_MSIX | VIRTIO_PCI_FLAG_SHARED_MSIX);
966         }
967
968         for (i = 0; i < 1 + VIRTIO_MAX_VIRTQUEUES; i++) {
969                 ires = &sc->vtpci_intr_res[i];
970
971                 if (ires->intrhand != NULL) {
972                         bus_teardown_intr(dev, ires->irq, ires->intrhand);
973                         ires->intrhand = NULL;
974                 }
975
976                 if (ires->irq != NULL) {
977                         bus_release_resource(dev, SYS_RES_IRQ, ires->rid,
978                             ires->irq);
979                         ires->irq = NULL;
980                 }
981
982                 ires->rid = -1;
983         }
984 }
985
986 static void
987 vtpci_free_virtqueues(struct vtpci_softc *sc)
988 {
989         struct vtpci_virtqueue *vqx;
990         int i;
991
992         sc->vtpci_nvqs = 0;
993
994         for (i = 0; i < VIRTIO_MAX_VIRTQUEUES; i++) {
995                 vqx = &sc->vtpci_vqx[i];
996
997                 if (vqx->vq != NULL) {
998                         virtqueue_free(vqx->vq);
999                         vqx->vq = NULL;
1000                 }
1001         }
1002 }
1003
1004 static void
1005 vtpci_release_child_resources(struct vtpci_softc *sc)
1006 {
1007
1008         vtpci_free_interrupts(sc);
1009         vtpci_free_virtqueues(sc);
1010 }
1011
1012 static void
1013 vtpci_reset(struct vtpci_softc *sc)
1014 {
1015
1016         /*
1017          * Setting the status to RESET sets the host device to
1018          * the original, uninitialized state.
1019          */
1020         vtpci_set_status(sc->vtpci_dev, VIRTIO_CONFIG_STATUS_RESET);
1021 }
1022
1023 static int
1024 vtpci_legacy_intr(void *xsc)
1025 {
1026         struct vtpci_softc *sc;
1027         struct vtpci_virtqueue *vqx;
1028         int i;
1029         uint8_t isr;
1030
1031         sc = xsc;
1032         vqx = &sc->vtpci_vqx[0];
1033
1034         /* Reading the ISR also clears it. */
1035         isr = vtpci_read_config_1(sc, VIRTIO_PCI_ISR);
1036
1037         if (isr & VIRTIO_PCI_ISR_CONFIG)
1038                 vtpci_config_intr(sc);
1039
1040         if (isr & VIRTIO_PCI_ISR_INTR)
1041                 for (i = 0; i < sc->vtpci_nvqs; i++, vqx++)
1042                         virtqueue_intr(vqx->vq);
1043
1044         return isr;
1045 }
1046
1047 static int
1048 vtpci_vq_shared_intr(void *xsc)
1049 {
1050         struct vtpci_softc *sc;
1051         struct vtpci_virtqueue *vqx;
1052         int i, rc;
1053
1054         rc = 0;
1055         sc = xsc;
1056         vqx = &sc->vtpci_vqx[0];
1057
1058         for (i = 0; i < sc->vtpci_nvqs; i++, vqx++)
1059                 rc |= virtqueue_intr(vqx->vq);
1060
1061         return rc;
1062 }
1063
1064 static int
1065 vtpci_vq_intr(void *xvq)
1066 {
1067         struct virtqueue *vq;
1068         int rc;
1069
1070         vq = xvq;
1071         rc = virtqueue_intr(vq);
1072
1073         return rc;
1074 }
1075
1076 static int
1077 vtpci_config_intr(void *xsc)
1078 {
1079         struct vtpci_softc *sc;
1080         device_t child;
1081         int rc;
1082
1083         rc = 0;
1084         sc = xsc;
1085         child = sc->vtpci_child_dev;
1086
1087         if (child != NULL)
1088                 rc = VIRTIO_CONFIG_CHANGE(child);
1089
1090         return rc;
1091 }