// SPDX-License-Identifier: GPL-2.0
/* viohs.c: LDOM Virtual I/O handshake helper layer.
 *
 * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
 */

#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/sched/clock.h>
#include <linux/slab.h>

#include <asm/ldc.h>
#include <asm/vio.h>

int vio_ldc_send(struct vio_driver_state *vio, void *data, int len)
{
        int err, limit = 1000;

        err = -EINVAL;
        while (limit-- > 0) {
                err = ldc_write(vio->lp, data, len);
                if (!err || (err != -EAGAIN))
                        break;
                udelay(1);
        }

        return err;
}
EXPORT_SYMBOL(vio_ldc_send);

static int send_ctrl(struct vio_driver_state *vio,
                     struct vio_msg_tag *tag, int len)
{
        tag->sid = vio_send_sid(vio);
        return vio_ldc_send(vio, tag, len);
}

static void init_tag(struct vio_msg_tag *tag, u8 type, u8 stype, u16 stype_env)
{
        tag->type = type;
        tag->stype = stype;
        tag->stype_env = stype_env;
}

static int send_version(struct vio_driver_state *vio, u16 major, u16 minor)
{
        struct vio_ver_info pkt;

        vio->_local_sid = (u32) sched_clock();

        memset(&pkt, 0, sizeof(pkt));
        init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_VER_INFO);
        pkt.major = major;
        pkt.minor = minor;
        pkt.dev_class = vio->dev_class;

        viodbg(HS, "SEND VERSION INFO maj[%u] min[%u] devclass[%u]\n",
               major, minor, vio->dev_class);

        return send_ctrl(vio, &pkt.tag, sizeof(pkt));
}

static int start_handshake(struct vio_driver_state *vio)
{
        int err;

        viodbg(HS, "START HANDSHAKE\n");

        vio->hs_state = VIO_HS_INVALID;

        err = send_version(vio,
                           vio->ver_table[0].major,
                           vio->ver_table[0].minor);
        if (err < 0)
                return err;

        return 0;
}

static void flush_rx_dring(struct vio_driver_state *vio)
{
        struct vio_dring_state *dr;
        u64 ident;

        BUG_ON(!(vio->dr_state & VIO_DR_STATE_RXREG));

        dr = &vio->drings[VIO_DRIVER_RX_RING];
        ident = dr->ident;

        BUG_ON(!vio->desc_buf);
        kfree(vio->desc_buf);
        vio->desc_buf = NULL;

        memset(dr, 0, sizeof(*dr));
        dr->ident = ident;
}

void vio_link_state_change(struct vio_driver_state *vio, int event)
{
        if (event == LDC_EVENT_UP) {
                vio->hs_state = VIO_HS_INVALID;

                switch (vio->dev_class) {
                case VDEV_NETWORK:
                case VDEV_NETWORK_SWITCH:
                        vio->dr_state = (VIO_DR_STATE_TXREQ |
                                         VIO_DR_STATE_RXREQ);
                        break;

                case VDEV_DISK:
                        vio->dr_state = VIO_DR_STATE_TXREQ;
                        break;
                case VDEV_DISK_SERVER:
                        vio->dr_state = VIO_DR_STATE_RXREQ;
                        break;
                }
                start_handshake(vio);
        } else if (event == LDC_EVENT_RESET) {
                vio->hs_state = VIO_HS_INVALID;

                if (vio->dr_state & VIO_DR_STATE_RXREG)
                        flush_rx_dring(vio);

                vio->dr_state = 0x00;
                memset(&vio->ver, 0, sizeof(vio->ver));

                ldc_disconnect(vio->lp);
        }
}
EXPORT_SYMBOL(vio_link_state_change);

static int handshake_failure(struct vio_driver_state *vio)
{
        struct vio_dring_state *dr;

        /* XXX Put policy here...  Perhaps start a timer to fire
         * XXX in 100 ms, which will bring the link up and retry
         * XXX the handshake.
         */

        viodbg(HS, "HANDSHAKE FAILURE\n");

        vio->dr_state &= ~(VIO_DR_STATE_TXREG |
                           VIO_DR_STATE_RXREG);

        dr = &vio->drings[VIO_DRIVER_RX_RING];
        memset(dr, 0, sizeof(*dr));

        kfree(vio->desc_buf);
        vio->desc_buf = NULL;
        vio->desc_buf_len = 0;

        vio->hs_state = VIO_HS_INVALID;

        return -ECONNRESET;
}

