// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) 2007-2008 Samuel Thibault.
 * (C) Copyright 2020 EPAM Systems Inc.
 */

#define LOG_CATEGORY UCLASS_PVBLOCK

#include <blk.h>
#include <common.h>
#include <dm.h>
#include <dm/device-internal.h>
#include <malloc.h>
#include <part.h>

#include <asm/armv8/mmu.h>
#include <asm/global_data.h>
#include <asm/io.h>
#include <asm/xen/system.h>

#include <linux/bug.h>
#include <linux/compat.h>

#include <xen/events.h>
#include <xen/gnttab.h>
#include <xen/hvm.h>
#include <xen/xenbus.h>

#include <xen/interface/io/ring.h>
#include <xen/interface/io/blkif.h>
#include <xen/interface/io/protocols.h>

#define DRV_NAME        "pvblock"
#define DRV_NAME_BLK    "pvblock_blk"

#define O_RDONLY        00
#define O_RDWR          02
#define WAIT_RING_TO_MS 10

struct blkfront_info {
        u64 sectors;
        unsigned int sector_size;
        int mode;
        int info;
        int barrier;
        int flush;
};

/**
 * struct blkfront_dev - Struct representing blkfront device
 * @dom: Domain id
 * @ring: Front_ring structure
 * @ring_ref: The grant reference, allowing us to grant access
 *            to the ring to the other end/domain
 * @evtchn: Event channel used to signal ring events
 * @handle: Events handle
 * @nodename: Device XenStore path in format "device/vbd/" + @devid
 * @backend: Backend XenStore path
 * @info: Private data
 * @devid: Device id
 */
struct blkfront_dev {
        domid_t dom;

        struct blkif_front_ring ring;
        grant_ref_t ring_ref;
        evtchn_port_t evtchn;
        blkif_vdev_t handle;

        char *nodename;
        char *backend;
        struct blkfront_info info;
        unsigned int devid;
        u8 *bounce_buffer;
};

struct blkfront_plat {
        unsigned int devid;
};

/**
 * struct blkfront_aiocb - AIO сontrol block
 * @aio_dev: Blockfront device
 * @aio_buf: Memory buffer, which must be sector-aligned for
 *           @aio_dev sector
 * @aio_nbytes: Size of AIO, which must be less than @aio_dev
 *              sector-sized amounts
 * @aio_offset: Offset, which must not go beyond @aio_dev
 *              sector-aligned location
 * @data: Data used to receiving response from ring
 * @gref: Array of grant references
 * @n: Number of segments
 * @aio_cb: Represents one I/O request.
 */
struct blkfront_aiocb {
        struct blkfront_dev *aio_dev;
        u8 *aio_buf;
        size_t aio_nbytes;
        off_t aio_offset;
        void *data;

        grant_ref_t gref[BLKIF_MAX_SEGMENTS_PER_REQUEST];
        int n;

        void (*aio_cb)(struct blkfront_aiocb *aiocb, int ret);
};

static void blkfront_sync(struct blkfront_dev *dev);

static void free_blkfront(struct blkfront_dev *dev)
{
        mask_evtchn(dev->evtchn);
        free(dev->backend);

        gnttab_end_access(dev->ring_ref);
        free(dev->ring.sring);

        unbind_evtchn(dev->evtchn);

        free(dev->bounce_buffer);
        free(dev->nodename);
        free(dev);
}

