[deliverable/linux.git] / arch / sparc / kernel / viohs.c

/* 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/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) *
			  dr->ncookies)];
	} u;
	int i;

	memset(&u, 0, sizeof(u));
	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, sizeof(u));
}

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)
{
	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;
		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);

	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, len;

	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);

	len = (sizeof(*pkt) +
	       (dr->ncookies * sizeof(struct ldc_trans_cookie)));
	if (send_ctrl(vio, &pkt->tag, len) < 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))
		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) {
		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(unsigned long _arg)
{
	struct vio_driver_state *vio = (struct vio_driver_state *) _arg;

	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:
		break;

	default:
		return -EINVAL;
	}

	if (!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;

	setup_timer(&vio->timer, vio_port_timer, (unsigned long) vio);

	return 0;
}
EXPORT_SYMBOL(vio_driver_init);
Commit	Line	Data
e53e97ce DM	1	/* viohs.c: LDOM Virtual I/O handshake helper layer.
	2	*
	3	* Copyright (C) 2007 David S. Miller <davem@davemloft.net>
	4	*/
	5
	6	#include <linux/kernel.h>
066bcaca	7	#include <linux/export.h>
e53e97ce DM	8	#include <linux/string.h>
	9	#include <linux/delay.h>
	10	#include <linux/sched.h>
	11	#include <linux/slab.h>
	12
	13	#include <asm/ldc.h>
	14	#include <asm/vio.h>
	15
	16	int vio_ldc_send(struct vio_driver_state vio, void data, int len)
	17	{
	18	int err, limit = 1000;
	19
	20	err = -EINVAL;
	21	while (limit-- > 0) {
	22	err = ldc_write(vio->lp, data, len);
	23	if (!err \|\| (err != -EAGAIN))
	24	break;
	25	udelay(1);
	26	}
	27
	28	return err;
	29	}
	30	EXPORT_SYMBOL(vio_ldc_send);
	31
	32	static int send_ctrl(struct vio_driver_state *vio,
	33	struct vio_msg_tag *tag, int len)
	34	{
	35	tag->sid = vio_send_sid(vio);
	36	return vio_ldc_send(vio, tag, len);
	37	}
	38
	39	static void init_tag(struct vio_msg_tag *tag, u8 type, u8 stype, u16 stype_env)
	40	{
	41	tag->type = type;
	42	tag->stype = stype;
	43	tag->stype_env = stype_env;
	44	}
	45
	46	static int send_version(struct vio_driver_state *vio, u16 major, u16 minor)
	47	{
	48	struct vio_ver_info pkt;
	49
	50	vio->_local_sid = (u32) sched_clock();
	51
	52	memset(&pkt, 0, sizeof(pkt));
	53	init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_VER_INFO);
	54	pkt.major = major;
	55	pkt.minor = minor;
	56	pkt.dev_class = vio->dev_class;
	57
	58	viodbg(HS, "SEND VERSION INFO maj[%u] min[%u] devclass[%u]\n",
	59	major, minor, vio->dev_class);
	60
	61	return send_ctrl(vio, &pkt.tag, sizeof(pkt));
	62	}
	63
	64	static int start_handshake(struct vio_driver_state *vio)
	65	{
	66	int err;
	67
	68	viodbg(HS, "START HANDSHAKE\n");
	69
	70	vio->hs_state = VIO_HS_INVALID;
	71
72	err = send_version(vio,
73	vio->ver_table[0].major,
74	vio->ver_table[0].minor);
75	if (err < 0)
76	return err;
77
78	return 0;
79	}
80
a4cd1845 DM	81	static void flush_rx_dring(struct vio_driver_state *vio)
	82	{
	83	struct vio_dring_state *dr;
	84	u64 ident;
	85
	86	BUG_ON(!(vio->dr_state & VIO_DR_STATE_RXREG));
	87
	88	dr = &vio->drings[VIO_DRIVER_RX_RING];
	89	ident = dr->ident;
	90
	91	BUG_ON(!vio->desc_buf);
	92	kfree(vio->desc_buf);
a5f8967e	93	vio->desc_buf = NULL;
a4cd1845 DM	94
	95	memset(dr, 0, sizeof(*dr));
	96	dr->ident = ident;
	97	}
	98