static int process_unknown(struct vio_driver_state *vio, void *arg)
{
        struct vio_msg_tag *pkt = arg;

        viodbg(HS, "UNKNOWN CONTROL [%02x:%02x:%04x:%08x]\n",
               pkt->type, pkt->stype, pkt->stype_env, pkt->sid);

        printk(KERN_ERR "vio: ID[%lu] Resetting connection.\n",
               vio->vdev->channel_id);

        ldc_disconnect(vio->lp);

        return -ECONNRESET;
}

static int send_dreg(struct vio_driver_state *vio)
{
        struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_TX_RING];
        union {
                struct vio_dring_register pkt;
                char all[sizeof(struct vio_dring_register) +
                         (sizeof(struct ldc_trans_cookie) *
                          VIO_MAX_RING_COOKIES)];
        } u;
        size_t bytes = sizeof(struct vio_dring_register) +
                       (sizeof(struct ldc_trans_cookie) *
                        dr->ncookies);
        int i;

        if (WARN_ON(bytes > sizeof(u)))
                return -EINVAL;

        memset(&u, 0, bytes);
        init_tag(&u.pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_DRING_REG);
        u.pkt.dring_ident = 0;
        u.pkt.num_descr = dr->num_entries;
        u.pkt.descr_size = dr->entry_size;
        u.pkt.options = VIO_TX_DRING;
        u.pkt.num_cookies = dr->ncookies;

        viodbg(HS, "SEND DRING_REG INFO ndesc[%u] dsz[%u] opt[0x%x] "
               "ncookies[%u]\n",
               u.pkt.num_descr, u.pkt.descr_size, u.pkt.options,
               u.pkt.num_cookies);

        for (i = 0; i < dr->ncookies; i++) {
                u.pkt.cookies[i] = dr->cookies[i];

                viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
                       i,
                       (unsigned long long) u.pkt.cookies[i].cookie_addr,
                       (unsigned long long) u.pkt.cookies[i].cookie_size);
        }

        return send_ctrl(vio, &u.pkt.tag, bytes);
}

static int send_rdx(struct vio_driver_state *vio)
{
        struct vio_rdx pkt;

        memset(&pkt, 0, sizeof(pkt));

        init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX);

        viodbg(HS, "SEND RDX INFO\n");

        return send_ctrl(vio, &pkt.tag, sizeof(pkt));
}

static int send_attr(struct vio_driver_state *vio)
{
        if (!vio->ops)
                return -EINVAL;

        return vio->ops->send_attr(vio);
}

static struct vio_version *find_by_major(struct vio_driver_state *vio,
                                         u16 major)
{
        struct vio_version *ret = NULL;
        int i;

        for (i = 0; i < vio->ver_table_entries; i++) {
                struct vio_version *v = &vio->ver_table[i];
                if (v->major <= major) {
                        ret = v;
                        break;
                }
        }
        return ret;
}

static int process_ver_info(struct vio_driver_state *vio,
                            struct vio_ver_info *pkt)
{
        struct vio_version *vap;
        int err;

        viodbg(HS, "GOT VERSION INFO maj[%u] min[%u] devclass[%u]\n",
               pkt->major, pkt->minor, pkt->dev_class);

        if (vio->hs_state != VIO_HS_INVALID) {
                /* XXX Perhaps invoke start_handshake? XXX */
                memset(&vio->ver, 0, sizeof(vio->ver));
                vio->hs_state = VIO_HS_INVALID;
        }

        vap = find_by_major(vio, pkt->major);

        vio->_peer_sid = pkt->tag.sid;