static int init_blkfront(unsigned int devid, struct blkfront_dev *dev)
{
        xenbus_transaction_t xbt;
        char *err = NULL;
        char *message = NULL;
        struct blkif_sring *s;
        int retry = 0;
        char *msg = NULL;
        char *c;
        char nodename[32];
        char path[ARRAY_SIZE(nodename) + strlen("/backend-id") + 1];

        sprintf(nodename, "device/vbd/%d", devid);

        memset(dev, 0, sizeof(*dev));
        dev->nodename = strdup(nodename);
        dev->devid = devid;

        snprintf(path, sizeof(path), "%s/backend-id", nodename);
        dev->dom = xenbus_read_integer(path);
        evtchn_alloc_unbound(dev->dom, NULL, dev, &dev->evtchn);

        s = (struct blkif_sring *)memalign(PAGE_SIZE, PAGE_SIZE);
        if (!s) {
                printf("Failed to allocate shared ring\n");
                goto error;
        }

        SHARED_RING_INIT(s);
        FRONT_RING_INIT(&dev->ring, s, PAGE_SIZE);

        dev->ring_ref = gnttab_grant_access(dev->dom, virt_to_pfn(s), 0);

again:
        err = xenbus_transaction_start(&xbt);
        if (err) {
                printf("starting transaction\n");
                free(err);
        }

        err = xenbus_printf(xbt, nodename, "ring-ref", "%u", dev->ring_ref);
        if (err) {
                message = "writing ring-ref";
                goto abort_transaction;
        }
        err = xenbus_printf(xbt, nodename, "event-channel", "%u", dev->evtchn);
        if (err) {
                message = "writing event-channel";
                goto abort_transaction;
        }
        err = xenbus_printf(xbt, nodename, "protocol", "%s",
                            XEN_IO_PROTO_ABI_NATIVE);
        if (err) {
                message = "writing protocol";
                goto abort_transaction;
        }

        snprintf(path, sizeof(path), "%s/state", nodename);
        err = xenbus_switch_state(xbt, path, XenbusStateConnected);
        if (err) {
                message = "switching state";
                goto abort_transaction;
        }

        err = xenbus_transaction_end(xbt, 0, &retry);
        free(err);
        if (retry) {
                goto again;
                printf("completing transaction\n");
        }

        goto done;

abort_transaction:
        free(err);
        err = xenbus_transaction_end(xbt, 1, &retry);
        printf("Abort transaction %s\n", message);
        goto error;

done:
        snprintf(path, sizeof(path), "%s/backend", nodename);
        msg = xenbus_read(XBT_NIL, path, &dev->backend);
        if (msg) {
                printf("Error %s when reading the backend path %s\n",
                       msg, path);
                goto error;
        }

        dev->handle = strtoul(strrchr(nodename, '/') + 1, NULL, 0);

        {
                XenbusState state;
                char path[strlen(dev->backend) +
                        strlen("/feature-flush-cache") + 1];

                snprintf(path, sizeof(path), "%s/mode", dev->backend);
                msg = xenbus_read(XBT_NIL, path, &c);
                if (msg) {
                        printf("Error %s when reading the mode\n", msg);
                        goto error;
                }
                if (*c == 'w')
                        dev->info.mode = O_RDWR;
                else
                        dev->info.mode = O_RDONLY;
                free(c);

                snprintf(path, sizeof(path), "%s/state", dev->backend);

                msg = NULL;
                state = xenbus_read_integer(path);
                while (!msg && state < XenbusStateConnected)
                        msg = xenbus_wait_for_state_change(path, &state);
                if (msg || state != XenbusStateConnected) {
                        printf("backend not available, state=%d\n", state);
                        goto error;
                }

                snprintf(path, sizeof(path), "%s/info", dev->backend);
                dev->info.info = xenbus_read_integer(path);

                snprintf(path, sizeof(path), "%s/sectors", dev->backend);
                /*
                 * FIXME: read_integer returns an int, so disk size
                 * limited to 1TB for now
                 */
                dev->info.sectors = xenbus_read_integer(path);

                snprintf(path, sizeof(path), "%s/sector-size", dev->backend);
                dev->info.sector_size = xenbus_read_integer(path);

                snprintf(path, sizeof(path), "%s/feature-barrier",
                         dev->backend);
                dev->info.barrier = xenbus_read_integer(path);

                snprintf(path, sizeof(path), "%s/feature-flush-cache",
                         dev->backend);
                dev->info.flush = xenbus_read_integer(path);
        }
        unmask_evtchn(dev->evtchn);

        dev->bounce_buffer = memalign(dev->info.sector_size,
                                      dev->info.sector_size);
        if (!dev->bounce_buffer) {
                printf("Failed to allocate bouncing buffer\n");
                goto error;
        }

        debug("%llu sectors of %u bytes, bounce buffer at %p\n",
              dev->info.sectors, dev->info.sector_size,
              dev->bounce_buffer);

        return 0;

error:
        free(msg);
        free(err);
        free_blkfront(dev);
        return -ENODEV;
}

