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