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