static void shutdown_blkfront(struct blkfront_dev *dev)
{
        char *err = NULL, *err2;
        XenbusState state;

        char path[strlen(dev->backend) + strlen("/state") + 1];
        char nodename[strlen(dev->nodename) + strlen("/event-channel") + 1];

        debug("Close " DRV_NAME ", device ID %d\n", dev->devid);

        blkfront_sync(dev);

        snprintf(path, sizeof(path), "%s/state", dev->backend);
        snprintf(nodename, sizeof(nodename), "%s/state", dev->nodename);

        err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosing);
        if (err) {
                printf("%s: error changing state to %d: %s\n", __func__,
                       XenbusStateClosing, err);
                goto close;
        }

        state = xenbus_read_integer(path);
        while (!err && state < XenbusStateClosing)
                err = xenbus_wait_for_state_change(path, &state);
        free(err);

        err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateClosed);
        if (err) {
                printf("%s: error changing state to %d: %s\n", __func__,
                       XenbusStateClosed, err);
                goto close;
        }

        state = xenbus_read_integer(path);
        while (state < XenbusStateClosed) {
                err = xenbus_wait_for_state_change(path, &state);
                free(err);
        }

        err = xenbus_switch_state(XBT_NIL, nodename, XenbusStateInitialising);
        if (err) {
                printf("%s: error changing state to %d: %s\n", __func__,
                       XenbusStateInitialising, err);
                goto close;
        }

        state = xenbus_read_integer(path);
        while (!err &&
               (state < XenbusStateInitWait || state >= XenbusStateClosed))
                err = xenbus_wait_for_state_change(path, &state);

close:
        free(err);

        snprintf(nodename, sizeof(nodename), "%s/ring-ref", dev->nodename);
        err2 = xenbus_rm(XBT_NIL, nodename);
        free(err2);
        snprintf(nodename, sizeof(nodename), "%s/event-channel", dev->nodename);
        err2 = xenbus_rm(XBT_NIL, nodename);
        free(err2);

        if (!err)
                free_blkfront(dev);
}

/**
 * blkfront_aio_poll() - AIO polling function.
 * @dev: Blkfront device
 *
 * Here we receive response from the ring and check its status. This happens
 * until we read all data from the ring. We read the data from consumed pointer
 * to the response pointer. Then increase consumed pointer to make it clear that
 * the data has been read.
 *
 * Return: Number of consumed bytes.
 */
