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

   1 /******************************************************************************
   2  * Copyright (c) 2011 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 <cpu.h>
  15 #include <helpers.h>
  16 #include <byteorder.h>
  17 #include "virtio.h"
  18 #include "virtio-blk.h"
  19 #include "virtio-internal.h"
  20
  21 #define DEFAULT_SECTOR_SIZE 512
  22 #define DRIVER_FEATURE_SUPPORT  (VIRTIO_BLK_F_BLK_SIZE | VIRTIO_F_VERSION_1)
  23
  24 static struct vqs vq;
  25
  26 /**
  27  * Initialize virtio-block device.
  28  * @param  dev  pointer to virtio device information
  29  */
  30 int
  31 virtioblk_init(struct virtio_device *dev)
  32 {
  33         struct vring_avail *vq_avail;
  34         int blk_size = DEFAULT_SECTOR_SIZE;
  35         uint64_t features;
  36         int status = VIRTIO_STAT_ACKNOWLEDGE;
  37
  38         /* Reset device */
  39         virtio_reset_device(dev);
  40
  41         /* Acknowledge device. */
  42         virtio_set_status(dev, status);
  43
  44         /* Tell HV that we know how to drive the device. */
  45         status |= VIRTIO_STAT_DRIVER;
  46         virtio_set_status(dev, status);
  47
  48         if (dev->is_modern) {
  49                 /* Negotiate features and sets FEATURES_OK if successful */
  50                 if (virtio_negotiate_guest_features(dev, DRIVER_FEATURE_SUPPORT))
  51                         goto dev_error;
  52
  53                 virtio_get_status(dev, &status);
  54         } else {
  55                 /* Device specific setup - we support F_BLK_SIZE */
  56                 virtio_set_guest_features(dev,  VIRTIO_BLK_F_BLK_SIZE);
  57         }
  58
  59         if (virtio_queue_init_vq(dev, &vq, 0))
  60                 goto dev_error;
  61
  62         vq_avail = virtio_get_vring_avail(dev, 0);
  63         vq_avail->flags = virtio_cpu_to_modern16(dev, VRING_AVAIL_F_NO_INTERRUPT);
  64         vq_avail->idx = 0;
  65
  66         /* Tell HV that setup succeeded */
  67         status |= VIRTIO_STAT_DRIVER_OK;
  68         virtio_set_status(dev, status);
  69
  70         features = virtio_get_host_features(dev);
  71         if (features & VIRTIO_BLK_F_BLK_SIZE) {
  72                 blk_size = virtio_get_config(dev,
  73                                              offset_of(struct virtio_blk_cfg, blk_size),
  74                                              sizeof(blk_size));
  75         }
  76
  77         return blk_size;
  78 dev_error:
  79         printf("%s: failed\n", __func__);
  80         status |= VIRTIO_STAT_FAILED;
  81         virtio_set_status(dev, status);
  82         return 0;
  83 }
  84
  85
  86 /**
  87  * Shutdown the virtio-block device.
  88  * @param  dev  pointer to virtio device information
  89  */
  90 void
  91 virtioblk_shutdown(struct virtio_device *dev)
  92 {
  93         /* Quiesce device */
  94         virtio_set_status(dev, VIRTIO_STAT_FAILED);
  95
  96         /* Reset device */
  97         virtio_reset_device(dev);
  98 }
  99
 100 static void fill_blk_hdr(struct virtio_blk_req *blkhdr, bool is_modern,
 101                          uint32_t type, uint32_t ioprio, uint32_t sector)
 102 {
 103         if (is_modern) {
 104                 blkhdr->type = cpu_to_le32(type);
 105                 blkhdr->ioprio = cpu_to_le32(ioprio);
 106                 blkhdr->sector = cpu_to_le64(sector);
 107         } else {
 108                 blkhdr->type = type;
 109                 blkhdr->ioprio = ioprio;
 110                 blkhdr->sector = sector;
 111         }
 112 }
 113
 114 /**
 115  * Read blocks
 116  * @param  reg  pointer to "reg" property
 117  * @param  buf  pointer to destination buffer
 118  * @param  blocknum  block number of the first block that should be read
 119  * @param  cnt  amount of blocks that should be read
 120  * @return number of blocks that have been read successfully
 121  */
 122 int
 123 virtioblk_read(struct virtio_device *dev, char *buf, uint64_t blocknum, long cnt)
 124 {
 125         struct vring_desc *desc;
 126         int id;
 127         static struct virtio_blk_req blkhdr;
 128         //struct virtio_blk_config *blkconf;
 129         uint64_t capacity;
 130         uint32_t vq_size, time;
 131         struct vring_desc *vq_desc;             /* Descriptor vring */
 132         struct vring_avail *vq_avail;           /* "Available" vring */
 133         struct vring_used *vq_used;             /* "Used" vring */
 134         volatile uint8_t status = -1;
 135         volatile uint16_t *current_used_idx;
 136         uint16_t last_used_idx, avail_idx;
 137         int blk_size = DEFAULT_SECTOR_SIZE;
 138
 139         //printf("virtioblk_read: dev=%p buf=%p blocknum=%li count=%li\n",
 140         //      dev, buf, blocknum, cnt);
 141
 142         /* Check whether request is within disk capacity */
 143         capacity = virtio_get_config(dev,
 144                         offset_of(struct virtio_blk_cfg, capacity),
 145                         sizeof(capacity));
 146         if (blocknum + cnt - 1 > capacity) {
 147                 puts("virtioblk_read: Access beyond end of device!");
 148                 return 0;
 149         }
 150
 151         blk_size = virtio_get_config(dev,
 152                         offset_of(struct virtio_blk_cfg, blk_size),
 153                         sizeof(blk_size));
 154         if (blk_size % DEFAULT_SECTOR_SIZE) {
 155                 fprintf(stderr, "virtio-blk: Unaligned sector read %d\n", blk_size);
 156                 return 0;
 157         }
 158
 159         vq_size = virtio_get_qsize(dev, 0);
 160         vq_desc = virtio_get_vring_desc(dev, 0);
 161         vq_avail = virtio_get_vring_avail(dev, 0);
 162         vq_used = virtio_get_vring_used(dev, 0);
 163
 164         avail_idx = virtio_modern16_to_cpu(dev, vq_avail->idx);
 165
 166         last_used_idx = vq_used->idx;
 167         current_used_idx = &vq_used->idx;
 168
 169         /* Set up header */
 170         fill_blk_hdr(&blkhdr, dev->is_modern, VIRTIO_BLK_T_IN | VIRTIO_BLK_T_BARRIER,
 171                      1, blocknum * blk_size / DEFAULT_SECTOR_SIZE);
 172
 173         /* Determine descriptor index */
 174         id = (avail_idx * 3) % vq_size;
 175
 176         /* Set up virtqueue descriptor for header */
 177         desc = &vq_desc[id];
 178         virtio_fill_desc(desc, dev->is_modern, (uint64_t)&blkhdr,
 179                          sizeof(struct virtio_blk_req),
 180                          VRING_DESC_F_NEXT, (id + 1) % vq_size);
 181
 182         /* Set up virtqueue descriptor for data */
 183         desc = &vq_desc[(id + 1) % vq_size];
 184         virtio_fill_desc(desc, dev->is_modern, (uint64_t)buf, cnt * blk_size,
 185                          VRING_DESC_F_NEXT | VRING_DESC_F_WRITE,
 186                          (id + 2) % vq_size);
 187
 188         /* Set up virtqueue descriptor for status */
 189         desc = &vq_desc[(id + 2) % vq_size];
 190         virtio_fill_desc(desc, dev->is_modern, (uint64_t)&status, 1,
 191                          VRING_DESC_F_WRITE, 0);
 192
 193         vq_avail->ring[avail_idx % vq_size] = virtio_cpu_to_modern16 (dev, id);
 194         mb();
 195         vq_avail->idx = virtio_cpu_to_modern16(dev, avail_idx + 1);
 196
 197         /* Tell HV that the queue is ready */
 198         virtio_queue_notify(dev, 0);
 199
 200         /* Wait for host to consume the descriptor */
 201         time = SLOF_GetTimer() + VIRTIO_TIMEOUT;
 202         while (*current_used_idx == last_used_idx) {
 203                 // do something better
 204                 mb();
 205                 if (time < SLOF_GetTimer())
 206                         break;
 207         }
 208
 209         if (status == 0)
 210                 return cnt;
 211
 212         printf("virtioblk_read failed! status = %i\n", status);
 213
 214         return 0;
 215 }