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