static int blkfront_aio_poll(struct blkfront_dev *dev)
{
        RING_IDX rp, cons;
        struct blkif_response *rsp;
        int more;
        int nr_consumed;

moretodo:
        rp = dev->ring.sring->rsp_prod;
        rmb(); /* Ensure we see queued responses up to 'rp'. */
        cons = dev->ring.rsp_cons;

        nr_consumed = 0;
        while ((cons != rp)) {
                struct blkfront_aiocb *aiocbp;
                int status;

                rsp = RING_GET_RESPONSE(&dev->ring, cons);
                nr_consumed++;

                aiocbp = (void *)(uintptr_t)rsp->id;
                status = rsp->status;

                switch (rsp->operation) {
                case BLKIF_OP_READ:
                case BLKIF_OP_WRITE:
                {
                        int j;

                        if (status != BLKIF_RSP_OKAY)
                                printf("%s error %d on %s at offset %llu, num bytes %llu\n",
                                       rsp->operation == BLKIF_OP_READ ?
                                       "read" : "write",
                                       status, aiocbp->aio_dev->nodename,
                                       (unsigned long long)aiocbp->aio_offset,
                                       (unsigned long long)aiocbp->aio_nbytes);

                        for (j = 0; j < aiocbp->n; j++)
                                gnttab_end_access(aiocbp->gref[j]);

                        break;
                }

                case BLKIF_OP_WRITE_BARRIER:
                        if (status != BLKIF_RSP_OKAY)
                                printf("write barrier error %d\n", status);
                        break;
                case BLKIF_OP_FLUSH_DISKCACHE:
                        if (status != BLKIF_RSP_OKAY)
                                printf("flush error %d\n", status);
                        break;

                default:
                        printf("unrecognized block operation %d response (status %d)\n",
                               rsp->operation, status);
                        break;
                }

                dev->ring.rsp_cons = ++cons;
                /* Nota: callback frees aiocbp itself */
                if (aiocbp && aiocbp->aio_cb)
                        aiocbp->aio_cb(aiocbp, status ? -EIO : 0);
                if (dev->ring.rsp_cons != cons)
                        /* We reentered, we must not continue here */
                        break;
        }

        RING_FINAL_CHECK_FOR_RESPONSES(&dev->ring, more);
        if (more)
                goto moretodo;

        return nr_consumed;
}

static void blkfront_wait_slot(struct blkfront_dev *dev)
{
        /* Wait for a slot */
        if (RING_FULL(&dev->ring)) {
                while (true) {
                        blkfront_aio_poll(dev);
                        if (!RING_FULL(&dev->ring))
                                break;
                        wait_event_timeout(NULL, !RING_FULL(&dev->ring),
                                           WAIT_RING_TO_MS);
                }
        }
}

/**
 * blkfront_aio_poll() - Issue an aio.
 * @aiocbp: AIO control block structure
 * @write: Describes is it read or write operation
 *         0 - read
 *         1 - write
 *
 * We check whether the AIO parameters meet the requirements of the device.
 * Then receive request from ring and define its arguments. After this we
 * grant access to the grant references. The last step is notifying about AIO
 * via event channel.
 */
static void blkfront_aio(struct blkfront_aiocb *aiocbp, int write)
{
        struct blkfront_dev *dev = aiocbp->aio_dev;
        struct blkif_request *req;
        RING_IDX i;
        int notify;
        int n, j;
        uintptr_t start, end;

        /* Can't io at non-sector-aligned location */
        BUG_ON(aiocbp->aio_offset & (dev->info.sector_size - 1));
        /* Can't io non-sector-sized amounts */
        BUG_ON(aiocbp->aio_nbytes & (dev->info.sector_size - 1));
        /* Can't io non-sector-aligned buffer */
        BUG_ON(((uintptr_t)aiocbp->aio_buf & (dev->info.sector_size - 1)));

        start = (uintptr_t)aiocbp->aio_buf & PAGE_MASK;
        end = ((uintptr_t)aiocbp->aio_buf + aiocbp->aio_nbytes +
               PAGE_SIZE - 1) & PAGE_MASK;
        n = (end - start) / PAGE_SIZE;
        aiocbp->n = n;

        BUG_ON(n > BLKIF_MAX_SEGMENTS_PER_REQUEST);

        blkfront_wait_slot(dev);
        i = dev->ring.req_prod_pvt;
        req = RING_GET_REQUEST(&dev->ring, i);

        req->operation = write ? BLKIF_OP_WRITE : BLKIF_OP_READ;
        req->nr_segments = n;
        req->handle = dev->handle;
        req->id = (uintptr_t)aiocbp;
        req->sector_number = aiocbp->aio_offset / dev->info.sector_size;

        for (j = 0; j < n; j++) {
                req->seg[j].first_sect = 0;
                req->seg[j].last_sect = PAGE_SIZE / dev->info.sector_size - 1;
        }
        req->seg[0].first_sect = ((uintptr_t)aiocbp->aio_buf & ~PAGE_MASK) /
                dev->info.sector_size;
        req->seg[n - 1].last_sect = (((uintptr_t)aiocbp->aio_buf +
                aiocbp->aio_nbytes - 1) & ~PAGE_MASK) / dev->info.sector_size;
        for (j = 0; j < n; j++) {
                uintptr_t data = start + j * PAGE_SIZE;

                if (!write) {
                        /* Trigger CoW if needed */
                        *(char *)(data + (req->seg[j].first_sect *
                                          dev->info.sector_size)) = 0;
                        barrier();
                }
                req->seg[j].gref = gnttab_grant_access(dev->dom,
                                                       virt_to_pfn((void *)data),
                                                       write);
                aiocbp->gref[j] = req->seg[j].gref;
        }

        dev->ring.req_prod_pvt = i + 1;

        wmb();
        RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&dev->ring, notify);

        if (notify)
                notify_remote_via_evtchn(dev->evtchn);
}