        if (!vap) {
                pkt->tag.stype = VIO_SUBTYPE_NACK;
                pkt->major = 0;
                pkt->minor = 0;
                viodbg(HS, "SEND VERSION NACK maj[0] min[0]\n");
                err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
        } else if (vap->major != pkt->major) {
                pkt->tag.stype = VIO_SUBTYPE_NACK;
                pkt->major = vap->major;
                pkt->minor = vap->minor;
                viodbg(HS, "SEND VERSION NACK maj[%u] min[%u]\n",
                       pkt->major, pkt->minor);
                err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
        } else {
                struct vio_version ver = {
                        .major = pkt->major,
                        .minor = pkt->minor,
                };
                if (ver.minor > vap->minor)
                        ver.minor = vap->minor;
                pkt->minor = ver.minor;
                pkt->tag.stype = VIO_SUBTYPE_ACK;
                pkt->dev_class = vio->dev_class;
                viodbg(HS, "SEND VERSION ACK maj[%u] min[%u]\n",
                       pkt->major, pkt->minor);
                err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
                if (err > 0) {
                        vio->ver = ver;
                        vio->hs_state = VIO_HS_GOTVERS;
                }
        }
        if (err < 0)
                return handshake_failure(vio);

        return 0;
}

static int process_ver_ack(struct vio_driver_state *vio,
                           struct vio_ver_info *pkt)
{
        viodbg(HS, "GOT VERSION ACK maj[%u] min[%u] devclass[%u]\n",
               pkt->major, pkt->minor, pkt->dev_class);

        if (vio->hs_state & VIO_HS_GOTVERS) {
                if (vio->ver.major != pkt->major ||
                    vio->ver.minor != pkt->minor) {
                        pkt->tag.stype = VIO_SUBTYPE_NACK;
                        (void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
                        return handshake_failure(vio);
                }
        } else {
                vio->ver.major = pkt->major;
                vio->ver.minor = pkt->minor;
                vio->hs_state = VIO_HS_GOTVERS;
        }

        switch (vio->dev_class) {
        case VDEV_NETWORK:
        case VDEV_DISK:
                if (send_attr(vio) < 0)
                        return handshake_failure(vio);
                break;

        default:
                break;
        }

        return 0;
}

static int process_ver_nack(struct vio_driver_state *vio,
                            struct vio_ver_info *pkt)
{
        struct vio_version *nver;

        viodbg(HS, "GOT VERSION NACK maj[%u] min[%u] devclass[%u]\n",
               pkt->major, pkt->minor, pkt->dev_class);

        if (pkt->major == 0 && pkt->minor == 0)
                return handshake_failure(vio);
        nver = find_by_major(vio, pkt->major);
        if (!nver)
                return handshake_failure(vio);

        if (send_version(vio, nver->major, nver->minor) < 0)
                return handshake_failure(vio);

        return 0;
}

static int process_ver(struct vio_driver_state *vio, struct vio_ver_info *pkt)
{
        switch (pkt->tag.stype) {
        case VIO_SUBTYPE_INFO:
                return process_ver_info(vio, pkt);

        case VIO_SUBTYPE_ACK:
                return process_ver_ack(vio, pkt);

        case VIO_SUBTYPE_NACK:
                return process_ver_nack(vio, pkt);

        default:
                return handshake_failure(vio);
        }
}

static int process_attr(struct vio_driver_state *vio, void *pkt)
{
        int err;

        if (!(vio->hs_state & VIO_HS_GOTVERS))
                return handshake_failure(vio);

        if (!vio->ops)
                return 0;

        err = vio->ops->handle_attr(vio, pkt);
        if (err < 0) {
                return handshake_failure(vio);
        } else {
                vio->hs_state |= VIO_HS_GOT_ATTR;

                if ((vio->dr_state & VIO_DR_STATE_TXREQ) &&
                    !(vio->hs_state & VIO_HS_SENT_DREG)) {
                        if (send_dreg(vio) < 0)
                                return handshake_failure(vio);

                        vio->hs_state |= VIO_HS_SENT_DREG;
                }
        }

        return 0;
}

static int all_drings_registered(struct vio_driver_state *vio)
{
        int need_rx, need_tx;

        need_rx = (vio->dr_state & VIO_DR_STATE_RXREQ);
        need_tx = (vio->dr_state & VIO_DR_STATE_TXREQ);

        if (need_rx &&
            !(vio->dr_state & VIO_DR_STATE_RXREG))
                return 0;

        if (need_tx &&
            !(vio->dr_state & VIO_DR_STATE_TXREG))
                return 0;

        return 1;
}

static int process_dreg_info(struct vio_driver_state *vio,
                             struct vio_dring_register *pkt)
{
        struct vio_dring_state *dr;
        int i;

