src/hw/virtio-scsi.c - seabios - Git at Google

 // Virtio SCSI boot support.
 //
 // Copyright (C) 2012 Red Hat Inc.
 //
 // Authors:
 //  Paolo Bonzini <pbonzini@redhat.com>
 //
 // This file may be distributed under the terms of the GNU LGPLv3 license.

 #include "block.h" // struct drive_s
 #include "blockcmd.h" // scsi_drive_setup
 #include "config.h" // CONFIG_*
 #include "malloc.h" // free
 #include "output.h" // dprintf
 #include "pcidevice.h" // foreachpci
 #include "pci_ids.h" // PCI_DEVICE_ID_VIRTIO_BLK
 #include "pci_regs.h" // PCI_VENDOR_ID
 #include "stacks.h" // run_thread
 #include "std/disk.h" // DISK_RET_SUCCESS
 #include "string.h" // memset
 #include "util.h" // usleep, bootprio_find_pci_device, is_bootprio_strict
 #include "virtio-pci.h"
 #include "virtio-ring.h"
 #include "virtio-scsi.h"
 #include "virtio-mmio.h"

 struct virtio_lun_s {
     struct drive_s drive;
     struct pci_device *pci;
     void *mmio;
     char name[16];
     struct vring_virtqueue *vq;
     struct vp_device *vp;
     u16 target;
     u16 lun;
 };

 int
 virtio_scsi_process_op(struct disk_op_s *op)
 {
     if (! CONFIG_VIRTIO_SCSI)
         return 0;
     struct virtio_lun_s *vlun =
         container_of(op->drive_fl, struct virtio_lun_s, drive);
     struct vp_device *vp = vlun->vp;
     struct vring_virtqueue *vq = vlun->vq;
     struct virtio_scsi_req_cmd req;
     struct virtio_scsi_resp_cmd resp;
     struct vring_list sg[3];

     memset(&req, 0, sizeof(req));
     int blocksize = scsi_fill_cmd(op, req.cdb, 16);
     if (blocksize < 0)
         return default_process_op(op);
     req.lun[0] = 1;
     req.lun[1] = vlun->target;
     req.lun[2] = (vlun->lun >> 8) | 0x40;
     req.lun[3] = (vlun->lun & 0xff);

     u32 len = op->count * blocksize;
     int datain = scsi_is_read(op);
     int in_num = (datain ? 2 : 1);
     int out_num = (len ? 3 : 2) - in_num;

     sg[0].addr   = (void*)(&req);
     sg[0].length = sizeof(req);

     sg[out_num].addr   = (void*)(&resp);
     sg[out_num].length = sizeof(resp);

     if (len) {
         int data_idx = (datain ? 2 : 1);
         sg[data_idx].addr   = op->buf_fl;
         sg[data_idx].length = len;
     }

     /* Add to virtqueue and kick host */
     vring_add_buf(vq, sg, out_num, in_num, 0, 0);
     vring_kick(vp, vq, 1);

     /* Wait for reply */
     while (!vring_more_used(vq))
         usleep(5);

     /* Reclaim virtqueue element */
     vring_get_buf(vq, NULL);

     /* Clear interrupt status register.  Avoid leaving interrupts stuck if
      * VRING_AVAIL_F_NO_INTERRUPT was ignored and interrupts were raised.
      */
     vp_get_isr(vp);

     if (resp.response == VIRTIO_SCSI_S_OK && resp.status == 0) {
         return DISK_RET_SUCCESS;
     }
     return DISK_RET_EBADTRACK;
 }

 static void
 virtio_scsi_init_lun(struct virtio_lun_s *vlun,
                      struct pci_device *pci, void *mmio,
                      struct vp_device *vp, struct vring_virtqueue *vq,
                      u16 target, u16 lun)
 {
     memset(vlun, 0, sizeof(*vlun));
     vlun->drive.type = DTYPE_VIRTIO_SCSI;
     vlun->drive.cntl_id = pci->bdf;
     vlun->pci = pci;
     vlun->mmio = mmio;
     vlun->vp = vp;
     vlun->vq = vq;
     vlun->target = target;
     vlun->lun = lun;
     if (vlun->pci)
         snprintf(vlun->name, sizeof(vlun->name), "pci:%pP", vlun->pci);
     if (vlun->mmio)
         snprintf(vlun->name, sizeof(vlun->name), "mmio:%08x", (u32)vlun->mmio);
 }

 static int
 virtio_scsi_add_lun(u32 lun, struct drive_s *tmpl_drv)
 {
     u8 skip_nonbootable = is_bootprio_strict();
     struct virtio_lun_s *tmpl_vlun =
         container_of(tmpl_drv, struct virtio_lun_s, drive);
     int prio = -1;

     if (tmpl_vlun->pci)
         prio = bootprio_find_scsi_device(tmpl_vlun->pci, tmpl_vlun->target, lun);
     if (tmpl_vlun->mmio)
         prio = bootprio_find_scsi_mmio_device(tmpl_vlun->mmio, tmpl_vlun->target, lun);

     if (skip_nonbootable && prio < 0) {
         dprintf(1, "skipping init of a non-bootable virtio-scsi dev at %s,"
                 " target %d, lun %d\n",
                 tmpl_vlun->name, tmpl_vlun->target, lun);
         return -1;
     }

     struct virtio_lun_s *vlun = malloc_low(sizeof(*vlun));
     if (!vlun) {
         warn_noalloc();
         return -1;
     }
     virtio_scsi_init_lun(vlun, tmpl_vlun->pci, tmpl_vlun->mmio,tmpl_vlun->vp,
                          tmpl_vlun->vq, tmpl_vlun->target, lun);

     if (vlun->pci)
         boot_lchs_find_scsi_device(vlun->pci, vlun->target, vlun->lun,
                                    &(vlun->drive.lchs));
     int ret = scsi_drive_setup(&vlun->drive, "virtio-scsi", prio);
     if (ret)
         goto fail;
     return 0;

 fail:
     free(vlun);
     return -1;
 }

 static int
 virtio_scsi_scan_target(struct pci_device *pci, void *mmio, struct vp_device *vp,
                         struct vring_virtqueue *vq, u16 target)
 {

     struct virtio_lun_s vlun0;

     virtio_scsi_init_lun(&vlun0, pci, mmio, vp, vq, target, 0);

     int ret = scsi_rep_luns_scan(&vlun0.drive, virtio_scsi_add_lun);
     return ret < 0 ? 0 : ret;
 }

 static void
 init_virtio_scsi(void *data)
 {
     struct pci_device *pci = data;
     dprintf(1, "found virtio-scsi at %pP\n", pci);
     struct vring_virtqueue *vq = NULL;
     struct vp_device *vp = malloc_high(sizeof(*vp));
     if (!vp) {
         warn_noalloc();
         return;
     }
     vp_init_simple(vp, pci);
     u8 status = VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER;

     if (vp->use_modern) {
         u64 features = vp_get_features(vp);
         u64 version1 = 1ull << VIRTIO_F_VERSION_1;
         u64 iommu_platform = 1ull << VIRTIO_F_IOMMU_PLATFORM;
         if (!(features & version1)) {
             dprintf(1, "modern device without virtio_1 feature bit: %pP\n", pci);
             goto fail;
         }

         vp_set_features(vp, features & (version1 | iommu_platform));
         status |= VIRTIO_CONFIG_S_FEATURES_OK;
         vp_set_status(vp, status);
         if (!(vp_get_status(vp) & VIRTIO_CONFIG_S_FEATURES_OK)) {
             dprintf(1, "device didn't accept features: %pP\n", pci);
             goto fail;
         }
     }

     if (vp_find_vq(vp, 2, &vq) < 0 ) {
         dprintf(1, "fail to find vq for virtio-scsi %pP\n", pci);
         goto fail;
     }

     status |= VIRTIO_CONFIG_S_DRIVER_OK;
     vp_set_status(vp, status);

     int i, tot;
     for (tot = 0, i = 0; i < 256; i++)
         tot += virtio_scsi_scan_target(pci, NULL, vp, vq, i);

     if (!tot)
         goto fail;

     return;

 fail:
     vp_reset(vp);
     free(vp);
     free(vq);
 }

 void
 init_virtio_scsi_mmio(void *mmio)
 {
     dprintf(1, "found virtio-scsi-mmio at %p\n", mmio);
     struct vring_virtqueue *vq = NULL;
     struct vp_device *vp = malloc_high(sizeof(*vp));
     if (!vp) {
         warn_noalloc();
         return;
     }
     vp_init_mmio(vp, mmio);
     u8 status = VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER;

     u64 features = vp_get_features(vp);
     u64 version1 = 1ull << VIRTIO_F_VERSION_1;
     if (features & version1) {
         u64 iommu_platform = 1ull << VIRTIO_F_IOMMU_PLATFORM;

         vp_set_features(vp, features & (version1 | iommu_platform));
         vp_set_status(vp, VIRTIO_CONFIG_S_FEATURES_OK);
         if (!(vp_get_status(vp) & VIRTIO_CONFIG_S_FEATURES_OK)) {
             dprintf(1, "device didn't accept features: %pP\n", mmio);
             goto fail;
         }
     }

     if (vp_find_vq(vp, 2, &vq) < 0 ) {
         dprintf(1, "fail to find vq for virtio-scsi-mmio %p\n", mmio);
         goto fail;
     }

     status |= VIRTIO_CONFIG_S_DRIVER_OK;
     vp_set_status(vp, status);

     int i, tot;
     for (tot = 0, i = 0; i < 256; i++)
         tot += virtio_scsi_scan_target(NULL, mmio, vp, vq, i);

     if (!tot)
         goto fail;

     return;

 fail:
     vp_reset(vp);
     free(vp);
     free(vq);
 }

 void
 virtio_scsi_setup(void)
 {
     u8 skip_nonbootable = is_bootprio_strict();

     ASSERT32FLAT();
     if (! CONFIG_VIRTIO_SCSI)
         return;

     dprintf(3, "init virtio-scsi\n");

     struct pci_device *pci;
     foreachpci(pci) {
         if (pci->vendor != PCI_VENDOR_ID_REDHAT_QUMRANET ||
             (pci->device != PCI_DEVICE_ID_VIRTIO_SCSI_09 &&
              pci->device != PCI_DEVICE_ID_VIRTIO_SCSI_10))
             continue;

         if (skip_nonbootable && bootprio_find_pci_device(pci) < 0) {
             dprintf(1, "skipping init of a non-bootable virtio-scsi at %pP\n",
                     pci);
             continue;
         }

         run_thread(init_virtio_scsi, pci);
     }
 }
	// Virtio SCSI boot support.
	//
	// Copyright (C) 2012 Red Hat Inc.
	//
	// Authors:
	// Paolo Bonzini <pbonzini@redhat.com>
	//
	// This file may be distributed under the terms of the GNU LGPLv3 license.

	#include "block.h" // struct drive_s
	#include "blockcmd.h" // scsi_drive_setup
	#include "config.h" // CONFIG_*
	#include "malloc.h" // free
	#include "output.h" // dprintf
	#include "pcidevice.h" // foreachpci
	#include "pci_ids.h" // PCI_DEVICE_ID_VIRTIO_BLK
	#include "pci_regs.h" // PCI_VENDOR_ID
	#include "stacks.h" // run_thread
	#include "std/disk.h" // DISK_RET_SUCCESS
	#include "string.h" // memset
	#include "util.h" // usleep, bootprio_find_pci_device, is_bootprio_strict
	#include "virtio-pci.h"
	#include "virtio-ring.h"
	#include "virtio-scsi.h"
	#include "virtio-mmio.h"

	struct virtio_lun_s {
	struct drive_s drive;
	struct pci_device *pci;
	void *mmio;
	char name[16];
	struct vring_virtqueue *vq;
	struct vp_device *vp;
	u16 target;
	u16 lun;
	};

	int
	virtio_scsi_process_op(struct disk_op_s *op)
	{
	if (! CONFIG_VIRTIO_SCSI)
	return 0;
	struct virtio_lun_s *vlun =
	container_of(op->drive_fl, struct virtio_lun_s, drive);
	struct vp_device *vp = vlun->vp;
	struct vring_virtqueue *vq = vlun->vq;
	struct virtio_scsi_req_cmd req;
	struct virtio_scsi_resp_cmd resp;
	struct vring_list sg[3];

	memset(&req, 0, sizeof(req));
	int blocksize = scsi_fill_cmd(op, req.cdb, 16);
	if (blocksize < 0)
	return default_process_op(op);
	req.lun[0] = 1;
	req.lun[1] = vlun->target;
	req.lun[2] = (vlun->lun >> 8) \| 0x40;
	req.lun[3] = (vlun->lun & 0xff);

	u32 len = op->count * blocksize;
	int datain = scsi_is_read(op);
	int in_num = (datain ? 2 : 1);
	int out_num = (len ? 3 : 2) - in_num;

	sg[0].addr = (void*)(&req);
	sg[0].length = sizeof(req);

	sg[out_num].addr = (void*)(&resp);
	sg[out_num].length = sizeof(resp);

	if (len) {
	int data_idx = (datain ? 2 : 1);
	sg[data_idx].addr = op->buf_fl;
	sg[data_idx].length = len;
	}

	/* Add to virtqueue and kick host */
	vring_add_buf(vq, sg, out_num, in_num, 0, 0);
	vring_kick(vp, vq, 1);

	/* Wait for reply */
	while (!vring_more_used(vq))
	usleep(5);

	/* Reclaim virtqueue element */
	vring_get_buf(vq, NULL);

	/* Clear interrupt status register. Avoid leaving interrupts stuck if
	* VRING_AVAIL_F_NO_INTERRUPT was ignored and interrupts were raised.
	*/
	vp_get_isr(vp);

	if (resp.response == VIRTIO_SCSI_S_OK && resp.status == 0) {
	return DISK_RET_SUCCESS;
	}
	return DISK_RET_EBADTRACK;
	}

	static void
	virtio_scsi_init_lun(struct virtio_lun_s *vlun,
	struct pci_device pci, void mmio,
	struct vp_device vp, struct vring_virtqueue vq,
	u16 target, u16 lun)
	{
	memset(vlun, 0, sizeof(*vlun));
	vlun->drive.type = DTYPE_VIRTIO_SCSI;
	vlun->drive.cntl_id = pci->bdf;
	vlun->pci = pci;
	vlun->mmio = mmio;
	vlun->vp = vp;
	vlun->vq = vq;
	vlun->target = target;
	vlun->lun = lun;
	if (vlun->pci)
	snprintf(vlun->name, sizeof(vlun->name), "pci:%pP", vlun->pci);
	if (vlun->mmio)
	snprintf(vlun->name, sizeof(vlun->name), "mmio:%08x", (u32)vlun->mmio);
	}

	static int
	virtio_scsi_add_lun(u32 lun, struct drive_s *tmpl_drv)
	{
	u8 skip_nonbootable = is_bootprio_strict();
	struct virtio_lun_s *tmpl_vlun =
	container_of(tmpl_drv, struct virtio_lun_s, drive);
	int prio = -1;

	if (tmpl_vlun->pci)
	prio = bootprio_find_scsi_device(tmpl_vlun->pci, tmpl_vlun->target, lun);
	if (tmpl_vlun->mmio)
	prio = bootprio_find_scsi_mmio_device(tmpl_vlun->mmio, tmpl_vlun->target, lun);

	if (skip_nonbootable && prio < 0) {
	dprintf(1, "skipping init of a non-bootable virtio-scsi dev at %s,"
	" target %d, lun %d\n",
	tmpl_vlun->name, tmpl_vlun->target, lun);
	return -1;
	}

	struct virtio_lun_s vlun = malloc_low(sizeof(vlun));
	if (!vlun) {
	warn_noalloc();
	return -1;
	}
	virtio_scsi_init_lun(vlun, tmpl_vlun->pci, tmpl_vlun->mmio,tmpl_vlun->vp,
	tmpl_vlun->vq, tmpl_vlun->target, lun);

	if (vlun->pci)
	boot_lchs_find_scsi_device(vlun->pci, vlun->target, vlun->lun,
	&(vlun->drive.lchs));
	int ret = scsi_drive_setup(&vlun->drive, "virtio-scsi", prio);
	if (ret)
	goto fail;
	return 0;

	fail:
	free(vlun);
	return -1;
	}

	static int
	virtio_scsi_scan_target(struct pci_device pci, void mmio, struct vp_device *vp,
	struct vring_virtqueue *vq, u16 target)
	{

	struct virtio_lun_s vlun0;

	virtio_scsi_init_lun(&vlun0, pci, mmio, vp, vq, target, 0);

	int ret = scsi_rep_luns_scan(&vlun0.drive, virtio_scsi_add_lun);
	return ret < 0 ? 0 : ret;
	}

	static void
	init_virtio_scsi(void *data)
	{
	struct pci_device *pci = data;
	dprintf(1, "found virtio-scsi at %pP\n", pci);
	struct vring_virtqueue *vq = NULL;
	struct vp_device vp = malloc_high(sizeof(vp));
	if (!vp) {
	warn_noalloc();
	return;
	}
	vp_init_simple(vp, pci);
	u8 status = VIRTIO_CONFIG_S_ACKNOWLEDGE \| VIRTIO_CONFIG_S_DRIVER;

	if (vp->use_modern) {
	u64 features = vp_get_features(vp);
	u64 version1 = 1ull << VIRTIO_F_VERSION_1;
	u64 iommu_platform = 1ull << VIRTIO_F_IOMMU_PLATFORM;
	if (!(features & version1)) {
	dprintf(1, "modern device without virtio_1 feature bit: %pP\n", pci);
	goto fail;
	}

	vp_set_features(vp, features & (version1 \| iommu_platform));
	status \|= VIRTIO_CONFIG_S_FEATURES_OK;
	vp_set_status(vp, status);
	if (!(vp_get_status(vp) & VIRTIO_CONFIG_S_FEATURES_OK)) {
	dprintf(1, "device didn't accept features: %pP\n", pci);
	goto fail;
	}
	}

	if (vp_find_vq(vp, 2, &vq) < 0 ) {
	dprintf(1, "fail to find vq for virtio-scsi %pP\n", pci);
	goto fail;
	}

	status \|= VIRTIO_CONFIG_S_DRIVER_OK;
	vp_set_status(vp, status);

	int i, tot;
	for (tot = 0, i = 0; i < 256; i++)
	tot += virtio_scsi_scan_target(pci, NULL, vp, vq, i);

	if (!tot)
	goto fail;

	return;

	fail:
	vp_reset(vp);
	free(vp);
	free(vq);
	}

	void
	init_virtio_scsi_mmio(void *mmio)
	{
	dprintf(1, "found virtio-scsi-mmio at %p\n", mmio);
	struct vring_virtqueue *vq = NULL;
	struct vp_device vp = malloc_high(sizeof(vp));
	if (!vp) {
	warn_noalloc();
	return;
	}
	vp_init_mmio(vp, mmio);
	u8 status = VIRTIO_CONFIG_S_ACKNOWLEDGE \| VIRTIO_CONFIG_S_DRIVER;

	u64 features = vp_get_features(vp);
	u64 version1 = 1ull << VIRTIO_F_VERSION_1;
	if (features & version1) {
	u64 iommu_platform = 1ull << VIRTIO_F_IOMMU_PLATFORM;

	vp_set_features(vp, features & (version1 \| iommu_platform));
	vp_set_status(vp, VIRTIO_CONFIG_S_FEATURES_OK);
	if (!(vp_get_status(vp) & VIRTIO_CONFIG_S_FEATURES_OK)) {
	dprintf(1, "device didn't accept features: %pP\n", mmio);
	goto fail;
	}
	}

	if (vp_find_vq(vp, 2, &vq) < 0 ) {
	dprintf(1, "fail to find vq for virtio-scsi-mmio %p\n", mmio);
	goto fail;
	}

	status \|= VIRTIO_CONFIG_S_DRIVER_OK;
	vp_set_status(vp, status);

	int i, tot;
	for (tot = 0, i = 0; i < 256; i++)
	tot += virtio_scsi_scan_target(NULL, mmio, vp, vq, i);

	if (!tot)
	goto fail;

	return;

	fail:
	vp_reset(vp);
	free(vp);
	free(vq);
	}

	void
	virtio_scsi_setup(void)
	{
	u8 skip_nonbootable = is_bootprio_strict();

	ASSERT32FLAT();
	if (! CONFIG_VIRTIO_SCSI)
	return;

	dprintf(3, "init virtio-scsi\n");

	struct pci_device *pci;
	foreachpci(pci) {
	if (pci->vendor != PCI_VENDOR_ID_REDHAT_QUMRANET \|\|
	(pci->device != PCI_DEVICE_ID_VIRTIO_SCSI_09 &&
	pci->device != PCI_DEVICE_ID_VIRTIO_SCSI_10))
	continue;

	if (skip_nonbootable && bootprio_find_pci_device(pci) < 0) {
	dprintf(1, "skipping init of a non-bootable virtio-scsi at %pP\n",
	pci);
	continue;
	}

	run_thread(init_virtio_scsi, pci);
	}
	}