static void blkfront_aio_cb(struct blkfront_aiocb *aiocbp, int ret)
{
        aiocbp->data = (void *)1;
        aiocbp->aio_cb = NULL;
}

static void blkfront_io(struct blkfront_aiocb *aiocbp, int write)
{
        aiocbp->aio_cb = blkfront_aio_cb;
        blkfront_aio(aiocbp, write);
        aiocbp->data = NULL;

        while (true) {
                blkfront_aio_poll(aiocbp->aio_dev);
                if (aiocbp->data)
                        break;
                cpu_relax();
        }
}

static void blkfront_push_operation(struct blkfront_dev *dev, u8 op,
                                    uint64_t id)
{
        struct blkif_request *req;
        int notify, i;

        blkfront_wait_slot(dev);
        i = dev->ring.req_prod_pvt;
        req = RING_GET_REQUEST(&dev->ring, i);
        req->operation = op;
        req->nr_segments = 0;
        req->handle = dev->handle;
        req->id = id;
        req->sector_number = 0;
        dev->ring.req_prod_pvt = i + 1;
        wmb();
        RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&dev->ring, notify);
        if (notify)
                notify_remote_via_evtchn(dev->evtchn);
}

static void blkfront_sync(struct blkfront_dev *dev)
{
        if (dev->info.mode == O_RDWR) {
                if (dev->info.barrier == 1)
                        blkfront_push_operation(dev,
                                                BLKIF_OP_WRITE_BARRIER, 0);

                if (dev->info.flush == 1)
                        blkfront_push_operation(dev,
                                                BLKIF_OP_FLUSH_DISKCACHE, 0);
        }

        while (true) {
                blkfront_aio_poll(dev);
                if (RING_FREE_REQUESTS(&dev->ring) == RING_SIZE(&dev->ring))
                        break;
                cpu_relax();
        }
}

/**
 * pvblock_iop() - Issue an aio.
 * @udev: Pvblock device
 * @blknr: Block number to read from / write to
 * @blkcnt: Amount of blocks to read / write
 * @buffer: Memory buffer with data to be read / write
 * @write: Describes is it read or write operation
 *         0 - read
 *         1 - write
 *
 * Depending on the operation - reading or writing, data is read / written from the
 * specified address (@buffer) to the sector (@blknr).
 */