        viodbg(HS, "GOT DRING_REG INFO ident[%llx] "
               "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
               (unsigned long long) pkt->dring_ident,
               pkt->num_descr, pkt->descr_size, pkt->options,
               pkt->num_cookies);

        if (!(vio->dr_state & VIO_DR_STATE_RXREQ))
                goto send_nack;

        if (vio->dr_state & VIO_DR_STATE_RXREG)
                goto send_nack;

        /* v1.6 and higher, ACK with desired, supported mode, or NACK */
        if (vio_version_after_eq(vio, 1, 6)) {
                if (!(pkt->options & VIO_TX_DRING))
                        goto send_nack;
                pkt->options = VIO_TX_DRING;
        }

        BUG_ON(vio->desc_buf);

        vio->desc_buf = kzalloc(pkt->descr_size, GFP_ATOMIC);
        if (!vio->desc_buf)
                goto send_nack;

        vio->desc_buf_len = pkt->descr_size;

        dr = &vio->drings[VIO_DRIVER_RX_RING];

        dr->num_entries = pkt->num_descr;
        dr->entry_size = pkt->descr_size;
        dr->ncookies = pkt->num_cookies;
        for (i = 0; i < dr->ncookies; i++) {
                dr->cookies[i] = pkt->cookies[i];

                viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
                       i,
                       (unsigned long long)
                       pkt->cookies[i].cookie_addr,
                       (unsigned long long)
                       pkt->cookies[i].cookie_size);
        }

        pkt->tag.stype = VIO_SUBTYPE_ACK;
        pkt->dring_ident = ++dr->ident;

        viodbg(HS, "SEND DRING_REG ACK ident[%llx] "
               "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
               (unsigned long long) pkt->dring_ident,
               pkt->num_descr, pkt->descr_size, pkt->options,
               pkt->num_cookies);

        if (send_ctrl(vio, &pkt->tag, struct_size(pkt, cookies, dr->ncookies)) < 0)
                goto send_nack;

        vio->dr_state |= VIO_DR_STATE_RXREG;

        return 0;

send_nack:
        pkt->tag.stype = VIO_SUBTYPE_NACK;
        viodbg(HS, "SEND DRING_REG NACK\n");
        (void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));

        return handshake_failure(vio);
}

static int process_dreg_ack(struct vio_driver_state *vio,
                            struct vio_dring_register *pkt)
{
        struct vio_dring_state *dr;

        viodbg(HS, "GOT DRING_REG ACK ident[%llx] "
               "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
               (unsigned long long) pkt->dring_ident,
               pkt->num_descr, pkt->descr_size, pkt->options,
               pkt->num_cookies);

        dr = &vio->drings[VIO_DRIVER_TX_RING];

        if (!(vio->dr_state & VIO_DR_STATE_TXREQ))
                return handshake_failure(vio);

        dr->ident = pkt->dring_ident;
        vio->dr_state |= VIO_DR_STATE_TXREG;

        if (all_drings_registered(vio)) {
                if (send_rdx(vio) < 0)
                        return handshake_failure(vio);
                vio->hs_state = VIO_HS_SENT_RDX;
        }
        return 0;
}

static int process_dreg_nack(struct vio_driver_state *vio,
                             struct vio_dring_register *pkt)
{
        viodbg(HS, "GOT DRING_REG NACK ident[%llx] "
               "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
               (unsigned long long) pkt->dring_ident,
               pkt->num_descr, pkt->descr_size, pkt->options,
               pkt->num_cookies);

        return handshake_failure(vio);
}

static int process_dreg(struct vio_driver_state *vio,
                        struct vio_dring_register *pkt)
{
        if (!(vio->hs_state & VIO_HS_GOTVERS))
                return handshake_failure(vio);

        switch (pkt->tag.stype) {
        case VIO_SUBTYPE_INFO:
                return process_dreg_info(vio, pkt);

        case VIO_SUBTYPE_ACK:
                return process_dreg_ack(vio, pkt);

        case VIO_SUBTYPE_NACK:
                return process_dreg_nack(vio, pkt);

        default:
                return handshake_failure(vio);
        }
}

