xref: /linux/arch/sparc/kernel/viohs.c (revision e7d759f31ca295d589f7420719c311870bb3166f) 
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 
18 int 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 }
32 EXPORT_SYMBOL(vio_ldc_send);
33 
34 static 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 
41 static 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 
48 static 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 
66 static 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 
83 static 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 
101 void 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 }
133 EXPORT_SYMBOL(vio_link_state_change);
134 
135 static 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 
161 static 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 
176 static 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 			  VIO_MAX_RING_COOKIES)];
184 	} u;
185 	size_t bytes = sizeof(struct vio_dring_register) +
186 		       (sizeof(struct ldc_trans_cookie) *
187 			dr->ncookies);
188 	int i;
189 
190 	if (WARN_ON(bytes > sizeof(u)))
191 		return -EINVAL;
192 
193 	memset(&u, 0, bytes);
194 	init_tag(&u.pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_DRING_REG);
195 	u.pkt.dring_ident = 0;
196 	u.pkt.num_descr = dr->num_entries;
197 	u.pkt.descr_size = dr->entry_size;
198 	u.pkt.options = VIO_TX_DRING;
199 	u.pkt.num_cookies = dr->ncookies;
200 
201 	viodbg(HS, "SEND DRING_REG INFO ndesc[%u] dsz[%u] opt[0x%x] "
202 	       "ncookies[%u]\n",
203 	       u.pkt.num_descr, u.pkt.descr_size, u.pkt.options,
204 	       u.pkt.num_cookies);
205 
206 	for (i = 0; i < dr->ncookies; i++) {
207 		u.pkt.cookies[i] = dr->cookies[i];
208 
209 		viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
210 		       i,
211 		       (unsigned long long) u.pkt.cookies[i].cookie_addr,
212 		       (unsigned long long) u.pkt.cookies[i].cookie_size);
213 	}
214 
215 	return send_ctrl(vio, &u.pkt.tag, bytes);
216 }
217 
218 static int send_rdx(struct vio_driver_state *vio)
219 {
220 	struct vio_rdx pkt;
221 
222 	memset(&pkt, 0, sizeof(pkt));
223 
224 	init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX);
225 
226 	viodbg(HS, "SEND RDX INFO\n");
227 
228 	return send_ctrl(vio, &pkt.tag, sizeof(pkt));
229 }
230 
231 static int send_attr(struct vio_driver_state *vio)
232 {
233 	if (!vio->ops)
234 		return -EINVAL;
235 
236 	return vio->ops->send_attr(vio);
237 }
238 
239 static struct vio_version *find_by_major(struct vio_driver_state *vio,
240 					 u16 major)
241 {
242 	struct vio_version *ret = NULL;
243 	int i;
244 
245 	for (i = 0; i < vio->ver_table_entries; i++) {
246 		struct vio_version *v = &vio->ver_table[i];
247 		if (v->major <= major) {
248 			ret = v;
249 			break;
250 		}
251 	}
252 	return ret;
253 }
254 
255 static int process_ver_info(struct vio_driver_state *vio,
256 			    struct vio_ver_info *pkt)
257 {
258 	struct vio_version *vap;
259 	int err;
260 
261 	viodbg(HS, "GOT VERSION INFO maj[%u] min[%u] devclass[%u]\n",
262 	       pkt->major, pkt->minor, pkt->dev_class);
263 
264 	if (vio->hs_state != VIO_HS_INVALID) {
265 		/* XXX Perhaps invoke start_handshake? XXX */
266 		memset(&vio->ver, 0, sizeof(vio->ver));
267 		vio->hs_state = VIO_HS_INVALID;
268 	}
269 
270 	vap = find_by_major(vio, pkt->major);
271 
272 	vio->_peer_sid = pkt->tag.sid;
273 
274 	if (!vap) {
275 		pkt->tag.stype = VIO_SUBTYPE_NACK;
276 		pkt->major = 0;
277 		pkt->minor = 0;
278 		viodbg(HS, "SEND VERSION NACK maj[0] min[0]\n");
279 		err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
280 	} else if (vap->major != pkt->major) {
281 		pkt->tag.stype = VIO_SUBTYPE_NACK;
282 		pkt->major = vap->major;
283 		pkt->minor = vap->minor;
284 		viodbg(HS, "SEND VERSION NACK maj[%u] min[%u]\n",
285 		       pkt->major, pkt->minor);
286 		err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
287 	} else {
288 		struct vio_version ver = {
289 			.major = pkt->major,
290 			.minor = pkt->minor,
291 		};
292 		if (ver.minor > vap->minor)
293 			ver.minor = vap->minor;
294 		pkt->minor = ver.minor;
295 		pkt->tag.stype = VIO_SUBTYPE_ACK;
296 		pkt->dev_class = vio->dev_class;
297 		viodbg(HS, "SEND VERSION ACK maj[%u] min[%u]\n",
298 		       pkt->major, pkt->minor);
299 		err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
300 		if (err > 0) {
301 			vio->ver = ver;
302 			vio->hs_state = VIO_HS_GOTVERS;
303 		}
304 	}
305 	if (err < 0)
306 		return handshake_failure(vio);
307 
308 	return 0;
309 }
310 
311 static int process_ver_ack(struct vio_driver_state *vio,
312 			   struct vio_ver_info *pkt)
313 {
314 	viodbg(HS, "GOT VERSION ACK maj[%u] min[%u] devclass[%u]\n",
315 	       pkt->major, pkt->minor, pkt->dev_class);
316 
317 	if (vio->hs_state & VIO_HS_GOTVERS) {
318 		if (vio->ver.major != pkt->major ||
319 		    vio->ver.minor != pkt->minor) {
320 			pkt->tag.stype = VIO_SUBTYPE_NACK;
321 			(void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
322 			return handshake_failure(vio);
323 		}
324 	} else {
325 		vio->ver.major = pkt->major;
326 		vio->ver.minor = pkt->minor;
327 		vio->hs_state = VIO_HS_GOTVERS;
328 	}
329 
330 	switch (vio->dev_class) {
331 	case VDEV_NETWORK:
332 	case VDEV_DISK:
333 		if (send_attr(vio) < 0)
334 			return handshake_failure(vio);
335 		break;
336 
337 	default:
338 		break;
339 	}
340 
341 	return 0;
342 }
343 
344 static int process_ver_nack(struct vio_driver_state *vio,
345 			    struct vio_ver_info *pkt)
346 {
347 	struct vio_version *nver;
348 
349 	viodbg(HS, "GOT VERSION NACK maj[%u] min[%u] devclass[%u]\n",
350 	       pkt->major, pkt->minor, pkt->dev_class);
351 
352 	if (pkt->major == 0 && pkt->minor == 0)
353 		return handshake_failure(vio);
354 	nver = find_by_major(vio, pkt->major);
355 	if (!nver)
356 		return handshake_failure(vio);
357 
358 	if (send_version(vio, nver->major, nver->minor) < 0)
359 		return handshake_failure(vio);
360 
361 	return 0;
362 }
363 
364 static int process_ver(struct vio_driver_state *vio, struct vio_ver_info *pkt)
365 {
366 	switch (pkt->tag.stype) {
367 	case VIO_SUBTYPE_INFO:
368 		return process_ver_info(vio, pkt);
369 
370 	case VIO_SUBTYPE_ACK:
371 		return process_ver_ack(vio, pkt);
372 
373 	case VIO_SUBTYPE_NACK:
374 		return process_ver_nack(vio, pkt);
375 
376 	default:
377 		return handshake_failure(vio);
378 	}
379 }
380 
381 static int process_attr(struct vio_driver_state *vio, void *pkt)
382 {
383 	int err;
384 
385 	if (!(vio->hs_state & VIO_HS_GOTVERS))
386 		return handshake_failure(vio);
387 
388 	if (!vio->ops)
389 		return 0;
390 
391 	err = vio->ops->handle_attr(vio, pkt);
392 	if (err < 0) {
393 		return handshake_failure(vio);
394 	} else {
395 		vio->hs_state |= VIO_HS_GOT_ATTR;
396 
397 		if ((vio->dr_state & VIO_DR_STATE_TXREQ) &&
398 		    !(vio->hs_state & VIO_HS_SENT_DREG)) {
399 			if (send_dreg(vio) < 0)
400 				return handshake_failure(vio);
401 
402 			vio->hs_state |= VIO_HS_SENT_DREG;
403 		}
404 	}
405 
406 	return 0;
407 }
408 
409 static int all_drings_registered(struct vio_driver_state *vio)
410 {
411 	int need_rx, need_tx;
412 
413 	need_rx = (vio->dr_state & VIO_DR_STATE_RXREQ);
414 	need_tx = (vio->dr_state & VIO_DR_STATE_TXREQ);
415 
416 	if (need_rx &&
417 	    !(vio->dr_state & VIO_DR_STATE_RXREG))
418 		return 0;
419 
420 	if (need_tx &&
421 	    !(vio->dr_state & VIO_DR_STATE_TXREG))
422 		return 0;
423 
424 	return 1;
425 }
426 
427 static int process_dreg_info(struct vio_driver_state *vio,
428 			     struct vio_dring_register *pkt)
429 {
430 	struct vio_dring_state *dr;
431 	int i;
432 
433 	viodbg(HS, "GOT DRING_REG INFO ident[%llx] "
434 	       "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
435 	       (unsigned long long) pkt->dring_ident,
436 	       pkt->num_descr, pkt->descr_size, pkt->options,
437 	       pkt->num_cookies);
438 
439 	if (!(vio->dr_state & VIO_DR_STATE_RXREQ))
440 		goto send_nack;
441 
442 	if (vio->dr_state & VIO_DR_STATE_RXREG)
443 		goto send_nack;
444 
445 	/* v1.6 and higher, ACK with desired, supported mode, or NACK */
446 	if (vio_version_after_eq(vio, 1, 6)) {
447 		if (!(pkt->options & VIO_TX_DRING))
448 			goto send_nack;
449 		pkt->options = VIO_TX_DRING;
450 	}
451 
452 	BUG_ON(vio->desc_buf);
453 
454 	vio->desc_buf = kzalloc(pkt->descr_size, GFP_ATOMIC);
455 	if (!vio->desc_buf)
456 		goto send_nack;
457 
458 	vio->desc_buf_len = pkt->descr_size;
459 
460 	dr = &vio->drings[VIO_DRIVER_RX_RING];
461 
462 	dr->num_entries = pkt->num_descr;
463 	dr->entry_size = pkt->descr_size;
464 	dr->ncookies = pkt->num_cookies;
465 	for (i = 0; i < dr->ncookies; i++) {
466 		dr->cookies[i] = pkt->cookies[i];
467 
468 		viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
469 		       i,
470 		       (unsigned long long)
471 		       pkt->cookies[i].cookie_addr,
472 		       (unsigned long long)
473 		       pkt->cookies[i].cookie_size);
474 	}
475 
476 	pkt->tag.stype = VIO_SUBTYPE_ACK;
477 	pkt->dring_ident = ++dr->ident;
478 
479 	viodbg(HS, "SEND 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,
483 	       pkt->num_cookies);
484 
485 	if (send_ctrl(vio, &pkt->tag, struct_size(pkt, cookies, dr->ncookies)) < 0)
486 		goto send_nack;
487 
488 	vio->dr_state |= VIO_DR_STATE_RXREG;
489 
490 	return 0;
491 
492 send_nack:
493 	pkt->tag.stype = VIO_SUBTYPE_NACK;
494 	viodbg(HS, "SEND DRING_REG NACK\n");
495 	(void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
496 
497 	return handshake_failure(vio);
498 }
499 
500 static int process_dreg_ack(struct vio_driver_state *vio,
501 			    struct vio_dring_register *pkt)
502 {
503 	struct vio_dring_state *dr;
504 
505 	viodbg(HS, "GOT DRING_REG ACK ident[%llx] "
506 	       "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
507 	       (unsigned long long) pkt->dring_ident,
508 	       pkt->num_descr, pkt->descr_size, pkt->options,
509 	       pkt->num_cookies);
510 
511 	dr = &vio->drings[VIO_DRIVER_TX_RING];
512 
513 	if (!(vio->dr_state & VIO_DR_STATE_TXREQ))
514 		return handshake_failure(vio);
515 
516 	dr->ident = pkt->dring_ident;
517 	vio->dr_state |= VIO_DR_STATE_TXREG;
518 
519 	if (all_drings_registered(vio)) {
520 		if (send_rdx(vio) < 0)
521 			return handshake_failure(vio);
522 		vio->hs_state = VIO_HS_SENT_RDX;
523 	}
524 	return 0;
525 }
526 
527 static int process_dreg_nack(struct vio_driver_state *vio,
528 			     struct vio_dring_register *pkt)
529 {
530 	viodbg(HS, "GOT DRING_REG NACK ident[%llx] "
531 	       "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
532 	       (unsigned long long) pkt->dring_ident,
533 	       pkt->num_descr, pkt->descr_size, pkt->options,
534 	       pkt->num_cookies);
535 
536 	return handshake_failure(vio);
537 }
538 
539 static int process_dreg(struct vio_driver_state *vio,
540 			struct vio_dring_register *pkt)
541 {
542 	if (!(vio->hs_state & VIO_HS_GOTVERS))
543 		return handshake_failure(vio);
544 
545 	switch (pkt->tag.stype) {
546 	case VIO_SUBTYPE_INFO:
547 		return process_dreg_info(vio, pkt);
548 
549 	case VIO_SUBTYPE_ACK:
550 		return process_dreg_ack(vio, pkt);
551 
552 	case VIO_SUBTYPE_NACK:
553 		return process_dreg_nack(vio, pkt);
554 
555 	default:
556 		return handshake_failure(vio);
557 	}
558 }
559 
560 static int process_dunreg(struct vio_driver_state *vio,
561 			  struct vio_dring_unregister *pkt)
562 {
563 	struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_RX_RING];
564 
565 	viodbg(HS, "GOT DRING_UNREG\n");
566 
567 	if (pkt->dring_ident != dr->ident)
568 		return 0;
569 
570 	vio->dr_state &= ~VIO_DR_STATE_RXREG;
571 
572 	memset(dr, 0, sizeof(*dr));
573 
574 	kfree(vio->desc_buf);
575 	vio->desc_buf = NULL;
576 	vio->desc_buf_len = 0;
577 
578 	return 0;
579 }
580 
581 static int process_rdx_info(struct vio_driver_state *vio, struct vio_rdx *pkt)
582 {
583 	viodbg(HS, "GOT RDX INFO\n");
584 
585 	pkt->tag.stype = VIO_SUBTYPE_ACK;
586 	viodbg(HS, "SEND RDX ACK\n");
587 	if (send_ctrl(vio, &pkt->tag, sizeof(*pkt)) < 0)
588 		return handshake_failure(vio);
589 
590 	vio->hs_state |= VIO_HS_SENT_RDX_ACK;
591 	return 0;
592 }
593 
594 static int process_rdx_ack(struct vio_driver_state *vio, struct vio_rdx *pkt)
595 {
596 	viodbg(HS, "GOT RDX ACK\n");
597 
598 	if (!(vio->hs_state & VIO_HS_SENT_RDX))
599 		return handshake_failure(vio);
600 
601 	vio->hs_state |= VIO_HS_GOT_RDX_ACK;
602 	return 0;
603 }
604 
605 static int process_rdx_nack(struct vio_driver_state *vio, struct vio_rdx *pkt)
606 {
607 	viodbg(HS, "GOT RDX NACK\n");
608 
609 	return handshake_failure(vio);
610 }
611 
612 static int process_rdx(struct vio_driver_state *vio, struct vio_rdx *pkt)
613 {
614 	if (!all_drings_registered(vio))
615 		handshake_failure(vio);
616 
617 	switch (pkt->tag.stype) {
618 	case VIO_SUBTYPE_INFO:
619 		return process_rdx_info(vio, pkt);
620 
621 	case VIO_SUBTYPE_ACK:
622 		return process_rdx_ack(vio, pkt);
623 
624 	case VIO_SUBTYPE_NACK:
625 		return process_rdx_nack(vio, pkt);
626 
627 	default:
628 		return handshake_failure(vio);
629 	}
630 }
631 
632 int vio_control_pkt_engine(struct vio_driver_state *vio, void *pkt)
633 {
634 	struct vio_msg_tag *tag = pkt;
635 	u8 prev_state = vio->hs_state;
636 	int err;
637 
638 	switch (tag->stype_env) {
639 	case VIO_VER_INFO:
640 		err = process_ver(vio, pkt);
641 		break;
642 
643 	case VIO_ATTR_INFO:
644 		err = process_attr(vio, pkt);
645 		break;
646 
647 	case VIO_DRING_REG:
648 		err = process_dreg(vio, pkt);
649 		break;
650 
651 	case VIO_DRING_UNREG:
652 		err = process_dunreg(vio, pkt);
653 		break;
654 
655 	case VIO_RDX:
656 		err = process_rdx(vio, pkt);
657 		break;
658 
659 	default:
660 		err = process_unknown(vio, pkt);
661 		break;
662 	}
663 
664 	if (!err &&
665 	    vio->hs_state != prev_state &&
666 	    (vio->hs_state & VIO_HS_COMPLETE)) {
667 		if (vio->ops)
668 			vio->ops->handshake_complete(vio);
669 	}
670 
671 	return err;
672 }
673 EXPORT_SYMBOL(vio_control_pkt_engine);
674 
675 void vio_conn_reset(struct vio_driver_state *vio)
676 {
677 }
678 EXPORT_SYMBOL(vio_conn_reset);
679 
680 /* The issue is that the Solaris virtual disk server just mirrors the
681  * SID values it gets from the client peer.  So we work around that
682  * here in vio_{validate,send}_sid() so that the drivers don't need
683  * to be aware of this crap.
684  */
685 int vio_validate_sid(struct vio_driver_state *vio, struct vio_msg_tag *tp)
686 {
687 	u32 sid;
688 
689 	/* Always let VERSION+INFO packets through unchecked, they
690 	 * define the new SID.
691 	 */
692 	if (tp->type == VIO_TYPE_CTRL &&
693 	    tp->stype == VIO_SUBTYPE_INFO &&
694 	    tp->stype_env == VIO_VER_INFO)
695 		return 0;
696 
697 	/* Ok, now figure out which SID to use.  */
698 	switch (vio->dev_class) {
699 	case VDEV_NETWORK:
700 	case VDEV_NETWORK_SWITCH:
701 	case VDEV_DISK_SERVER:
702 	default:
703 		sid = vio->_peer_sid;
704 		break;
705 
706 	case VDEV_DISK:
707 		sid = vio->_local_sid;
708 		break;
709 	}
710 
711 	if (sid == tp->sid)
712 		return 0;
713 	viodbg(DATA, "BAD SID tag->sid[%08x] peer_sid[%08x] local_sid[%08x]\n",
714 	       tp->sid, vio->_peer_sid, vio->_local_sid);
715 	return -EINVAL;
716 }
717 EXPORT_SYMBOL(vio_validate_sid);
718 
719 u32 vio_send_sid(struct vio_driver_state *vio)
720 {
721 	switch (vio->dev_class) {
722 	case VDEV_NETWORK:
723 	case VDEV_NETWORK_SWITCH:
724 	case VDEV_DISK:
725 	default:
726 		return vio->_local_sid;
727 
728 	case VDEV_DISK_SERVER:
729 		return vio->_peer_sid;
730 	}
731 }
732 EXPORT_SYMBOL(vio_send_sid);
733 
734 int vio_ldc_alloc(struct vio_driver_state *vio,
735 			 struct ldc_channel_config *base_cfg,
736 			 void *event_arg)
737 {
738 	struct ldc_channel_config cfg = *base_cfg;
739 	struct ldc_channel *lp;
740 
741 	cfg.tx_irq = vio->vdev->tx_irq;
742 	cfg.rx_irq = vio->vdev->rx_irq;
743 
744 	lp = ldc_alloc(vio->vdev->channel_id, &cfg, event_arg, vio->name);
745 	if (IS_ERR(lp))
746 		return PTR_ERR(lp);
747 
748 	vio->lp = lp;
749 
750 	return 0;
751 }
752 EXPORT_SYMBOL(vio_ldc_alloc);
753 
754 void vio_ldc_free(struct vio_driver_state *vio)
755 {
756 	ldc_free(vio->lp);
757 	vio->lp = NULL;
758 
759 	kfree(vio->desc_buf);
760 	vio->desc_buf = NULL;
761 	vio->desc_buf_len = 0;
762 }
763 EXPORT_SYMBOL(vio_ldc_free);
764 
765 void vio_port_up(struct vio_driver_state *vio)
766 {
767 	unsigned long flags;
768 	int err, state;
769 
770 	spin_lock_irqsave(&vio->lock, flags);
771 
772 	state = ldc_state(vio->lp);
773 
774 	err = 0;
775 	if (state == LDC_STATE_INIT) {
776 		err = ldc_bind(vio->lp);
777 		if (err)
778 			printk(KERN_WARNING "%s: Port %lu bind failed, "
779 			       "err=%d\n",
780 			       vio->name, vio->vdev->channel_id, err);
781 	}
782 
783 	if (!err) {
784 		if (ldc_mode(vio->lp) == LDC_MODE_RAW)
785 			ldc_set_state(vio->lp, LDC_STATE_CONNECTED);
786 		else
787 			err = ldc_connect(vio->lp);
788 
789 		if (err)
790 			printk(KERN_WARNING "%s: Port %lu connect failed, "
791 			       "err=%d\n",
792 			       vio->name, vio->vdev->channel_id, err);
793 	}
794 	if (err) {
795 		unsigned long expires = jiffies + HZ;
796 
797 		expires = round_jiffies(expires);
798 		mod_timer(&vio->timer, expires);
799 	}
800 
801 	spin_unlock_irqrestore(&vio->lock, flags);
802 }
803 EXPORT_SYMBOL(vio_port_up);
804 
805 static void vio_port_timer(struct timer_list *t)
806 {
807 	struct vio_driver_state *vio = from_timer(vio, t, timer);
808 
809 	vio_port_up(vio);
810 }
811 
812 int vio_driver_init(struct vio_driver_state *vio, struct vio_dev *vdev,
813 		    u8 dev_class, struct vio_version *ver_table,
814 		    int ver_table_size, struct vio_driver_ops *ops,
815 		    char *name)
816 {
817 	switch (dev_class) {
818 	case VDEV_NETWORK:
819 	case VDEV_NETWORK_SWITCH:
820 	case VDEV_DISK:
821 	case VDEV_DISK_SERVER:
822 	case VDEV_CONSOLE_CON:
823 		break;
824 
825 	default:
826 		return -EINVAL;
827 	}
828 
829 	if (dev_class == VDEV_NETWORK ||
830 	    dev_class == VDEV_NETWORK_SWITCH ||
831 	    dev_class == VDEV_DISK ||
832 	    dev_class == VDEV_DISK_SERVER) {
833 		if (!ops || !ops->send_attr || !ops->handle_attr ||
834 		    !ops->handshake_complete)
835 			return -EINVAL;
836 	}
837 
838 	if (!ver_table || ver_table_size < 0)
839 		return -EINVAL;
840 
841 	if (!name)
842 		return -EINVAL;
843 
844 	spin_lock_init(&vio->lock);
845 
846 	vio->name = name;
847 
848 	vio->dev_class = dev_class;
849 	vio->vdev = vdev;
850 
851 	vio->ver_table = ver_table;
852 	vio->ver_table_entries = ver_table_size;
853 
854 	vio->ops = ops;
855 
856 	timer_setup(&vio->timer, vio_port_timer, 0);
857 
858 	return 0;
859 }
860 EXPORT_SYMBOL(vio_driver_init);
861