static ulong pvblock_iop(struct udevice *udev, lbaint_t blknr,
                         lbaint_t blkcnt, void *buffer, int write)
{
        struct blkfront_dev *blk_dev = dev_get_priv(udev);
        struct blk_desc *desc = dev_get_uclass_plat(udev);
        struct blkfront_aiocb aiocb;
        lbaint_t blocks_todo;
        bool unaligned;

        if (blkcnt == 0)
                return 0;

        if ((blknr + blkcnt) > desc->lba) {
                printf(DRV_NAME ": block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
                       blknr + blkcnt, desc->lba);
                return 0;
        }

        unaligned = (uintptr_t)buffer & (blk_dev->info.sector_size - 1);

        aiocb.aio_dev = blk_dev;
        aiocb.aio_offset = blknr * desc->blksz;
        aiocb.aio_cb = NULL;
        aiocb.data = NULL;
        blocks_todo = blkcnt;
        do {
                aiocb.aio_buf = unaligned ? blk_dev->bounce_buffer : buffer;

                if (write && unaligned)
                        memcpy(blk_dev->bounce_buffer, buffer, desc->blksz);

                aiocb.aio_nbytes = unaligned ? desc->blksz :
                        min((size_t)(BLKIF_MAX_SEGMENTS_PER_REQUEST * PAGE_SIZE),
                            (size_t)(blocks_todo * desc->blksz));

                blkfront_io(&aiocb, write);

                if (!write && unaligned)
                        memcpy(buffer, blk_dev->bounce_buffer, desc->blksz);

                aiocb.aio_offset += aiocb.aio_nbytes;
                buffer += aiocb.aio_nbytes;
                blocks_todo -= aiocb.aio_nbytes / desc->blksz;
        } while (blocks_todo > 0);

        return blkcnt;
}

ulong pvblock_blk_read(struct udevice *udev, lbaint_t blknr, lbaint_t blkcnt,
                       void *buffer)
{
        return pvblock_iop(udev, blknr, blkcnt, buffer, 0);
}

ulong pvblock_blk_write(struct udevice *udev, lbaint_t blknr, lbaint_t blkcnt,
                        const void *buffer)
{
        return pvblock_iop(udev, blknr, blkcnt, (void *)buffer, 1);
}

static int pvblock_blk_bind(struct udevice *udev)
{
        struct blk_desc *desc = dev_get_uclass_plat(udev);
        int devnum;

        desc->if_type = IF_TYPE_PVBLOCK;
        /*
         * Initialize the devnum to -ENODEV. This is to make sure that
         * blk_next_free_devnum() works as expected, since the default
         * value 0 is a valid devnum.
         */
        desc->devnum = -ENODEV;
        devnum = blk_next_free_devnum(IF_TYPE_PVBLOCK);
        if (devnum < 0)
                return devnum;
        desc->devnum = devnum;
        desc->part_type = PART_TYPE_UNKNOWN;
        desc->bdev = udev;

        strncpy(desc->vendor, "Xen", sizeof(desc->vendor));
        strncpy(desc->revision, "1", sizeof(desc->revision));
        strncpy(desc->product, "Virtual disk", sizeof(desc->product));

        return 0;
}

static int pvblock_blk_probe(struct udevice *udev)
{
        struct blkfront_dev *blk_dev = dev_get_priv(udev);
        struct blkfront_plat *plat = dev_get_plat(udev);
        struct blk_desc *desc = dev_get_uclass_plat(udev);
        int ret, devid;

        devid = plat->devid;
        free(plat);

        ret = init_blkfront(devid, blk_dev);
        if (ret < 0)
                return ret;

        desc->blksz = blk_dev->info.sector_size;
        desc->lba = blk_dev->info.sectors;
        desc->log2blksz = LOG2(blk_dev->info.sector_size);

        return 0;
}

static int pvblock_blk_remove(struct udevice *udev)
{
        struct blkfront_dev *blk_dev = dev_get_priv(udev);

        shutdown_blkfront(blk_dev);
        return 0;
}

static const struct blk_ops pvblock_blk_ops = {
        .read   = pvblock_blk_read,
        .write  = pvblock_blk_write,
};

U_BOOT_DRIVER(pvblock_blk) = {
        .name                   = DRV_NAME_BLK,
        .id                     = UCLASS_BLK,
        .ops                    = &pvblock_blk_ops,
        .bind                   = pvblock_blk_bind,
        .probe                  = pvblock_blk_probe,
        .remove                 = pvblock_blk_remove,
        .priv_auto      = sizeof(struct blkfront_dev),
        .flags                  = DM_FLAG_OS_PREPARE,
};