static int process_dunreg(struct vio_driver_state *vio,
                          struct vio_dring_unregister *pkt)
{
        struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_RX_RING];

        viodbg(HS, "GOT DRING_UNREG\n");

        if (pkt->dring_ident != dr->ident)
                return 0;

        vio->dr_state &= ~VIO_DR_STATE_RXREG;

        memset(dr, 0, sizeof(*dr));

        kfree(vio->desc_buf);
        vio->desc_buf = NULL;
        vio->desc_buf_len = 0;

        return 0;
}

static int process_rdx_info(struct vio_driver_state *vio, struct vio_rdx *pkt)
{
        viodbg(HS, "GOT RDX INFO\n");

        pkt->tag.stype = VIO_SUBTYPE_ACK;
        viodbg(HS, "SEND RDX ACK\n");
        if (send_ctrl(vio, &pkt->tag, sizeof(*pkt)) < 0)
                return handshake_failure(vio);

        vio->hs_state |= VIO_HS_SENT_RDX_ACK;
        return 0;
}

static int process_rdx_ack(struct vio_driver_state *vio, struct vio_rdx *pkt)
{
        viodbg(HS, "GOT RDX ACK\n");

        if (!(vio->hs_state & VIO_HS_SENT_RDX))
                return handshake_failure(vio);

        vio->hs_state |= VIO_HS_GOT_RDX_ACK;
        return 0;
}

static int process_rdx_nack(struct vio_driver_state *vio, struct vio_rdx *pkt)
{
        viodbg(HS, "GOT RDX NACK\n");

        return handshake_failure(vio);
}

static int process_rdx(struct vio_driver_state *vio, struct vio_rdx *pkt)
{
        if (!all_drings_registered(vio))
                handshake_failure(vio);

        switch (pkt->tag.stype) {
        case VIO_SUBTYPE_INFO:
                return process_rdx_info(vio, pkt);

        case VIO_SUBTYPE_ACK:
                return process_rdx_ack(vio, pkt);

        case VIO_SUBTYPE_NACK:
                return process_rdx_nack(vio, pkt);

        default:
                return handshake_failure(vio);
        }
}

int vio_control_pkt_engine(struct vio_driver_state *vio, void *pkt)
{
        struct vio_msg_tag *tag = pkt;
        u8 prev_state = vio->hs_state;
        int err;

        switch (tag->stype_env) {
        case VIO_VER_INFO:
                err = process_ver(vio, pkt);
                break;

        case VIO_ATTR_INFO:
                err = process_attr(vio, pkt);
                break;

        case VIO_DRING_REG:
                err = process_dreg(vio, pkt);
                break;

        case VIO_DRING_UNREG:
                err = process_dunreg(vio, pkt);
                break;

        case VIO_RDX:
                err = process_rdx(vio, pkt);
                break;

        default:
                err = process_unknown(vio, pkt);
                break;
        }

        if (!err &&
            vio->hs_state != prev_state &&
            (vio->hs_state & VIO_HS_COMPLETE)) {
                if (vio->ops)
                        vio->ops->handshake_complete(vio);
        }

        return err;
}
EXPORT_SYMBOL(vio_control_pkt_engine);

void vio_conn_reset(struct vio_driver_state *vio)
{
}
EXPORT_SYMBOL(vio_conn_reset);

/* The issue is that the Solaris virtual disk server just mirrors the
 * SID values it gets from the client peer.  So we work around that
 * here in vio_{validate,send}_sid() so that the drivers don't need
 * to be aware of this crap.
 */
int vio_validate_sid(struct vio_driver_state *vio, struct vio_msg_tag *tp)
{
        u32 sid;

        /* Always let VERSION+INFO packets through unchecked, they
         * define the new SID.
         */
        if (tp->type == VIO_TYPE_CTRL &&
            tp->stype == VIO_SUBTYPE_INFO &&
            tp->stype_env == VIO_VER_INFO)
                return 0;

        /* Ok, now figure out which SID to use.  */
        switch (vio->dev_class) {
        case VDEV_NETWORK:
        case VDEV_NETWORK_SWITCH:
        case VDEV_DISK_SERVER:
        default:
                sid = vio->_peer_sid;
                break;

        case VDEV_DISK:
                sid = vio->_local_sid;
                break;
        }

        if (sid == tp->sid)
                return 0;
        viodbg(DATA, "BAD SID tag->sid[%08x] peer_sid[%08x] local_sid[%08x]\n",
               tp->sid, vio->_peer_sid, vio->_local_sid);
        return -EINVAL;
}
EXPORT_SYMBOL(vio_validate_sid);

