1 // SPDX-License-Identifier: GPL-2.0
2 /* viohs.c: LDOM Virtual I/O handshake helper layer.
4 * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
7 #include <linux/kernel.h>
8 #include <linux/export.h>
9 #include <linux/string.h>
10 #include <linux/delay.h>
11 #include <linux/sched.h>
12 #include <linux/sched/clock.h>
13 #include <linux/slab.h>
18 int vio_ldc_send(struct vio_driver_state *vio, void *data, int len)
20 int err, limit = 1000;
24 err = ldc_write(vio->lp, data, len);
25 if (!err || (err != -EAGAIN))
32 EXPORT_SYMBOL(vio_ldc_send);
34 static int send_ctrl(struct vio_driver_state *vio,
35 struct vio_msg_tag *tag, int len)
37 tag->sid = vio_send_sid(vio);
38 return vio_ldc_send(vio, tag, len);
41 static void init_tag(struct vio_msg_tag *tag, u8 type, u8 stype, u16 stype_env)
45 tag->stype_env = stype_env;
48 static int send_version(struct vio_driver_state *vio, u16 major, u16 minor)
50 struct vio_ver_info pkt;
52 vio->_local_sid = (u32) sched_clock();
54 memset(&pkt, 0, sizeof(pkt));
55 init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_VER_INFO);
58 pkt.dev_class = vio->dev_class;
60 viodbg(HS, "SEND VERSION INFO maj[%u] min[%u] devclass[%u]\n",
61 major, minor, vio->dev_class);
63 return send_ctrl(vio, &pkt.tag, sizeof(pkt));
66 static int start_handshake(struct vio_driver_state *vio)
70 viodbg(HS, "START HANDSHAKE\n");
72 vio->hs_state = VIO_HS_INVALID;
74 err = send_version(vio,
75 vio->ver_table[0].major,
76 vio->ver_table[0].minor);
83 static void flush_rx_dring(struct vio_driver_state *vio)
85 struct vio_dring_state *dr;
88 BUG_ON(!(vio->dr_state & VIO_DR_STATE_RXREG));
90 dr = &vio->drings[VIO_DRIVER_RX_RING];
93 BUG_ON(!vio->desc_buf);
97 memset(dr, 0, sizeof(*dr));
101 void vio_link_state_change(struct vio_driver_state *vio, int event)
103 if (event == LDC_EVENT_UP) {
104 vio->hs_state = VIO_HS_INVALID;
106 switch (vio->dev_class) {
108 case VDEV_NETWORK_SWITCH:
109 vio->dr_state = (VIO_DR_STATE_TXREQ |
114 vio->dr_state = VIO_DR_STATE_TXREQ;
116 case VDEV_DISK_SERVER:
117 vio->dr_state = VIO_DR_STATE_RXREQ;
120 start_handshake(vio);
121 } else if (event == LDC_EVENT_RESET) {
122 vio->hs_state = VIO_HS_INVALID;
124 if (vio->dr_state & VIO_DR_STATE_RXREG)
127 vio->dr_state = 0x00;
128 memset(&vio->ver, 0, sizeof(vio->ver));
130 ldc_disconnect(vio->lp);
133 EXPORT_SYMBOL(vio_link_state_change);
135 static int handshake_failure(struct vio_driver_state *vio)
137 struct vio_dring_state *dr;
139 /* XXX Put policy here... Perhaps start a timer to fire
140 * XXX in 100 ms, which will bring the link up and retry
144 viodbg(HS, "HANDSHAKE FAILURE\n");
146 vio->dr_state &= ~(VIO_DR_STATE_TXREG |
149 dr = &vio->drings[VIO_DRIVER_RX_RING];
150 memset(dr, 0, sizeof(*dr));
152 kfree(vio->desc_buf);
153 vio->desc_buf = NULL;
154 vio->desc_buf_len = 0;
156 vio->hs_state = VIO_HS_INVALID;
161 static int process_unknown(struct vio_driver_state *vio, void *arg)
163 struct vio_msg_tag *pkt = arg;
165 viodbg(HS, "UNKNOWN CONTROL [%02x:%02x:%04x:%08x]\n",
166 pkt->type, pkt->stype, pkt->stype_env, pkt->sid);
168 printk(KERN_ERR "vio: ID[%lu] Resetting connection.\n",
169 vio->vdev->channel_id);
171 ldc_disconnect(vio->lp);
176 static int send_dreg(struct vio_driver_state *vio)
178 struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_TX_RING];
180 struct vio_dring_register pkt;
181 char all[sizeof(struct vio_dring_register) +
182 (sizeof(struct ldc_trans_cookie) *
187 memset(&u, 0, sizeof(u));
188 init_tag(&u.pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_DRING_REG);
189 u.pkt.dring_ident = 0;
190 u.pkt.num_descr = dr->num_entries;
191 u.pkt.descr_size = dr->entry_size;
192 u.pkt.options = VIO_TX_DRING;
193 u.pkt.num_cookies = dr->ncookies;
195 viodbg(HS, "SEND DRING_REG INFO ndesc[%u] dsz[%u] opt[0x%x] "
197 u.pkt.num_descr, u.pkt.descr_size, u.pkt.options,
200 for (i = 0; i < dr->ncookies; i++) {
201 u.pkt.cookies[i] = dr->cookies[i];
203 viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
205 (unsigned long long) u.pkt.cookies[i].cookie_addr,
206 (unsigned long long) u.pkt.cookies[i].cookie_size);
209 return send_ctrl(vio, &u.pkt.tag, sizeof(u));
212 static int send_rdx(struct vio_driver_state *vio)
216 memset(&pkt, 0, sizeof(pkt));
218 init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX);
220 viodbg(HS, "SEND RDX INFO\n");
222 return send_ctrl(vio, &pkt.tag, sizeof(pkt));
225 static int send_attr(struct vio_driver_state *vio)
230 return vio->ops->send_attr(vio);
233 static struct vio_version *find_by_major(struct vio_driver_state *vio,
236 struct vio_version *ret = NULL;
239 for (i = 0; i < vio->ver_table_entries; i++) {
240 struct vio_version *v = &vio->ver_table[i];
241 if (v->major <= major) {
249 static int process_ver_info(struct vio_driver_state *vio,
250 struct vio_ver_info *pkt)
252 struct vio_version *vap;
255 viodbg(HS, "GOT VERSION INFO maj[%u] min[%u] devclass[%u]\n",
256 pkt->major, pkt->minor, pkt->dev_class);
258 if (vio->hs_state != VIO_HS_INVALID) {
259 /* XXX Perhaps invoke start_handshake? XXX */
260 memset(&vio->ver, 0, sizeof(vio->ver));
261 vio->hs_state = VIO_HS_INVALID;
264 vap = find_by_major(vio, pkt->major);
266 vio->_peer_sid = pkt->tag.sid;
269 pkt->tag.stype = VIO_SUBTYPE_NACK;
272 viodbg(HS, "SEND VERSION NACK maj[0] min[0]\n");
273 err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
274 } else if (vap->major != pkt->major) {
275 pkt->tag.stype = VIO_SUBTYPE_NACK;
276 pkt->major = vap->major;
277 pkt->minor = vap->minor;
278 viodbg(HS, "SEND VERSION NACK maj[%u] min[%u]\n",
279 pkt->major, pkt->minor);
280 err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
282 struct vio_version ver = {
286 if (ver.minor > vap->minor)
287 ver.minor = vap->minor;
288 pkt->minor = ver.minor;
289 pkt->tag.stype = VIO_SUBTYPE_ACK;
290 pkt->dev_class = vio->dev_class;
291 viodbg(HS, "SEND VERSION ACK maj[%u] min[%u]\n",
292 pkt->major, pkt->minor);
293 err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
296 vio->hs_state = VIO_HS_GOTVERS;
300 return handshake_failure(vio);
305 static int process_ver_ack(struct vio_driver_state *vio,
306 struct vio_ver_info *pkt)
308 viodbg(HS, "GOT VERSION ACK maj[%u] min[%u] devclass[%u]\n",
309 pkt->major, pkt->minor, pkt->dev_class);
311 if (vio->hs_state & VIO_HS_GOTVERS) {
312 if (vio->ver.major != pkt->major ||
313 vio->ver.minor != pkt->minor) {
314 pkt->tag.stype = VIO_SUBTYPE_NACK;
315 (void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
316 return handshake_failure(vio);
319 vio->ver.major = pkt->major;
320 vio->ver.minor = pkt->minor;
321 vio->hs_state = VIO_HS_GOTVERS;
324 switch (vio->dev_class) {
327 if (send_attr(vio) < 0)
328 return handshake_failure(vio);
338 static int process_ver_nack(struct vio_driver_state *vio,
339 struct vio_ver_info *pkt)
341 struct vio_version *nver;
343 viodbg(HS, "GOT VERSION NACK maj[%u] min[%u] devclass[%u]\n",
344 pkt->major, pkt->minor, pkt->dev_class);
346 if (pkt->major == 0 && pkt->minor == 0)
347 return handshake_failure(vio);
348 nver = find_by_major(vio, pkt->major);
350 return handshake_failure(vio);
352 if (send_version(vio, nver->major, nver->minor) < 0)
353 return handshake_failure(vio);
358 static int process_ver(struct vio_driver_state *vio, struct vio_ver_info *pkt)
360 switch (pkt->tag.stype) {
361 case VIO_SUBTYPE_INFO:
362 return process_ver_info(vio, pkt);
364 case VIO_SUBTYPE_ACK:
365 return process_ver_ack(vio, pkt);
367 case VIO_SUBTYPE_NACK:
368 return process_ver_nack(vio, pkt);
371 return handshake_failure(vio);
375 static int process_attr(struct vio_driver_state *vio, void *pkt)
379 if (!(vio->hs_state & VIO_HS_GOTVERS))
380 return handshake_failure(vio);
385 err = vio->ops->handle_attr(vio, pkt);
387 return handshake_failure(vio);
389 vio->hs_state |= VIO_HS_GOT_ATTR;
391 if ((vio->dr_state & VIO_DR_STATE_TXREQ) &&
392 !(vio->hs_state & VIO_HS_SENT_DREG)) {
393 if (send_dreg(vio) < 0)
394 return handshake_failure(vio);
396 vio->hs_state |= VIO_HS_SENT_DREG;
403 static int all_drings_registered(struct vio_driver_state *vio)
405 int need_rx, need_tx;
407 need_rx = (vio->dr_state & VIO_DR_STATE_RXREQ);
408 need_tx = (vio->dr_state & VIO_DR_STATE_TXREQ);
411 !(vio->dr_state & VIO_DR_STATE_RXREG))
415 !(vio->dr_state & VIO_DR_STATE_TXREG))
421 static int process_dreg_info(struct vio_driver_state *vio,
422 struct vio_dring_register *pkt)
424 struct vio_dring_state *dr;
427 viodbg(HS, "GOT DRING_REG INFO ident[%llx] "
428 "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
429 (unsigned long long) pkt->dring_ident,
430 pkt->num_descr, pkt->descr_size, pkt->options,
433 if (!(vio->dr_state & VIO_DR_STATE_RXREQ))
436 if (vio->dr_state & VIO_DR_STATE_RXREG)
439 /* v1.6 and higher, ACK with desired, supported mode, or NACK */
440 if (vio_version_after_eq(vio, 1, 6)) {
441 if (!(pkt->options & VIO_TX_DRING))
443 pkt->options = VIO_TX_DRING;
446 BUG_ON(vio->desc_buf);
448 vio->desc_buf = kzalloc(pkt->descr_size, GFP_ATOMIC);
452 vio->desc_buf_len = pkt->descr_size;
454 dr = &vio->drings[VIO_DRIVER_RX_RING];
456 dr->num_entries = pkt->num_descr;
457 dr->entry_size = pkt->descr_size;
458 dr->ncookies = pkt->num_cookies;
459 for (i = 0; i < dr->ncookies; i++) {
460 dr->cookies[i] = pkt->cookies[i];
462 viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
465 pkt->cookies[i].cookie_addr,
467 pkt->cookies[i].cookie_size);
470 pkt->tag.stype = VIO_SUBTYPE_ACK;
471 pkt->dring_ident = ++dr->ident;
473 viodbg(HS, "SEND DRING_REG ACK ident[%llx] "
474 "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
475 (unsigned long long) pkt->dring_ident,
476 pkt->num_descr, pkt->descr_size, pkt->options,
479 len = (sizeof(*pkt) +
480 (dr->ncookies * sizeof(struct ldc_trans_cookie)));
481 if (send_ctrl(vio, &pkt->tag, len) < 0)
484 vio->dr_state |= VIO_DR_STATE_RXREG;
489 pkt->tag.stype = VIO_SUBTYPE_NACK;
490 viodbg(HS, "SEND DRING_REG NACK\n");
491 (void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
493 return handshake_failure(vio);
496 static int process_dreg_ack(struct vio_driver_state *vio,
497 struct vio_dring_register *pkt)
499 struct vio_dring_state *dr;
501 viodbg(HS, "GOT DRING_REG ACK ident[%llx] "
502 "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
503 (unsigned long long) pkt->dring_ident,
504 pkt->num_descr, pkt->descr_size, pkt->options,
507 dr = &vio->drings[VIO_DRIVER_TX_RING];
509 if (!(vio->dr_state & VIO_DR_STATE_TXREQ))
510 return handshake_failure(vio);
512 dr->ident = pkt->dring_ident;
513 vio->dr_state |= VIO_DR_STATE_TXREG;
515 if (all_drings_registered(vio)) {
516 if (send_rdx(vio) < 0)
517 return handshake_failure(vio);
518 vio->hs_state = VIO_HS_SENT_RDX;
523 static int process_dreg_nack(struct vio_driver_state *vio,
524 struct vio_dring_register *pkt)
526 viodbg(HS, "GOT DRING_REG NACK ident[%llx] "
527 "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
528 (unsigned long long) pkt->dring_ident,
529 pkt->num_descr, pkt->descr_size, pkt->options,
532 return handshake_failure(vio);
535 static int process_dreg(struct vio_driver_state *vio,
536 struct vio_dring_register *pkt)
538 if (!(vio->hs_state & VIO_HS_GOTVERS))
539 return handshake_failure(vio);
541 switch (pkt->tag.stype) {
542 case VIO_SUBTYPE_INFO:
543 return process_dreg_info(vio, pkt);
545 case VIO_SUBTYPE_ACK:
546 return process_dreg_ack(vio, pkt);
548 case VIO_SUBTYPE_NACK:
549 return process_dreg_nack(vio, pkt);
552 return handshake_failure(vio);
556 static int process_dunreg(struct vio_driver_state *vio,
557 struct vio_dring_unregister *pkt)
559 struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_RX_RING];
561 viodbg(HS, "GOT DRING_UNREG\n");
563 if (pkt->dring_ident != dr->ident)
566 vio->dr_state &= ~VIO_DR_STATE_RXREG;
568 memset(dr, 0, sizeof(*dr));
570 kfree(vio->desc_buf);
571 vio->desc_buf = NULL;
572 vio->desc_buf_len = 0;
577 static int process_rdx_info(struct vio_driver_state *vio, struct vio_rdx *pkt)
579 viodbg(HS, "GOT RDX INFO\n");
581 pkt->tag.stype = VIO_SUBTYPE_ACK;
582 viodbg(HS, "SEND RDX ACK\n");
583 if (send_ctrl(vio, &pkt->tag, sizeof(*pkt)) < 0)
584 return handshake_failure(vio);
586 vio->hs_state |= VIO_HS_SENT_RDX_ACK;
590 static int process_rdx_ack(struct vio_driver_state *vio, struct vio_rdx *pkt)
592 viodbg(HS, "GOT RDX ACK\n");
594 if (!(vio->hs_state & VIO_HS_SENT_RDX))
595 return handshake_failure(vio);
597 vio->hs_state |= VIO_HS_GOT_RDX_ACK;
601 static int process_rdx_nack(struct vio_driver_state *vio, struct vio_rdx *pkt)
603 viodbg(HS, "GOT RDX NACK\n");
605 return handshake_failure(vio);
608 static int process_rdx(struct vio_driver_state *vio, struct vio_rdx *pkt)
610 if (!all_drings_registered(vio))
611 handshake_failure(vio);
613 switch (pkt->tag.stype) {
614 case VIO_SUBTYPE_INFO:
615 return process_rdx_info(vio, pkt);
617 case VIO_SUBTYPE_ACK:
618 return process_rdx_ack(vio, pkt);
620 case VIO_SUBTYPE_NACK:
621 return process_rdx_nack(vio, pkt);
624 return handshake_failure(vio);
628 int vio_control_pkt_engine(struct vio_driver_state *vio, void *pkt)
630 struct vio_msg_tag *tag = pkt;
631 u8 prev_state = vio->hs_state;
634 switch (tag->stype_env) {
636 err = process_ver(vio, pkt);
640 err = process_attr(vio, pkt);
644 err = process_dreg(vio, pkt);
647 case VIO_DRING_UNREG:
648 err = process_dunreg(vio, pkt);
652 err = process_rdx(vio, pkt);
656 err = process_unknown(vio, pkt);
661 vio->hs_state != prev_state &&
662 (vio->hs_state & VIO_HS_COMPLETE)) {
664 vio->ops->handshake_complete(vio);
669 EXPORT_SYMBOL(vio_control_pkt_engine);
671 void vio_conn_reset(struct vio_driver_state *vio)
674 EXPORT_SYMBOL(vio_conn_reset);
676 /* The issue is that the Solaris virtual disk server just mirrors the
677 * SID values it gets from the client peer. So we work around that
678 * here in vio_{validate,send}_sid() so that the drivers don't need
679 * to be aware of this crap.
681 int vio_validate_sid(struct vio_driver_state *vio, struct vio_msg_tag *tp)
685 /* Always let VERSION+INFO packets through unchecked, they
686 * define the new SID.
688 if (tp->type == VIO_TYPE_CTRL &&
689 tp->stype == VIO_SUBTYPE_INFO &&
690 tp->stype_env == VIO_VER_INFO)
693 /* Ok, now figure out which SID to use. */
694 switch (vio->dev_class) {
696 case VDEV_NETWORK_SWITCH:
697 case VDEV_DISK_SERVER:
699 sid = vio->_peer_sid;
703 sid = vio->_local_sid;
709 viodbg(DATA, "BAD SID tag->sid[%08x] peer_sid[%08x] local_sid[%08x]\n",
710 tp->sid, vio->_peer_sid, vio->_local_sid);
713 EXPORT_SYMBOL(vio_validate_sid);
715 u32 vio_send_sid(struct vio_driver_state *vio)
717 switch (vio->dev_class) {
719 case VDEV_NETWORK_SWITCH:
722 return vio->_local_sid;
724 case VDEV_DISK_SERVER:
725 return vio->_peer_sid;
728 EXPORT_SYMBOL(vio_send_sid);
730 int vio_ldc_alloc(struct vio_driver_state *vio,
731 struct ldc_channel_config *base_cfg,
734 struct ldc_channel_config cfg = *base_cfg;
735 struct ldc_channel *lp;
737 cfg.tx_irq = vio->vdev->tx_irq;
738 cfg.rx_irq = vio->vdev->rx_irq;
740 lp = ldc_alloc(vio->vdev->channel_id, &cfg, event_arg, vio->name);
748 EXPORT_SYMBOL(vio_ldc_alloc);
750 void vio_ldc_free(struct vio_driver_state *vio)
755 kfree(vio->desc_buf);
756 vio->desc_buf = NULL;
757 vio->desc_buf_len = 0;
759 EXPORT_SYMBOL(vio_ldc_free);
761 void vio_port_up(struct vio_driver_state *vio)
766 spin_lock_irqsave(&vio->lock, flags);
768 state = ldc_state(vio->lp);
771 if (state == LDC_STATE_INIT) {
772 err = ldc_bind(vio->lp);
774 printk(KERN_WARNING "%s: Port %lu bind failed, "
776 vio->name, vio->vdev->channel_id, err);
780 if (ldc_mode(vio->lp) == LDC_MODE_RAW)
781 ldc_set_state(vio->lp, LDC_STATE_CONNECTED);
783 err = ldc_connect(vio->lp);
786 printk(KERN_WARNING "%s: Port %lu connect failed, "
788 vio->name, vio->vdev->channel_id, err);
791 unsigned long expires = jiffies + HZ;
793 expires = round_jiffies(expires);
794 mod_timer(&vio->timer, expires);
797 spin_unlock_irqrestore(&vio->lock, flags);
799 EXPORT_SYMBOL(vio_port_up);
801 static void vio_port_timer(unsigned long _arg)
803 struct vio_driver_state *vio = (struct vio_driver_state *) _arg;
808 int vio_driver_init(struct vio_driver_state *vio, struct vio_dev *vdev,
809 u8 dev_class, struct vio_version *ver_table,
810 int ver_table_size, struct vio_driver_ops *ops,
815 case VDEV_NETWORK_SWITCH:
817 case VDEV_DISK_SERVER:
818 case VDEV_CONSOLE_CON:
825 if (dev_class == VDEV_NETWORK ||
826 dev_class == VDEV_NETWORK_SWITCH ||
827 dev_class == VDEV_DISK ||
828 dev_class == VDEV_DISK_SERVER) {
829 if (!ops || !ops->send_attr || !ops->handle_attr ||
830 !ops->handshake_complete)
834 if (!ver_table || ver_table_size < 0)
840 spin_lock_init(&vio->lock);
844 vio->dev_class = dev_class;
847 vio->ver_table = ver_table;
848 vio->ver_table_entries = ver_table_size;
852 setup_timer(&vio->timer, vio_port_timer, (unsigned long) vio);
856 EXPORT_SYMBOL(vio_driver_init);