1 /* viohs.c: LDOM Virtual I/O handshake helper layer.
3 * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/string.h>
9 #include <linux/delay.h>
10 #include <linux/sched.h>
11 #include <linux/slab.h>
16 int vio_ldc_send(struct vio_driver_state *vio, void *data, int len)
18 int err, limit = 1000;
22 err = ldc_write(vio->lp, data, len);
23 if (!err || (err != -EAGAIN))
30 EXPORT_SYMBOL(vio_ldc_send);
32 static int send_ctrl(struct vio_driver_state *vio,
33 struct vio_msg_tag *tag, int len)
35 tag->sid = vio_send_sid(vio);
36 return vio_ldc_send(vio, tag, len);
39 static void init_tag(struct vio_msg_tag *tag, u8 type, u8 stype, u16 stype_env)
43 tag->stype_env = stype_env;
46 static int send_version(struct vio_driver_state *vio, u16 major, u16 minor)
48 struct vio_ver_info pkt;
50 vio->_local_sid = (u32) sched_clock();
52 memset(&pkt, 0, sizeof(pkt));
53 init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_VER_INFO);
56 pkt.dev_class = vio->dev_class;
58 viodbg(HS, "SEND VERSION INFO maj[%u] min[%u] devclass[%u]\n",
59 major, minor, vio->dev_class);
61 return send_ctrl(vio, &pkt.tag, sizeof(pkt));
64 static int start_handshake(struct vio_driver_state *vio)
68 viodbg(HS, "START HANDSHAKE\n");
70 vio->hs_state = VIO_HS_INVALID;
72 err = send_version(vio,
73 vio->ver_table[0].major,
74 vio->ver_table[0].minor);
81 static void flush_rx_dring(struct vio_driver_state *vio)
83 struct vio_dring_state *dr;
86 BUG_ON(!(vio->dr_state & VIO_DR_STATE_RXREG));
88 dr = &vio->drings[VIO_DRIVER_RX_RING];
91 BUG_ON(!vio->desc_buf);
95 memset(dr, 0, sizeof(*dr));
99 void vio_link_state_change(struct vio_driver_state *vio, int event)
101 if (event == LDC_EVENT_UP) {
102 vio->hs_state = VIO_HS_INVALID;
104 switch (vio->dev_class) {
106 case VDEV_NETWORK_SWITCH:
107 vio->dr_state = (VIO_DR_STATE_TXREQ |
112 vio->dr_state = VIO_DR_STATE_TXREQ;
114 case VDEV_DISK_SERVER:
115 vio->dr_state = VIO_DR_STATE_RXREQ;
118 start_handshake(vio);
119 } else if (event == LDC_EVENT_RESET) {
120 vio->hs_state = VIO_HS_INVALID;
122 if (vio->dr_state & VIO_DR_STATE_RXREG)
125 vio->dr_state = 0x00;
126 memset(&vio->ver, 0, sizeof(vio->ver));
128 ldc_disconnect(vio->lp);
131 EXPORT_SYMBOL(vio_link_state_change);
133 static int handshake_failure(struct vio_driver_state *vio)
135 struct vio_dring_state *dr;
137 /* XXX Put policy here... Perhaps start a timer to fire
138 * XXX in 100 ms, which will bring the link up and retry
142 viodbg(HS, "HANDSHAKE FAILURE\n");
144 vio->dr_state &= ~(VIO_DR_STATE_TXREG |
147 dr = &vio->drings[VIO_DRIVER_RX_RING];
148 memset(dr, 0, sizeof(*dr));
150 kfree(vio->desc_buf);
151 vio->desc_buf = NULL;
152 vio->desc_buf_len = 0;
154 vio->hs_state = VIO_HS_INVALID;
159 static int process_unknown(struct vio_driver_state *vio, void *arg)
161 struct vio_msg_tag *pkt = arg;
163 viodbg(HS, "UNKNOWN CONTROL [%02x:%02x:%04x:%08x]\n",
164 pkt->type, pkt->stype, pkt->stype_env, pkt->sid);
166 printk(KERN_ERR "vio: ID[%lu] Resetting connection.\n",
167 vio->vdev->channel_id);
169 ldc_disconnect(vio->lp);
174 static int send_dreg(struct vio_driver_state *vio)
176 struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_TX_RING];
178 struct vio_dring_register pkt;
179 char all[sizeof(struct vio_dring_register) +
180 (sizeof(struct ldc_trans_cookie) *
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;
193 viodbg(HS, "SEND DRING_REG INFO ndesc[%u] dsz[%u] opt[0x%x] "
195 u.pkt.num_descr, u.pkt.descr_size, u.pkt.options,
198 for (i = 0; i < dr->ncookies; i++) {
199 u.pkt.cookies[i] = dr->cookies[i];
201 viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
203 (unsigned long long) u.pkt.cookies[i].cookie_addr,
204 (unsigned long long) u.pkt.cookies[i].cookie_size);
207 return send_ctrl(vio, &u.pkt.tag, sizeof(u));
210 static int send_rdx(struct vio_driver_state *vio)
214 memset(&pkt, 0, sizeof(pkt));
216 init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX);
218 viodbg(HS, "SEND RDX INFO\n");
220 return send_ctrl(vio, &pkt.tag, sizeof(pkt));
223 static int send_attr(struct vio_driver_state *vio)
225 return vio->ops->send_attr(vio);
228 static struct vio_version *find_by_major(struct vio_driver_state *vio,
231 struct vio_version *ret = NULL;
234 for (i = 0; i < vio->ver_table_entries; i++) {
235 struct vio_version *v = &vio->ver_table[i];
236 if (v->major <= major) {
244 static int process_ver_info(struct vio_driver_state *vio,
245 struct vio_ver_info *pkt)
247 struct vio_version *vap;
250 viodbg(HS, "GOT VERSION INFO maj[%u] min[%u] devclass[%u]\n",
251 pkt->major, pkt->minor, pkt->dev_class);
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;
259 vap = find_by_major(vio, pkt->major);
261 vio->_peer_sid = pkt->tag.sid;
264 pkt->tag.stype = VIO_SUBTYPE_NACK;
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));
277 struct vio_version ver = {
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));
290 vio->hs_state = VIO_HS_GOTVERS;
294 return handshake_failure(vio);
299 static int process_ver_ack(struct vio_driver_state *vio,
300 struct vio_ver_info *pkt)
302 viodbg(HS, "GOT VERSION ACK maj[%u] min[%u] devclass[%u]\n",
303 pkt->major, pkt->minor, pkt->dev_class);
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);
313 vio->ver.major = pkt->major;
314 vio->ver.minor = pkt->minor;
315 vio->hs_state = VIO_HS_GOTVERS;
318 switch (vio->dev_class) {
321 if (send_attr(vio) < 0)
322 return handshake_failure(vio);
332 static int process_ver_nack(struct vio_driver_state *vio,
333 struct vio_ver_info *pkt)
335 struct vio_version *nver;
337 viodbg(HS, "GOT VERSION NACK maj[%u] min[%u] devclass[%u]\n",
338 pkt->major, pkt->minor, pkt->dev_class);
340 if ((pkt->major == 0 && pkt->minor == 0) ||
341 !(nver = find_by_major(vio, pkt->major)))
342 return handshake_failure(vio);
344 if (send_version(vio, nver->major, nver->minor) < 0)
345 return handshake_failure(vio);
350 static int process_ver(struct vio_driver_state *vio, struct vio_ver_info *pkt)
352 switch (pkt->tag.stype) {
353 case VIO_SUBTYPE_INFO:
354 return process_ver_info(vio, pkt);
356 case VIO_SUBTYPE_ACK:
357 return process_ver_ack(vio, pkt);
359 case VIO_SUBTYPE_NACK:
360 return process_ver_nack(vio, pkt);
363 return handshake_failure(vio);
367 static int process_attr(struct vio_driver_state *vio, void *pkt)
371 if (!(vio->hs_state & VIO_HS_GOTVERS))
372 return handshake_failure(vio);
374 err = vio->ops->handle_attr(vio, pkt);
376 return handshake_failure(vio);
378 vio->hs_state |= VIO_HS_GOT_ATTR;
380 if ((vio->dr_state & VIO_DR_STATE_TXREQ) &&
381 !(vio->hs_state & VIO_HS_SENT_DREG)) {
382 if (send_dreg(vio) < 0)
383 return handshake_failure(vio);
385 vio->hs_state |= VIO_HS_SENT_DREG;
391 static int all_drings_registered(struct vio_driver_state *vio)
393 int need_rx, need_tx;
395 need_rx = (vio->dr_state & VIO_DR_STATE_RXREQ);
396 need_tx = (vio->dr_state & VIO_DR_STATE_TXREQ);
399 !(vio->dr_state & VIO_DR_STATE_RXREG))
403 !(vio->dr_state & VIO_DR_STATE_TXREG))
409 static int process_dreg_info(struct vio_driver_state *vio,
410 struct vio_dring_register *pkt)
412 struct vio_dring_state *dr;
415 viodbg(HS, "GOT DRING_REG INFO ident[%llx] "
416 "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
417 (unsigned long long) pkt->dring_ident,
418 pkt->num_descr, pkt->descr_size, pkt->options,
421 if (!(vio->dr_state & VIO_DR_STATE_RXREQ))
424 if (vio->dr_state & VIO_DR_STATE_RXREG)
427 BUG_ON(vio->desc_buf);
429 vio->desc_buf = kzalloc(pkt->descr_size, GFP_ATOMIC);
433 vio->desc_buf_len = pkt->descr_size;
435 dr = &vio->drings[VIO_DRIVER_RX_RING];
437 dr->num_entries = pkt->num_descr;
438 dr->entry_size = pkt->descr_size;
439 dr->ncookies = pkt->num_cookies;
440 for (i = 0; i < dr->ncookies; i++) {
441 dr->cookies[i] = pkt->cookies[i];
443 viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
446 pkt->cookies[i].cookie_addr,
448 pkt->cookies[i].cookie_size);
451 pkt->tag.stype = VIO_SUBTYPE_ACK;
452 pkt->dring_ident = ++dr->ident;
454 viodbg(HS, "SEND DRING_REG ACK ident[%llx]\n",
455 (unsigned long long) pkt->dring_ident);
457 len = (sizeof(*pkt) +
458 (dr->ncookies * sizeof(struct ldc_trans_cookie)));
459 if (send_ctrl(vio, &pkt->tag, len) < 0)
462 vio->dr_state |= VIO_DR_STATE_RXREG;
467 pkt->tag.stype = VIO_SUBTYPE_NACK;
468 viodbg(HS, "SEND DRING_REG NACK\n");
469 (void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
471 return handshake_failure(vio);
474 static int process_dreg_ack(struct vio_driver_state *vio,
475 struct vio_dring_register *pkt)
477 struct vio_dring_state *dr;
479 viodbg(HS, "GOT DRING_REG ACK ident[%llx] "
480 "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
481 (unsigned long long) pkt->dring_ident,
482 pkt->num_descr, pkt->descr_size, pkt->options,
485 dr = &vio->drings[VIO_DRIVER_TX_RING];
487 if (!(vio->dr_state & VIO_DR_STATE_TXREQ))
488 return handshake_failure(vio);
490 dr->ident = pkt->dring_ident;
491 vio->dr_state |= VIO_DR_STATE_TXREG;
493 if (all_drings_registered(vio)) {
494 if (send_rdx(vio) < 0)
495 return handshake_failure(vio);
496 vio->hs_state = VIO_HS_SENT_RDX;
501 static int process_dreg_nack(struct vio_driver_state *vio,
502 struct vio_dring_register *pkt)
504 viodbg(HS, "GOT DRING_REG NACK ident[%llx] "
505 "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
506 (unsigned long long) pkt->dring_ident,
507 pkt->num_descr, pkt->descr_size, pkt->options,
510 return handshake_failure(vio);
513 static int process_dreg(struct vio_driver_state *vio,
514 struct vio_dring_register *pkt)
516 if (!(vio->hs_state & VIO_HS_GOTVERS))
517 return handshake_failure(vio);
519 switch (pkt->tag.stype) {
520 case VIO_SUBTYPE_INFO:
521 return process_dreg_info(vio, pkt);
523 case VIO_SUBTYPE_ACK:
524 return process_dreg_ack(vio, pkt);
526 case VIO_SUBTYPE_NACK:
527 return process_dreg_nack(vio, pkt);
530 return handshake_failure(vio);
534 static int process_dunreg(struct vio_driver_state *vio,
535 struct vio_dring_unregister *pkt)
537 struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_RX_RING];
539 viodbg(HS, "GOT DRING_UNREG\n");
541 if (pkt->dring_ident != dr->ident)
544 vio->dr_state &= ~VIO_DR_STATE_RXREG;
546 memset(dr, 0, sizeof(*dr));
548 kfree(vio->desc_buf);
549 vio->desc_buf = NULL;
550 vio->desc_buf_len = 0;
555 static int process_rdx_info(struct vio_driver_state *vio, struct vio_rdx *pkt)
557 viodbg(HS, "GOT RDX INFO\n");
559 pkt->tag.stype = VIO_SUBTYPE_ACK;
560 viodbg(HS, "SEND RDX ACK\n");
561 if (send_ctrl(vio, &pkt->tag, sizeof(*pkt)) < 0)
562 return handshake_failure(vio);
564 vio->hs_state |= VIO_HS_SENT_RDX_ACK;
568 static int process_rdx_ack(struct vio_driver_state *vio, struct vio_rdx *pkt)
570 viodbg(HS, "GOT RDX ACK\n");
572 if (!(vio->hs_state & VIO_HS_SENT_RDX))
573 return handshake_failure(vio);
575 vio->hs_state |= VIO_HS_GOT_RDX_ACK;
579 static int process_rdx_nack(struct vio_driver_state *vio, struct vio_rdx *pkt)
581 viodbg(HS, "GOT RDX NACK\n");
583 return handshake_failure(vio);
586 static int process_rdx(struct vio_driver_state *vio, struct vio_rdx *pkt)
588 if (!all_drings_registered(vio))
589 handshake_failure(vio);
591 switch (pkt->tag.stype) {
592 case VIO_SUBTYPE_INFO:
593 return process_rdx_info(vio, pkt);
595 case VIO_SUBTYPE_ACK:
596 return process_rdx_ack(vio, pkt);
598 case VIO_SUBTYPE_NACK:
599 return process_rdx_nack(vio, pkt);
602 return handshake_failure(vio);
606 int vio_control_pkt_engine(struct vio_driver_state *vio, void *pkt)
608 struct vio_msg_tag *tag = pkt;
609 u8 prev_state = vio->hs_state;
612 switch (tag->stype_env) {
614 err = process_ver(vio, pkt);
618 err = process_attr(vio, pkt);
622 err = process_dreg(vio, pkt);
625 case VIO_DRING_UNREG:
626 err = process_dunreg(vio, pkt);
630 err = process_rdx(vio, pkt);
634 err = process_unknown(vio, pkt);
638 vio->hs_state != prev_state &&
639 (vio->hs_state & VIO_HS_COMPLETE))
640 vio->ops->handshake_complete(vio);
644 EXPORT_SYMBOL(vio_control_pkt_engine);
646 void vio_conn_reset(struct vio_driver_state *vio)
649 EXPORT_SYMBOL(vio_conn_reset);
651 /* The issue is that the Solaris virtual disk server just mirrors the
652 * SID values it gets from the client peer. So we work around that
653 * here in vio_{validate,send}_sid() so that the drivers don't need
654 * to be aware of this crap.
656 int vio_validate_sid(struct vio_driver_state *vio, struct vio_msg_tag *tp)
660 /* Always let VERSION+INFO packets through unchecked, they
661 * define the new SID.
663 if (tp->type == VIO_TYPE_CTRL &&
664 tp->stype == VIO_SUBTYPE_INFO &&
665 tp->stype_env == VIO_VER_INFO)
668 /* Ok, now figure out which SID to use. */
669 switch (vio->dev_class) {
671 case VDEV_NETWORK_SWITCH:
672 case VDEV_DISK_SERVER:
674 sid = vio->_peer_sid;
678 sid = vio->_local_sid;
684 viodbg(DATA, "BAD SID tag->sid[%08x] peer_sid[%08x] local_sid[%08x]\n",
685 tp->sid, vio->_peer_sid, vio->_local_sid);
688 EXPORT_SYMBOL(vio_validate_sid);
690 u32 vio_send_sid(struct vio_driver_state *vio)
692 switch (vio->dev_class) {
694 case VDEV_NETWORK_SWITCH:
697 return vio->_local_sid;
699 case VDEV_DISK_SERVER:
700 return vio->_peer_sid;
703 EXPORT_SYMBOL(vio_send_sid);
705 int vio_ldc_alloc(struct vio_driver_state *vio,
706 struct ldc_channel_config *base_cfg,
709 struct ldc_channel_config cfg = *base_cfg;
710 struct ldc_channel *lp;
712 cfg.tx_irq = vio->vdev->tx_irq;
713 cfg.rx_irq = vio->vdev->rx_irq;
715 lp = ldc_alloc(vio->vdev->channel_id, &cfg, event_arg);
723 EXPORT_SYMBOL(vio_ldc_alloc);
725 void vio_ldc_free(struct vio_driver_state *vio)
730 kfree(vio->desc_buf);
731 vio->desc_buf = NULL;
732 vio->desc_buf_len = 0;
734 EXPORT_SYMBOL(vio_ldc_free);
736 void vio_port_up(struct vio_driver_state *vio)
741 spin_lock_irqsave(&vio->lock, flags);
743 state = ldc_state(vio->lp);
746 if (state == LDC_STATE_INIT) {
747 err = ldc_bind(vio->lp, vio->name);
749 printk(KERN_WARNING "%s: Port %lu bind failed, "
751 vio->name, vio->vdev->channel_id, err);
755 err = ldc_connect(vio->lp);
757 printk(KERN_WARNING "%s: Port %lu connect failed, "
759 vio->name, vio->vdev->channel_id, err);
762 unsigned long expires = jiffies + HZ;
764 expires = round_jiffies(expires);
765 mod_timer(&vio->timer, expires);
768 spin_unlock_irqrestore(&vio->lock, flags);
770 EXPORT_SYMBOL(vio_port_up);
772 static void vio_port_timer(unsigned long _arg)
774 struct vio_driver_state *vio = (struct vio_driver_state *) _arg;
779 int vio_driver_init(struct vio_driver_state *vio, struct vio_dev *vdev,
780 u8 dev_class, struct vio_version *ver_table,
781 int ver_table_size, struct vio_driver_ops *ops,
786 case VDEV_NETWORK_SWITCH:
788 case VDEV_DISK_SERVER:
795 if (!ops->send_attr ||
797 !ops->handshake_complete)
800 if (!ver_table || ver_table_size < 0)
806 spin_lock_init(&vio->lock);
810 vio->dev_class = dev_class;
813 vio->ver_table = ver_table;
814 vio->ver_table_entries = ver_table_size;
818 setup_timer(&vio->timer, vio_port_timer, (unsigned long) vio);
822 EXPORT_SYMBOL(vio_driver_init);