e53e97ce DM	99	void vio_link_state_change(struct vio_driver_state *vio, int event)
	100	{
	101	if (event == LDC_EVENT_UP) {
	102	vio->hs_state = VIO_HS_INVALID;
	103
	104	switch (vio->dev_class) {
	105	case VDEV_NETWORK:
	106	case VDEV_NETWORK_SWITCH:
	107	vio->dr_state = (VIO_DR_STATE_TXREQ \|
	108	VIO_DR_STATE_RXREQ);
	109	break;
	110
	111	case VDEV_DISK:
	112	vio->dr_state = VIO_DR_STATE_TXREQ;
	113	break;
	114	case VDEV_DISK_SERVER:
	115	vio->dr_state = VIO_DR_STATE_RXREQ;
	116	break;
	117	}
	118	start_handshake(vio);
a4cd1845 DM	119	} else if (event == LDC_EVENT_RESET) {
	120	vio->hs_state = VIO_HS_INVALID;
	121
	122	if (vio->dr_state & VIO_DR_STATE_RXREG)
	123	flush_rx_dring(vio);
	124
	125	vio->dr_state = 0x00;
	126	memset(&vio->ver, 0, sizeof(vio->ver));
	127
	128	ldc_disconnect(vio->lp);
e53e97ce DM	129	}
	130	}
	131	EXPORT_SYMBOL(vio_link_state_change);
	132
	133	static int handshake_failure(struct vio_driver_state *vio)
	134	{
	135	struct vio_dring_state *dr;
	136
	137	/* XXX Put policy here... Perhaps start a timer to fire
	138	* XXX in 100 ms, which will bring the link up and retry
	139	* XXX the handshake.
	140	*/
	141
	142	viodbg(HS, "HANDSHAKE FAILURE\n");
	143
	144	vio->dr_state &= ~(VIO_DR_STATE_TXREG \|
	145	VIO_DR_STATE_RXREG);
	146
	147	dr = &vio->drings[VIO_DRIVER_RX_RING];
	148	memset(dr, 0, sizeof(*dr));
	149
	150	kfree(vio->desc_buf);
	151	vio->desc_buf = NULL;
	152	vio->desc_buf_len = 0;
	153
	154	vio->hs_state = VIO_HS_INVALID;
	155
	156	return -ECONNRESET;
	157	}
	158
	159	static int process_unknown(struct vio_driver_state vio, void arg)
	160	{
	161	struct vio_msg_tag *pkt = arg;
	162
	163	viodbg(HS, "UNKNOWN CONTROL [%02x:%02x:%04x:%08x]\n",
	164	pkt->type, pkt->stype, pkt->stype_env, pkt->sid);
	165
	166	printk(KERN_ERR "vio: ID[%lu] Resetting connection.\n",
43fdf274	167	vio->vdev->channel_id);
e53e97ce DM	168
	169	ldc_disconnect(vio->lp);
	170
	171	return -ECONNRESET;
	172	}
	173
	174	static int send_dreg(struct vio_driver_state *vio)
	175	{
	176	struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_TX_RING];
	177	union {
	178	struct vio_dring_register pkt;
	179	char all[sizeof(struct vio_dring_register) +
	180	(sizeof(struct ldc_trans_cookie) *
	181	dr->ncookies)];
	182	} u;
	183	int i;
	184
	185	memset(&u, 0, sizeof(u));
	186	init_tag(&u.pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_DRING_REG);
	187	u.pkt.dring_ident = 0;
	188	u.pkt.num_descr = dr->num_entries;
	189	u.pkt.descr_size = dr->entry_size;
	190	u.pkt.options = VIO_TX_DRING;
	191	u.pkt.num_cookies = dr->ncookies;
	192
	193	viodbg(HS, "SEND DRING_REG INFO ndesc[%u] dsz[%u] opt[0x%x] "
	194	"ncookies[%u]\n",
	195	u.pkt.num_descr, u.pkt.descr_size, u.pkt.options,
	196	u.pkt.num_cookies);
	197
	198	for (i = 0; i < dr->ncookies; i++) {
	199	u.pkt.cookies[i] = dr->cookies[i];
	200
	201	viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
	202	i,
	203	(unsigned long long) u.pkt.cookies[i].cookie_addr,
	204	(unsigned long long) u.pkt.cookies[i].cookie_size);
	205	}
	206
	207	return send_ctrl(vio, &u.pkt.tag, sizeof(u));
	208	}
	209
	210	static int send_rdx(struct vio_driver_state *vio)
	211	{
	212	struct vio_rdx pkt;
	213
	214	memset(&pkt, 0, sizeof(pkt));
	215
	216	init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX);
	217
	218	viodbg(HS, "SEND RDX INFO\n");
	219
	220	return send_ctrl(vio, &pkt.tag, sizeof(pkt));
	221	}
	222
	223	static int send_attr(struct vio_driver_state *vio)
	224	{
	225	return vio->ops->send_attr(vio);
	226	}
	227
	228	static struct vio_version find_by_major(struct vio_driver_state vio,
	229	u16 major)
	230	{
	231	struct vio_version *ret = NULL;
232	int i;
233
234	for (i = 0; i < vio->ver_table_entries; i++) {
235	struct vio_version *v = &vio->ver_table[i];
236	if (v->major <= major) {
237	ret = v;
238	break;
239	}
240	}
241	return ret;
242	}
243
244	static int process_ver_info(struct vio_driver_state *vio,
245	struct vio_ver_info *pkt)
246	{
247	struct vio_version *vap;
248	int err;
249
250	viodbg(HS, "GOT VERSION INFO maj[%u] min[%u] devclass[%u]\n",
251	pkt->major, pkt->minor, pkt->dev_class);
252
253	if (vio->hs_state != VIO_HS_INVALID) {
254	/* XXX Perhaps invoke start_handshake? XXX */
255	memset(&vio->ver, 0, sizeof(vio->ver));
256	vio->hs_state = VIO_HS_INVALID;
257	}
258
259	vap = find_by_major(vio, pkt->major);
260
261	vio->_peer_sid = pkt->tag.sid;
262
263	if (!vap) {
264	pkt->tag.stype = VIO_SUBTYPE_NACK;
265	pkt->major = 0;
266	pkt->minor = 0;
267	viodbg(HS, "SEND VERSION NACK maj[0] min[0]\n");
268	err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
269	} else if (vap->major != pkt->major) {
270	pkt->tag.stype = VIO_SUBTYPE_NACK;
271	pkt->major = vap->major;
272	pkt->minor = vap->minor;
273	viodbg(HS, "SEND VERSION NACK maj[%u] min[%u]\n",
274	pkt->major, pkt->minor);
275	err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
276	} else {
277	struct vio_version ver = {
278	.major = pkt->major,
279	.minor = pkt->minor,
280	};
281	if (ver.minor > vap->minor)
282	ver.minor = vap->minor;
283	pkt->minor = ver.minor;
284	pkt->tag.stype = VIO_SUBTYPE_ACK;
285	viodbg(HS, "SEND VERSION ACK maj[%u] min[%u]\n",
286	pkt->major, pkt->minor);
287	err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
288	if (err > 0) {
289	vio->ver = ver;
290	vio->hs_state = VIO_HS_GOTVERS;
291	}
292	}
293	if (err < 0)
294	return handshake_failure(vio);
295
296	return 0;
297	}
298
299	static int process_ver_ack(struct vio_driver_state *vio,
300	struct vio_ver_info *pkt)
301	{
302	viodbg(HS, "GOT VERSION ACK maj[%u] min[%u] devclass[%u]\n",
303	pkt->major, pkt->minor, pkt->dev_class);
304
305	if (vio->hs_state & VIO_HS_GOTVERS) {
306	if (vio->ver.major != pkt->major \|\|
307	vio->ver.minor != pkt->minor) {
308	pkt->tag.stype = VIO_SUBTYPE_NACK;
309	(void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
310	return handshake_failure(vio);
311	}
312	} else {
313	vio->ver.major = pkt->major;
314	vio->ver.minor = pkt->minor;
315	vio->hs_state = VIO_HS_GOTVERS;
316	}
317
318	switch (vio->dev_class) {
319	case VDEV_NETWORK:
320	case VDEV_DISK:
321	if (send_attr(vio) < 0)
322	return handshake_failure(vio);
323	break;
324
325	default:
326	break;
327	}
328
329	return 0;
330	}
331
332	static int process_ver_nack(struct vio_driver_state *vio,
333	struct vio_ver_info *pkt)
334	{
335	struct vio_version *nver;
336
337	viodbg(HS, "GOT VERSION NACK maj[%u] min[%u] devclass[%u]\n",
338	pkt->major, pkt->minor, pkt->dev_class);
339
2eac5a0d SR	340	if (pkt->major == 0 && pkt->minor == 0)
	341	return handshake_failure(vio);
	342	nver = find_by_major(vio, pkt->major);
	343	if (!nver)
e53e97ce DM	344	return handshake_failure(vio);
	345
	346	if (send_version(vio, nver->major, nver->minor) < 0)
	347	return handshake_failure(vio);
	348
	349	return 0;
	350	}
	351
	352	static int process_ver(struct vio_driver_state vio, struct vio_ver_info pkt)
	353	{
	354	switch (pkt->tag.stype) {
	355	case VIO_SUBTYPE_INFO:
	356	return process_ver_info(vio, pkt);
	357
	358	case VIO_SUBTYPE_ACK:
	359	return process_ver_ack(vio, pkt);
	360
	361	case VIO_SUBTYPE_NACK:
	362	return process_ver_nack(vio, pkt);
	363
	364	default:
	365	return handshake_failure(vio);
6cb79b3f	366	}
e53e97ce DM	367	}
	368
	369	static int process_attr(struct vio_driver_state vio, void pkt)
	370	{
	371	int err;
	372
	373	if (!(vio->hs_state & VIO_HS_GOTVERS))
	374	return handshake_failure(vio);
	375
	376	err = vio->ops->handle_attr(vio, pkt);
	377	if (err < 0) {
	378	return handshake_failure(vio);
	379	} else {
	380	vio->hs_state \|= VIO_HS_GOT_ATTR;
	381
	382	if ((vio->dr_state & VIO_DR_STATE_TXREQ) &&
	383	!(vio->hs_state & VIO_HS_SENT_DREG)) {
	384	if (send_dreg(vio) < 0)
	385	return handshake_failure(vio);
	386
	387	vio->hs_state \|= VIO_HS_SENT_DREG;
	388	}
	389	}
	390	return 0;
	391	}
	392
	393	static int all_drings_registered(struct vio_driver_state *vio)
	394	{
	395	int need_rx, need_tx;
	396
	397	need_rx = (vio->dr_state & VIO_DR_STATE_RXREQ);
	398	need_tx = (vio->dr_state & VIO_DR_STATE_TXREQ);
	399
	400	if (need_rx &&
	401	!(vio->dr_state & VIO_DR_STATE_RXREG))
	402	return 0;
	403
	404	if (need_tx &&
	405	!(vio->dr_state & VIO_DR_STATE_TXREG))
	406	return 0;
	407
	408	return 1;
	409	}
	410
	411	static int process_dreg_info(struct vio_driver_state *vio,
	412	struct vio_dring_register *pkt)
	413	{
	414	struct vio_dring_state *dr;
	415	int i, len;
	416
	417	viodbg(HS, "GOT DRING_REG INFO ident[%llx] "
	418	"ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
	419	(unsigned long long) pkt->dring_ident,
	420	pkt->num_descr, pkt->descr_size, pkt->options,
	421	pkt->num_cookies);
	422
	423	if (!(vio->dr_state & VIO_DR_STATE_RXREQ))
	424	goto send_nack;
	425
	426	if (vio->dr_state & VIO_DR_STATE_RXREG)
	427	goto send_nack;
	428
163a4e74 DS	429	/* v1.6 and higher, ACK with desired, supported mode, or NACK */
	430	if (vio_version_after_eq(vio, 1, 6)) {
	431	if (!(pkt->options & VIO_TX_DRING))
	432	goto send_nack;
	433	pkt->options = VIO_TX_DRING;
	434	}
	435
a4cd1845 DM	436	BUG_ON(vio->desc_buf);
a4cd1845 DM	437
e53e97ce DM	438	vio->desc_buf = kzalloc(pkt->descr_size, GFP_ATOMIC);
	439	if (!vio->desc_buf)
	440	goto send_nack;
	441
	442	vio->desc_buf_len = pkt->descr_size;
	443
	444	dr = &vio->drings[VIO_DRIVER_RX_RING];
	445
	446	dr->num_entries = pkt->num_descr;
	447	dr->entry_size = pkt->descr_size;
	448	dr->ncookies = pkt->num_cookies;
	449	for (i = 0; i < dr->ncookies; i++) {
	450	dr->cookies[i] = pkt->cookies[i];
	451
	452	viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
	453	i,
	454	(unsigned long long)
	455	pkt->cookies[i].cookie_addr,
	456	(unsigned long long)
	457	pkt->cookies[i].cookie_size);
	458	}
	459
	460	pkt->tag.stype = VIO_SUBTYPE_ACK;
	461	pkt->dring_ident = ++dr->ident;
	462
163a4e74 DS	463	viodbg(HS, "SEND DRING_REG ACK ident[%llx] "
	464	"ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
	465	(unsigned long long) pkt->dring_ident,
	466	pkt->num_descr, pkt->descr_size, pkt->options,
	467	pkt->num_cookies);
e53e97ce DM	468
	469	len = (sizeof(*pkt) +
	470	(dr->ncookies * sizeof(struct ldc_trans_cookie)));
	471	if (send_ctrl(vio, &pkt->tag, len) < 0)
	472	goto send_nack;
	473
	474	vio->dr_state \|= VIO_DR_STATE_RXREG;
	475
	476	return 0;
	477
	478	send_nack:
	479	pkt->tag.stype = VIO_SUBTYPE_NACK;
	480	viodbg(HS, "SEND DRING_REG NACK\n");
	481	(void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
	482
	483	return handshake_failure(vio);
	484	}
	485
	486	static int process_dreg_ack(struct vio_driver_state *vio,
	487	struct vio_dring_register *pkt)
	488	{
	489	struct vio_dring_state *dr;
	490
	491	viodbg(HS, "GOT DRING_REG ACK ident[%llx] "
	492	"ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
	493	(unsigned long long) pkt->dring_ident,
	494	pkt->num_descr, pkt->descr_size, pkt->options,
	495	pkt->num_cookies);
	496
	497	dr = &vio->drings[VIO_DRIVER_TX_RING];
	498
	499	if (!(vio->dr_state & VIO_DR_STATE_TXREQ))
	500	return handshake_failure(vio);
	501
	502	dr->ident = pkt->dring_ident;
	503	vio->dr_state \|= VIO_DR_STATE_TXREG;
	504
	505	if (all_drings_registered(vio)) {
	506	if (send_rdx(vio) < 0)
	507	return handshake_failure(vio);
	508	vio->hs_state = VIO_HS_SENT_RDX;
	509	}
	510	return 0;
	511	}
	512
	513	static int process_dreg_nack(struct vio_driver_state *vio,
	514	struct vio_dring_register *pkt)
	515	{
	516	viodbg(HS, "GOT DRING_REG NACK ident[%llx] "
	517	"ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
	518	(unsigned long long) pkt->dring_ident,
	519	pkt->num_descr, pkt->descr_size, pkt->options,
	520	pkt->num_cookies);
	521
	522	return handshake_failure(vio);
	523	}
	524
	525	static int process_dreg(struct vio_driver_state *vio,
	526	struct vio_dring_register *pkt)
	527	{
	528	if (!(vio->hs_state & VIO_HS_GOTVERS))
	529	return handshake_failure(vio);
	530
	531	switch (pkt->tag.stype) {
532	case VIO_SUBTYPE_INFO:
533	return process_dreg_info(vio, pkt);
534
535	case VIO_SUBTYPE_ACK:
536	return process_dreg_ack(vio, pkt);
537
538	case VIO_SUBTYPE_NACK:
539	return process_dreg_nack(vio, pkt);
540
541	default:
542	return handshake_failure(vio);
543	}
544	}
545
546	static int process_dunreg(struct vio_driver_state *vio,
547	struct vio_dring_unregister *pkt)
548	{
549	struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_RX_RING];
550
551	viodbg(HS, "GOT DRING_UNREG\n");
552
553	if (pkt->dring_ident != dr->ident)
554	return 0;
555
556	vio->dr_state &= ~VIO_DR_STATE_RXREG;
557
558	memset(dr, 0, sizeof(*dr));
559
560	kfree(vio->desc_buf);
561	vio->desc_buf = NULL;
562	vio->desc_buf_len = 0;
563
564	return 0;
565	}
566
567	static int process_rdx_info(struct vio_driver_state vio, struct vio_rdx pkt)
568	{
569	viodbg(HS, "GOT RDX INFO\n");
570
571	pkt->tag.stype = VIO_SUBTYPE_ACK;
572	viodbg(HS, "SEND RDX ACK\n");
573	if (send_ctrl(vio, &pkt->tag, sizeof(*pkt)) < 0)
574	return handshake_failure(vio);
575
576	vio->hs_state \|= VIO_HS_SENT_RDX_ACK;
577	return 0;
578	}
579
580	static int process_rdx_ack(struct vio_driver_state vio, struct vio_rdx pkt)
581	{
582	viodbg(HS, "GOT RDX ACK\n");
583
584	if (!(vio->hs_state & VIO_HS_SENT_RDX))
585	return handshake_failure(vio);
586
587	vio->hs_state \|= VIO_HS_GOT_RDX_ACK;
588	return 0;
589	}
590
591	static int process_rdx_nack(struct vio_driver_state vio, struct vio_rdx pkt)
592	{
593	viodbg(HS, "GOT RDX NACK\n");
594
595	return handshake_failure(vio);
596	}
597
598	static int process_rdx(struct vio_driver_state vio, struct vio_rdx pkt)
599	{
600	if (!all_drings_registered(vio))
601	handshake_failure(vio);
602
603	switch (pkt->tag.stype) {
604	case VIO_SUBTYPE_INFO:
605	return process_rdx_info(vio, pkt);
606
607	case VIO_SUBTYPE_ACK:
608	return process_rdx_ack(vio, pkt);
609
610	case VIO_SUBTYPE_NACK:
611	return process_rdx_nack(vio, pkt);
612
613	default:
614	return handshake_failure(vio);
615	}
616	}
617
618	int vio_control_pkt_engine(struct vio_driver_state vio, void pkt)
619	{
620	struct vio_msg_tag *tag = pkt;
621	u8 prev_state = vio->hs_state;
622	int err;
623
624	switch (tag->stype_env) {
625	case VIO_VER_INFO:
626	err = process_ver(vio, pkt);
627	break;
628
629	case VIO_ATTR_INFO:
630	err = process_attr(vio, pkt);
631	break;
632
633	case VIO_DRING_REG:
634	err = process_dreg(vio, pkt);
635	break;
636
637	case VIO_DRING_UNREG:
638	err = process_dunreg(vio, pkt);
639	break;
640
641	case VIO_RDX:
642	err = process_rdx(vio, pkt);
643	break;
644
645	default:
646	err = process_unknown(vio, pkt);
647	break;
648	}
649	if (!err &&
650	vio->hs_state != prev_state &&
651	(vio->hs_state & VIO_HS_COMPLETE))
652	vio->ops->handshake_complete(vio);
653
654	return err;
655	}
656	EXPORT_SYMBOL(vio_control_pkt_engine);
657
658	void vio_conn_reset(struct vio_driver_state *vio)
659	{
660	}
661	EXPORT_SYMBOL(vio_conn_reset);
662
663	/* The issue is that the Solaris virtual disk server just mirrors the
664	* SID values it gets from the client peer. So we work around that
665	* here in vio_{validate,send}_sid() so that the drivers don't need
666	* to be aware of this crap.
667	*/
668	int vio_validate_sid(struct vio_driver_state vio, struct vio_msg_tag tp)
669	{
670	u32 sid;
671
672	/* Always let VERSION+INFO packets through unchecked, they
673	* define the new SID.
674	*/
675	if (tp->type == VIO_TYPE_CTRL &&
676	tp->stype == VIO_SUBTYPE_INFO &&
677	tp->stype_env == VIO_VER_INFO)
678	return 0;
679
680	/* Ok, now figure out which SID to use. */
681	switch (vio->dev_class) {
682	case VDEV_NETWORK:
683	case VDEV_NETWORK_SWITCH:
684	case VDEV_DISK_SERVER:
685	default:
686	sid = vio->_peer_sid;
687	break;
688
689	case VDEV_DISK:
690	sid = vio->_local_sid;
691	break;
692	}
693
694	if (sid == tp->sid)
695	return 0;
696	viodbg(DATA, "BAD SID tag->sid[%08x] peer_sid[%08x] local_sid[%08x]\n",
697	tp->sid, vio->_peer_sid, vio->_local_sid);
698	return -EINVAL;
699	}
700	EXPORT_SYMBOL(vio_validate_sid);
701
702	u32 vio_send_sid(struct vio_driver_state *vio)
703	{
704	switch (vio->dev_class) {
705	case VDEV_NETWORK:
706	case VDEV_NETWORK_SWITCH:
707	case VDEV_DISK:
708	default:
709	return vio->_local_sid;
710
711	case VDEV_DISK_SERVER:
712	return vio->_peer_sid;
713	}
714	}
715	EXPORT_SYMBOL(vio_send_sid);
716
55fe9771	717	int vio_ldc_alloc(struct vio_driver_state *vio,
e53e97ce DM	718	struct ldc_channel_config *base_cfg,
	719	void *event_arg)
	720	{
	721	struct ldc_channel_config cfg = *base_cfg;
	722	struct ldc_channel *lp;
e53e97ce	723
43fdf274 DM	724	cfg.tx_irq = vio->vdev->tx_irq;
43fdf274 DM	725	cfg.rx_irq = vio->vdev->rx_irq;
e53e97ce	726
c21c4ab0	727	lp = ldc_alloc(vio->vdev->channel_id, &cfg, event_arg, vio->name);
e53e97ce DM	728	if (IS_ERR(lp))
	729	return PTR_ERR(lp);
	730
	731	vio->lp = lp;
	732
	733	return 0;
	734	}
	735	EXPORT_SYMBOL(vio_ldc_alloc);
	736
	737	void vio_ldc_free(struct vio_driver_state *vio)
	738	{
	739	ldc_free(vio->lp);
	740	vio->lp = NULL;
	741
	742	kfree(vio->desc_buf);
	743	vio->desc_buf = NULL;
	744	vio->desc_buf_len = 0;
	745	}
	746	EXPORT_SYMBOL(vio_ldc_free);
	747
	748	void vio_port_up(struct vio_driver_state *vio)
	749	{
	750	unsigned long flags;
	751	int err, state;
	752
	753	spin_lock_irqsave(&vio->lock, flags);
	754
	755	state = ldc_state(vio->lp);
	756
	757	err = 0;
	758	if (state == LDC_STATE_INIT) {
c21c4ab0	759	err = ldc_bind(vio->lp);
e53e97ce DM	760	if (err)
	761	printk(KERN_WARNING "%s: Port %lu bind failed, "
	762	"err=%d\n",
43fdf274	763	vio->name, vio->vdev->channel_id, err);
e53e97ce DM	764	}
	765
	766	if (!err) {
	767	err = ldc_connect(vio->lp);
	768	if (err)
	769	printk(KERN_WARNING "%s: Port %lu connect failed, "
	770	"err=%d\n",
43fdf274	771	vio->name, vio->vdev->channel_id, err);
e53e97ce DM	772	}
	773	if (err) {
	774	unsigned long expires = jiffies + HZ;
	775
	776	expires = round_jiffies(expires);
	777	mod_timer(&vio->timer, expires);
	778	}
	779
	780	spin_unlock_irqrestore(&vio->lock, flags);
	781	}
	782	EXPORT_SYMBOL(vio_port_up);
	783
	784	static void vio_port_timer(unsigned long _arg)
	785	{
	786	struct vio_driver_state vio = (struct vio_driver_state ) _arg;
	787
	788	vio_port_up(vio);
	789	}
	790
	791	int vio_driver_init(struct vio_driver_state vio, struct vio_dev vdev,
43fdf274 DM	792	u8 dev_class, struct vio_version *ver_table,
	793	int ver_table_size, struct vio_driver_ops *ops,
	794	char *name)
e53e97ce DM	795	{
	796	switch (dev_class) {
	797	case VDEV_NETWORK:
	798	case VDEV_NETWORK_SWITCH:
	799	case VDEV_DISK:
	800	case VDEV_DISK_SERVER:
	801	break;
	802
	803	default:
	804	return -EINVAL;
	805	}
	806
	807	if (!ops->send_attr \|\|
	808	!ops->handle_attr \|\|
	809	!ops->handshake_complete)
	810	return -EINVAL;
	811
e53e97ce DM	812	if (!ver_table \|\| ver_table_size < 0)
	813	return -EINVAL;
	814
	815	if (!name)
	816	return -EINVAL;
	817
	818	spin_lock_init(&vio->lock);
	819
	820	vio->name = name;
	821
	822	vio->dev_class = dev_class;
	823	vio->vdev = vdev;
	824
e53e97ce DM	825	vio->ver_table = ver_table;
	826	vio->ver_table_entries = ver_table_size;
	827
	828	vio->ops = ops;
	829
	830	setup_timer(&vio->timer, vio_port_timer, (unsigned long) vio);
	831
	832	return 0;
	833	}
	834	EXPORT_SYMBOL(vio_driver_init);