u32 vio_send_sid(struct vio_driver_state *vio)
{
        switch (vio->dev_class) {
        case VDEV_NETWORK:
        case VDEV_NETWORK_SWITCH:
        case VDEV_DISK:
        default:
                return vio->_local_sid;

        case VDEV_DISK_SERVER:
                return vio->_peer_sid;
        }
}
EXPORT_SYMBOL(vio_send_sid);

int vio_ldc_alloc(struct vio_driver_state *vio,
                         struct ldc_channel_config *base_cfg,
                         void *event_arg)
{
        struct ldc_channel_config cfg = *base_cfg;
        struct ldc_channel *lp;

        cfg.tx_irq = vio->vdev->tx_irq;
        cfg.rx_irq = vio->vdev->rx_irq;

        lp = ldc_alloc(vio->vdev->channel_id, &cfg, event_arg, vio->name);
        if (IS_ERR(lp))
                return PTR_ERR(lp);

        vio->lp = lp;

        return 0;
}
EXPORT_SYMBOL(vio_ldc_alloc);

void vio_ldc_free(struct vio_driver_state *vio)
{
        ldc_free(vio->lp);
        vio->lp = NULL;

        kfree(vio->desc_buf);
        vio->desc_buf = NULL;
        vio->desc_buf_len = 0;
}
EXPORT_SYMBOL(vio_ldc_free);

void vio_port_up(struct vio_driver_state *vio)
{
        unsigned long flags;
        int err, state;

        spin_lock_irqsave(&vio->lock, flags);

        state = ldc_state(vio->lp);

        err = 0;
        if (state == LDC_STATE_INIT) {
                err = ldc_bind(vio->lp);
                if (err)
                        printk(KERN_WARNING "%s: Port %lu bind failed, "
                               "err=%d\n",
                               vio->name, vio->vdev->channel_id, err);
        }

        if (!err) {
                if (ldc_mode(vio->lp) == LDC_MODE_RAW)
                        ldc_set_state(vio->lp, LDC_STATE_CONNECTED);
                else
                        err = ldc_connect(vio->lp);

                if (err)
                        printk(KERN_WARNING "%s: Port %lu connect failed, "
                               "err=%d\n",
                               vio->name, vio->vdev->channel_id, err);
        }
        if (err) {
                unsigned long expires = jiffies + HZ;

                expires = round_jiffies(expires);
                mod_timer(&vio->timer, expires);
        }

        spin_unlock_irqrestore(&vio->lock, flags);
}
EXPORT_SYMBOL(vio_port_up);

static void vio_port_timer(struct timer_list *t)
{
        struct vio_driver_state *vio = timer_container_of(vio, t, timer);

        vio_port_up(vio);
}

int vio_driver_init(struct vio_driver_state *vio, struct vio_dev *vdev,
                    u8 dev_class, struct vio_version *ver_table,
                    int ver_table_size, struct vio_driver_ops *ops,
                    char *name)
{
        switch (dev_class) {
        case VDEV_NETWORK:
        case VDEV_NETWORK_SWITCH:
        case VDEV_DISK:
        case VDEV_DISK_SERVER:
        case VDEV_CONSOLE_CON:
                break;

        default:
                return -EINVAL;
        }

        if (dev_class == VDEV_NETWORK ||
            dev_class == VDEV_NETWORK_SWITCH ||
            dev_class == VDEV_DISK ||
            dev_class == VDEV_DISK_SERVER) {
                if (!ops || !ops->send_attr || !ops->handle_attr ||
                    !ops->handshake_complete)
                        return -EINVAL;
        }

        if (!ver_table || ver_table_size < 0)
                return -EINVAL;

        if (!name)
                return -EINVAL;

        spin_lock_init(&vio->lock);

        vio->name = name;

        vio->dev_class = dev_class;
        vio->vdev = vdev;

        vio->ver_table = ver_table;
        vio->ver_table_entries = ver_table_size;

        vio->ops = ops;

        timer_setup(&vio->timer, vio_port_timer, 0);

        return 0;
}
EXPORT_SYMBOL(vio_driver_init);