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