qemu/roms/SLOF/lib/libvirtio/virtio-scsi.c

   1 /******************************************************************************
   2  * Copyright (c) 2012 IBM Corporation
   3  * All rights reserved.
   4  * This program and the accompanying materials
   5  * are made available under the terms of the BSD License
   6  * which accompanies this distribution, and is available at
   7  * http://www.opensource.org/licenses/bsd-license.php
   8  *
   9  * Contributors:
  10  *     IBM Corporation - initial implementation
  11  *****************************************************************************/
  12
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <cpu.h>
  16 #include <helpers.h>
  17 #include "virtio.h"
  18 #include "virtio-internal.h"
  19 #include "virtio-scsi.h"
  20
  21 int virtioscsi_send(struct virtio_device *dev,
  22                     struct virtio_scsi_req_cmd *req,
  23                     struct virtio_scsi_resp_cmd *resp,
  24                     int is_read, void *buf, uint64_t buf_len)
  25 {
  26         struct vring_desc *vq_desc;             /* Descriptor vring */
  27         struct vring_avail *vq_avail;           /* "Available" vring */
  28         struct vring_used *vq_used;             /* "Used" vring */
  29
  30         volatile uint16_t *current_used_idx;
  31         uint16_t last_used_idx, avail_idx;
  32         int id;
  33         uint32_t vq_size, time;
  34
  35         int vq = VIRTIO_SCSI_REQUEST_VQ;
  36
  37         vq_size = virtio_get_qsize(dev, vq);
  38         vq_desc = virtio_get_vring_desc(dev, vq);
  39         vq_avail = virtio_get_vring_avail(dev, vq);
  40         vq_used = virtio_get_vring_used(dev, vq);
  41
  42         avail_idx = virtio_modern16_to_cpu(dev, vq_avail->idx);
  43
  44         last_used_idx = vq_used->idx;
  45         current_used_idx = &vq_used->idx;
  46
  47         /* Determine descriptor index */
  48         id = (avail_idx * 3) % vq_size;
  49         virtio_fill_desc(&vq_desc[id], dev->is_modern, (uint64_t)req, sizeof(*req), VRING_DESC_F_NEXT,
  50                          (id + 1) % vq_size);
  51
  52         /* Set up virtqueue descriptor for data */
  53         if (buf && buf_len) {
  54                 virtio_fill_desc(&vq_desc[(id + 1) % vq_size], dev->is_modern,
  55                                  (uint64_t)resp, sizeof(*resp),
  56                                  VRING_DESC_F_NEXT | VRING_DESC_F_WRITE,
  57                                  (id + 2) % vq_size);
  58                 /* Set up virtqueue descriptor for status */
  59                 virtio_fill_desc(&vq_desc[(id + 2) % vq_size], dev->is_modern,
  60                                  (uint64_t)buf, buf_len,
  61                                  (is_read ? VRING_DESC_F_WRITE : 0), 0);
  62         } else {
  63                 virtio_fill_desc(&vq_desc[(id + 1) % vq_size], dev->is_modern,
  64                                  (uint64_t)resp, sizeof(*resp),
  65                                  VRING_DESC_F_WRITE, 0);
  66         }
  67
  68         vq_avail->ring[avail_idx % vq_size] = virtio_cpu_to_modern16(dev, id);
  69         mb();
  70         vq_avail->idx = virtio_cpu_to_modern16(dev, avail_idx + 1);
  71
  72         /* Tell HV that the vq is ready */
  73         virtio_queue_notify(dev, vq);
  74
  75         /* Wait for host to consume the descriptor */
  76         time = SLOF_GetTimer() + VIRTIO_TIMEOUT;
  77         while (*current_used_idx == last_used_idx) {
  78                 // do something better
  79                 mb();
  80                 if (time < SLOF_GetTimer())
  81                         break;
  82         }
  83
  84         return 0;
  85 }
  86
  87 /**
  88  * Initialize virtio-block device.
  89  * @param  dev  pointer to virtio device information
  90  */
  91 int virtioscsi_init(struct virtio_device *dev)
  92 {
  93         struct vring_avail *vq_avail;
  94         unsigned int idx = 0;
  95         int qsize = 0;
  96         int status = VIRTIO_STAT_ACKNOWLEDGE;
  97
  98         /* Reset device */
  99         // XXX That will clear the virtq base. We need to move
 100         //     initializing it to here anyway
 101         //
 102         //     virtio_reset_device(dev);
 103
 104         /* Acknowledge device. */
 105         virtio_set_status(dev, status);
 106
 107         /* Tell HV that we know how to drive the device. */
 108         status |= VIRTIO_STAT_DRIVER;
 109         virtio_set_status(dev, status);
 110
 111         /* Device specific setup - we do not support special features right now */
 112         if (dev->is_modern) {
 113                 if (virtio_negotiate_guest_features(dev, VIRTIO_F_VERSION_1))
 114                         goto dev_error;
 115                 virtio_get_status(dev, &status);
 116         } else {
 117                 virtio_set_guest_features(dev, 0);
 118         }
 119
 120         while(1) {
 121                 qsize = virtio_get_qsize(dev, idx);
 122                 if (!qsize)
 123                         break;
 124                 virtio_vring_size(qsize);
 125
 126                 vq_avail = virtio_get_vring_avail(dev, idx);
 127                 vq_avail->flags = virtio_cpu_to_modern16(dev, VRING_AVAIL_F_NO_INTERRUPT);
 128                 vq_avail->idx = 0;
 129                 idx++;
 130         }
 131
 132         /* Tell HV that setup succeeded */
 133         status |= VIRTIO_STAT_DRIVER_OK;
 134         virtio_set_status(dev, status);
 135
 136         return 0;
 137 dev_error:
 138         printf("%s: failed\n", __func__);
 139         status |= VIRTIO_STAT_FAILED;
 140         virtio_set_status(dev, status);
 141         return -1;
 142 }
 143
 144 /**
 145  * Shutdown the virtio-block device.
 146  * @param  dev  pointer to virtio device information
 147  */
 148 void virtioscsi_shutdown(struct virtio_device *dev)
 149 {
 150         /* Quiesce device */
 151         virtio_set_status(dev, VIRTIO_STAT_FAILED);
 152
 153         /* Reset device */
 154         virtio_reset_device(dev);
 155 }