/*******************************************************************************
 * Para-virtual block device class
 *******************************************************************************/

typedef int (*enum_vbd_callback)(struct udevice *parent, unsigned int devid);

static int on_new_vbd(struct udevice *parent, unsigned int devid)
{
        struct driver_info info;
        struct udevice *udev;
        struct blkfront_plat *plat;
        int ret;

        debug("New " DRV_NAME_BLK ", device ID %d\n", devid);

        plat = malloc(sizeof(struct blkfront_plat));
        if (!plat) {
                printf("Failed to allocate platform data\n");
                return -ENOMEM;
        }

        plat->devid = devid;

        info.name = DRV_NAME_BLK;
        info.plat = plat;

        ret = device_bind_by_name(parent, false, &info, &udev);
        if (ret < 0) {
                printf("Failed to bind " DRV_NAME_BLK " to device with ID %d, ret: %d\n",
                       devid, ret);
                free(plat);
        }
        return ret;
}

static int xenbus_enumerate_vbd(struct udevice *udev, enum_vbd_callback clb)
{
        char **dirs, *msg;
        int i, ret;

        msg = xenbus_ls(XBT_NIL, "device/vbd", &dirs);
        if (msg) {
                printf("Failed to read device/vbd directory: %s\n", msg);
                free(msg);
                return -ENODEV;
        }

        for (i = 0; dirs[i]; i++) {
                int devid;

                sscanf(dirs[i], "%d", &devid);
                ret = clb(udev, devid);
                if (ret < 0)
                        goto fail;

                free(dirs[i]);
        }
        ret = 0;

fail:
        for (; dirs[i]; i++)
                free(dirs[i]);
        free(dirs);
        return ret;
}

static void print_pvblock_devices(void)
{
        struct udevice *udev;
        bool first = true;
        const char *class_name;

        class_name = uclass_get_name(UCLASS_PVBLOCK);
        for (blk_first_device(IF_TYPE_PVBLOCK, &udev); udev;
             blk_next_device(&udev), first = false) {
                struct blk_desc *desc = dev_get_uclass_plat(udev);

                if (!first)
                        puts(", ");
                printf("%s: %d", class_name, desc->devnum);
        }
        printf("\n");
}

void pvblock_init(void)
{
        struct driver_info info;
        struct udevice *udev;
        struct uclass *uc;
        int ret;

        /*
         * At this point Xen drivers have already initialized,
         * so we can instantiate the class driver and enumerate
         * virtual block devices.
         */
        info.name = DRV_NAME;
        ret = device_bind_by_name(gd->dm_root, false, &info, &udev);
        if (ret < 0)
                printf("Failed to bind " DRV_NAME ", ret: %d\n", ret);

        /* Bootstrap virtual block devices class driver */
        ret = uclass_get(UCLASS_PVBLOCK, &uc);
        if (ret)
                return;
        uclass_foreach_dev_probe(UCLASS_PVBLOCK, udev);

        print_pvblock_devices();
}

static int pvblock_probe(struct udevice *udev)
{
        struct uclass *uc;
        int ret;

        if (xenbus_enumerate_vbd(udev, on_new_vbd) < 0)
                return -ENODEV;

        ret = uclass_get(UCLASS_BLK, &uc);
        if (ret)
                return ret;
        uclass_foreach_dev_probe(UCLASS_BLK, udev) {
                if (_ret)
                        return _ret;
        };
        return 0;
}

U_BOOT_DRIVER(pvblock_drv) = {
        .name           = DRV_NAME,
        .id             = UCLASS_PVBLOCK,
        .probe          = pvblock_probe,
};

UCLASS_DRIVER(pvblock) = {
        .name           = DRV_NAME,
        .id             = UCLASS_PVBLOCK,
};