kernel/drivers/virtio/virtiovar.h

   1 /*
   2  * Copyright (c) 2010 Minoura Makoto.
   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, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 /*
  27  * Part of the file derived from `Virtio PCI Card Specification v0.8.6 DRAFT'
  28  * Appendix A.
  29  */
  30
  31 /*
  32  * An interface for efficient virtio implementation.
  33  *
  34  * This header is BSD licensed so anyone can use the definitions
  35  * to implement compatible drivers/servers.
  36  *
  37  * Copyright 2007, 2009, IBM Corporation
  38  * All rights reserved.
  39  *
  40  * Redistribution and use in source and binary forms, with or without
  41  * modification, are permitted provided that the following conditions
  42  * are met:
  43  * 1. Redistributions of source code must retain the above copyright
  44  *    notice, this list of conditions and the following disclaimer.
  45  * 2. Redistributions in binary form must reproduce the above copyright
  46  *    notice, this list of conditions and the following disclaimer in the
  47  *    documentation and/or other materials provided with the distribution.
  48  * 3. Neither the name of IBM nor the names of its contributors
  49  *    may be used to endorse or promote products derived from this software
  50  *    without specific prior written permission.
  51  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  52  * ``AS IS'' ANDANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  53  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  54  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
  55  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  56  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  57  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  58  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  59  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  60  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  61  * SUCH DAMAGE.
  62  */
  63
  64 /*
  65  * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
  66  */
  67
  68 #ifndef __VIRTIOVAR_H__
  69 #define __VIRTIOVAR_H__
  70
  71 #include <sys/types.h>
  72 #include <sys/dditypes.h>
  73 #include <sys/cmn_err.h>
  74 #include <sys/list.h>
  75
  76 #ifdef DEBUG
  77 #define dev_debug(dip, fmt, arg...) \
  78         dev_err(dip, fmt, ##arg)
  79 #else
  80 #define dev_debug(dip, fmt, arg...)
  81 #endif
  82
  83 struct vq_entry {
  84         list_node_t             qe_list;
  85         struct virtqueue        *qe_queue;
  86         uint16_t                qe_index; /* index in vq_desc array */
  87         /* followings are used only when it is the `head' entry */
  88         struct vq_entry         *qe_next;
  89         struct vring_desc       *qe_desc;
  90         ddi_dma_cookie_t        qe_indirect_dma_cookie;
  91         ddi_dma_handle_t        qe_indirect_dma_handle;
  92         ddi_acc_handle_t        qe_indirect_dma_acch;
  93         struct vring_desc       *qe_indirect_descs;
  94         unsigned int            qe_indirect_next;
  95 };
  96
  97 struct virtqueue {
  98         struct virtio_softc     *vq_owner;
  99         unsigned int            vq_num; /* queue size (# of entries) */
 100         unsigned int            vq_indirect_num;
 101         int                     vq_index; /* queue number (0, 1, ...) */
 102
 103         /* vring pointers (KVA) */
 104         struct vring_desc       *vq_descs;
 105         struct vring_avail      *vq_avail;
 106         struct vring_used       *vq_used;
 107
 108         /* virtqueue allocation info */
 109         void                    *vq_vaddr;
 110         int                     vq_availoffset;
 111         int                     vq_usedoffset;
 112         ddi_dma_cookie_t        vq_dma_cookie;
 113         ddi_dma_handle_t        vq_dma_handle;
 114         ddi_acc_handle_t        vq_dma_acch;
 115
 116         int                     vq_maxsegsize;
 117
 118         /* free entry management */
 119         struct vq_entry         *vq_entries;
 120         list_t                  vq_freelist;
 121         kmutex_t                vq_freelist_lock;
 122         int                     vq_used_entries;
 123
 124         /* enqueue/dequeue status */
 125         uint16_t                vq_avail_idx;
 126         kmutex_t                vq_avail_lock;
 127         uint16_t                vq_used_idx;
 128         kmutex_t                vq_used_lock;
 129 };
 130
 131 struct virtio_softc {
 132         dev_info_t              *sc_dev;
 133
 134         uint_t                  sc_intr_prio;
 135
 136         ddi_acc_handle_t        sc_ioh;
 137         caddr_t                 sc_io_addr;
 138         int                     sc_config_offset;
 139
 140         uint32_t                sc_features;
 141
 142         int                     sc_nvqs; /* set by the user */
 143
 144         ddi_intr_handle_t       *sc_intr_htable;
 145         int                     sc_intr_num;
 146         boolean_t               sc_intr_config;
 147         int                     sc_intr_cap;
 148         int                     sc_int_type;
 149 };
 150
 151 struct virtio_int_handler {
 152         ddi_intr_handler_t *vh_func;
 153         void *vh_priv;
 154 };
 155
 156 /* public interface */
 157 uint32_t virtio_negotiate_features(struct virtio_softc *, uint32_t);
 158 size_t virtio_show_features(uint32_t features, char *buffer, size_t len);
 159 boolean_t virtio_has_feature(struct virtio_softc *sc, uint32_t feature);
 160 void virtio_set_status(struct virtio_softc *sc, unsigned int);
 161 #define virtio_device_reset(sc) virtio_set_status((sc), 0)
 162
 163 uint8_t virtio_read_device_config_1(struct virtio_softc *sc,
 164                 unsigned int index);
 165 uint16_t virtio_read_device_config_2(struct virtio_softc *sc,
 166                 unsigned int index);
 167 uint32_t virtio_read_device_config_4(struct virtio_softc *sc,
 168                 unsigned int index);
 169 uint64_t virtio_read_device_config_8(struct virtio_softc *sc,
 170                 unsigned int index);
 171 void virtio_write_device_config_1(struct virtio_softc *sc,
 172                 unsigned int index, uint8_t value);
 173 void virtio_write_device_config_2(struct virtio_softc *sc,
 174                 unsigned int index, uint16_t value);
 175 void virtio_write_device_config_4(struct virtio_softc *sc,
 176                 unsigned int index, uint32_t value);
 177 void virtio_write_device_config_8(struct virtio_softc *sc,
 178                 unsigned int index, uint64_t value);
 179
 180 struct virtqueue *virtio_alloc_vq(struct virtio_softc *sc,
 181                 unsigned int index, unsigned int size,
 182                 unsigned int indirect_num, const char *name);
 183 void virtio_free_vq(struct virtqueue *);
 184 void virtio_reset(struct virtio_softc *);
 185 struct vq_entry *vq_alloc_entry(struct virtqueue *vq);
 186 void vq_free_entry(struct virtqueue *vq, struct vq_entry *qe);
 187 uint_t vq_num_used(struct virtqueue *vq);
 188 unsigned int virtio_ve_indirect_available(struct vq_entry *qe);
 189
 190 void virtio_stop_vq_intr(struct virtqueue *);
 191 void virtio_start_vq_intr(struct virtqueue *);
 192
 193 void virtio_ve_add_cookie(struct vq_entry *qe, ddi_dma_handle_t dma_handle,
 194     ddi_dma_cookie_t dma_cookie, unsigned int ncookies, boolean_t write);
 195 void virtio_ve_add_indirect_buf(struct vq_entry *qe, uint64_t paddr,
 196     uint32_t len, boolean_t write);
 197 void virtio_ve_set(struct vq_entry *qe, uint64_t paddr, uint32_t len,
 198                 boolean_t write);
 199
 200 void virtio_push_chain(struct vq_entry *qe, boolean_t sync);
 201 struct vq_entry *virtio_pull_chain(struct virtqueue *vq, uint32_t *len);
 202 void virtio_free_chain(struct vq_entry *ve);
 203 void virtio_sync_vq(struct virtqueue *vq);
 204
 205 int virtio_register_ints(struct virtio_softc *sc,
 206                 struct virtio_int_handler *config_handler,
 207                 struct virtio_int_handler vq_handlers[]);
 208 void virtio_release_ints(struct virtio_softc *sc);
 209 int virtio_enable_ints(struct virtio_softc *sc);
 210
 211 #endif /* __VIRTIOVAR_H__ */