3 * iSeries Virtual I/O Message Path code
5 * Authors: Dave Boutcher <boutcher@us.ibm.com>
6 * Ryan Arnold <ryanarn@us.ibm.com>
7 * Colin Devilbiss <devilbis@us.ibm.com>
9 * (C) Copyright 2000-2005 IBM Corporation
11 * This code is used by the iSeries virtual disk, cd,
12 * tape, and console to communicate with OS/400 in another
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation; either version 2 of the
18 * License, or (at your option) anyu later version.
20 * This program is distributed in the hope that it will be useful, but
21 * WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software Foundation,
27 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 #include <linux/module.h>
31 #include <linux/kernel.h>
32 #include <linux/errno.h>
33 #include <linux/vmalloc.h>
34 #include <linux/string.h>
35 #include <linux/proc_fs.h>
36 #include <linux/dma-mapping.h>
37 #include <linux/wait.h>
38 #include <linux/seq_file.h>
39 #include <linux/smp_lock.h>
40 #include <linux/interrupt.h>
42 #include <asm/system.h>
43 #include <asm/uaccess.h>
44 #include <asm/iseries/hv_types.h>
45 #include <asm/iseries/it_exp_vpd_panel.h>
46 #include <asm/iseries/hv_lp_event.h>
47 #include <asm/iseries/hv_lp_config.h>
48 #include <asm/iseries/mf.h>
49 #include <asm/iseries/vio.h>
51 /* Status of the path to each other partition in the system.
52 * This is overkill, since we will only ever establish connections
53 * to our hosting partition and the primary partition on the system.
54 * But this allows for other support in the future.
56 static struct viopathStatus
{
57 int isOpen
; /* Did we open the path? */
58 int isActive
; /* Do we have a mon msg outstanding */
59 int users
[VIO_MAX_SUBTYPES
];
60 HvLpInstanceId mSourceInst
;
61 HvLpInstanceId mTargetInst
;
63 } viopathStatus
[HVMAXARCHITECTEDLPS
];
65 static DEFINE_SPINLOCK(statuslock
);
68 * For each kind of event we allocate a buffer that is
69 * guaranteed not to cross a page boundary
71 static unsigned char event_buffer
[VIO_MAX_SUBTYPES
* 256]
72 __attribute__((__aligned__(4096)));
73 static atomic_t event_buffer_available
[VIO_MAX_SUBTYPES
];
74 static int event_buffer_initialised
;
76 static void handleMonitorEvent(struct HvLpEvent
*event
);
79 * We use this structure to handle asynchronous responses. The caller
80 * blocks on the semaphore and the handler posts the semaphore. However,
81 * if system_state is not SYSTEM_RUNNING, then wait_atomic is used ...
90 /* Put a sequence number in each mon msg. The value is not
91 * important. Start at something other than 0 just for
92 * readability. wrapping this is ok.
94 static u8 viomonseq
= 22;
96 /* Our hosting logical partition. We get this at startup
97 * time, and different modules access this variable directly.
99 HvLpIndex viopath_hostLp
= HvLpIndexInvalid
;
100 EXPORT_SYMBOL(viopath_hostLp
);
101 HvLpIndex viopath_ourLp
= HvLpIndexInvalid
;
102 EXPORT_SYMBOL(viopath_ourLp
);
104 /* For each kind of incoming event we set a pointer to a
107 static vio_event_handler_t
*vio_handler
[VIO_MAX_SUBTYPES
];
109 #define VIOPATH_KERN_WARN KERN_WARNING "viopath: "
110 #define VIOPATH_KERN_INFO KERN_INFO "viopath: "
112 static int proc_viopath_show(struct seq_file
*m
, void *v
)
118 DECLARE_MUTEX_LOCKED(Semaphore
);
120 buf
= kmalloc(HW_PAGE_SIZE
, GFP_KERNEL
);
123 memset(buf
, 0, HW_PAGE_SIZE
);
125 handle
= dma_map_single(iSeries_vio_dev
, buf
, HW_PAGE_SIZE
,
128 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
129 HvLpEvent_Type_VirtualIo
,
130 viomajorsubtype_config
| vioconfigget
,
131 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
132 viopath_sourceinst(viopath_hostLp
),
133 viopath_targetinst(viopath_hostLp
),
134 (u64
)(unsigned long)&Semaphore
, VIOVERSION
<< 16,
135 ((u64
)handle
) << 32, HW_PAGE_SIZE
, 0, 0);
137 if (hvrc
!= HvLpEvent_Rc_Good
)
138 printk(VIOPATH_KERN_WARN
"hv error on op %d\n", (int)hvrc
);
142 vlanMap
= HvLpConfig_getVirtualLanIndexMap();
144 buf
[HW_PAGE_SIZE
-1] = '\0';
145 seq_printf(m
, "%s", buf
);
146 seq_printf(m
, "AVAILABLE_VETH=%x\n", vlanMap
);
147 seq_printf(m
, "SRLNBR=%c%c%c%c%c%c%c\n",
148 e2a(xItExtVpdPanel
.mfgID
[2]),
149 e2a(xItExtVpdPanel
.mfgID
[3]),
150 e2a(xItExtVpdPanel
.systemSerial
[1]),
151 e2a(xItExtVpdPanel
.systemSerial
[2]),
152 e2a(xItExtVpdPanel
.systemSerial
[3]),
153 e2a(xItExtVpdPanel
.systemSerial
[4]),
154 e2a(xItExtVpdPanel
.systemSerial
[5]));
156 dma_unmap_single(iSeries_vio_dev
, handle
, HW_PAGE_SIZE
,
163 static int proc_viopath_open(struct inode
*inode
, struct file
*file
)
165 return single_open(file
, proc_viopath_show
, NULL
);
168 static struct file_operations proc_viopath_operations
= {
169 .open
= proc_viopath_open
,
172 .release
= single_release
,
175 static int __init
vio_proc_init(void)
177 struct proc_dir_entry
*e
;
179 e
= create_proc_entry("iSeries/config", 0, NULL
);
181 e
->proc_fops
= &proc_viopath_operations
;
185 __initcall(vio_proc_init
);
187 /* See if a given LP is active. Allow for invalid lps to be passed in
188 * and just return invalid
190 int viopath_isactive(HvLpIndex lp
)
192 if (lp
== HvLpIndexInvalid
)
194 if (lp
< HVMAXARCHITECTEDLPS
)
195 return viopathStatus
[lp
].isActive
;
199 EXPORT_SYMBOL(viopath_isactive
);
202 * We cache the source and target instance ids for each
205 HvLpInstanceId
viopath_sourceinst(HvLpIndex lp
)
207 return viopathStatus
[lp
].mSourceInst
;
209 EXPORT_SYMBOL(viopath_sourceinst
);
211 HvLpInstanceId
viopath_targetinst(HvLpIndex lp
)
213 return viopathStatus
[lp
].mTargetInst
;
215 EXPORT_SYMBOL(viopath_targetinst
);
218 * Send a monitor message. This is a message with the acknowledge
219 * bit on that the other side will NOT explicitly acknowledge. When
220 * the other side goes down, the hypervisor will acknowledge any
221 * outstanding messages....so we will know when the other side dies.
223 static void sendMonMsg(HvLpIndex remoteLp
)
227 viopathStatus
[remoteLp
].mSourceInst
=
228 HvCallEvent_getSourceLpInstanceId(remoteLp
,
229 HvLpEvent_Type_VirtualIo
);
230 viopathStatus
[remoteLp
].mTargetInst
=
231 HvCallEvent_getTargetLpInstanceId(remoteLp
,
232 HvLpEvent_Type_VirtualIo
);
235 * Deliberately ignore the return code here. if we call this
236 * more than once, we don't care.
238 vio_setHandler(viomajorsubtype_monitor
, handleMonitorEvent
);
240 hvrc
= HvCallEvent_signalLpEventFast(remoteLp
, HvLpEvent_Type_VirtualIo
,
241 viomajorsubtype_monitor
, HvLpEvent_AckInd_DoAck
,
242 HvLpEvent_AckType_DeferredAck
,
243 viopathStatus
[remoteLp
].mSourceInst
,
244 viopathStatus
[remoteLp
].mTargetInst
,
245 viomonseq
++, 0, 0, 0, 0, 0);
247 if (hvrc
== HvLpEvent_Rc_Good
)
248 viopathStatus
[remoteLp
].isActive
= 1;
250 printk(VIOPATH_KERN_WARN
"could not connect to partition %d\n",
252 viopathStatus
[remoteLp
].isActive
= 0;
256 static void handleMonitorEvent(struct HvLpEvent
*event
)
262 * This handler is _also_ called as part of the loop
263 * at the end of this routine, so it must be able to
264 * ignore NULL events...
270 * First see if this is just a normal monitor message from the
273 if (event
->xFlags
.xFunction
== HvLpEvent_Function_Int
) {
274 remoteLp
= event
->xSourceLp
;
275 if (!viopathStatus
[remoteLp
].isActive
)
276 sendMonMsg(remoteLp
);
281 * This path is for an acknowledgement; the other partition
284 remoteLp
= event
->xTargetLp
;
285 if ((event
->xSourceInstanceId
!= viopathStatus
[remoteLp
].mSourceInst
) ||
286 (event
->xTargetInstanceId
!= viopathStatus
[remoteLp
].mTargetInst
)) {
287 printk(VIOPATH_KERN_WARN
"ignoring ack....mismatched instances\n");
291 printk(VIOPATH_KERN_WARN
"partition %d ended\n", remoteLp
);
293 viopathStatus
[remoteLp
].isActive
= 0;
296 * For each active handler, pass them a NULL
297 * message to indicate that the other partition
300 for (i
= 0; i
< VIO_MAX_SUBTYPES
; i
++) {
301 if (vio_handler
[i
] != NULL
)
302 (*vio_handler
[i
])(NULL
);
306 int vio_setHandler(int subtype
, vio_event_handler_t
*beh
)
308 subtype
= subtype
>> VIOMAJOR_SUBTYPE_SHIFT
;
309 if ((subtype
< 0) || (subtype
>= VIO_MAX_SUBTYPES
))
311 if (vio_handler
[subtype
] != NULL
)
313 vio_handler
[subtype
] = beh
;
316 EXPORT_SYMBOL(vio_setHandler
);
318 int vio_clearHandler(int subtype
)
320 subtype
= subtype
>> VIOMAJOR_SUBTYPE_SHIFT
;
321 if ((subtype
< 0) || (subtype
>= VIO_MAX_SUBTYPES
))
323 if (vio_handler
[subtype
] == NULL
)
325 vio_handler
[subtype
] = NULL
;
328 EXPORT_SYMBOL(vio_clearHandler
);
330 static void handleConfig(struct HvLpEvent
*event
)
334 if (event
->xFlags
.xFunction
== HvLpEvent_Function_Int
) {
335 printk(VIOPATH_KERN_WARN
336 "unexpected config request from partition %d",
339 if ((event
->xFlags
.xFunction
== HvLpEvent_Function_Int
) &&
340 (event
->xFlags
.xAckInd
== HvLpEvent_AckInd_DoAck
)) {
341 event
->xRc
= HvLpEvent_Rc_InvalidSubtype
;
342 HvCallEvent_ackLpEvent(event
);
347 up((struct semaphore
*)event
->xCorrelationToken
);
351 * Initialization of the hosting partition
353 void vio_set_hostlp(void)
356 * If this has already been set then we DON'T want to either change
357 * it or re-register the proc file system
359 if (viopath_hostLp
!= HvLpIndexInvalid
)
363 * Figure out our hosting partition. This isn't allowed to change
366 viopath_ourLp
= HvLpConfig_getLpIndex();
367 viopath_hostLp
= HvLpConfig_getHostingLpIndex(viopath_ourLp
);
369 if (viopath_hostLp
!= HvLpIndexInvalid
)
370 vio_setHandler(viomajorsubtype_config
, handleConfig
);
372 EXPORT_SYMBOL(vio_set_hostlp
);
374 static void vio_handleEvent(struct HvLpEvent
*event
, struct pt_regs
*regs
)
377 int subtype
= (event
->xSubtype
& VIOMAJOR_SUBTYPE_MASK
)
378 >> VIOMAJOR_SUBTYPE_SHIFT
;
380 if (event
->xFlags
.xFunction
== HvLpEvent_Function_Int
) {
381 remoteLp
= event
->xSourceLp
;
383 * The isActive is checked because if the hosting partition
384 * went down and came back up it would not be active but it
385 * would have different source and target instances, in which
386 * case we'd want to reset them. This case really protects
387 * against an unauthorized active partition sending interrupts
388 * or acks to this linux partition.
390 if (viopathStatus
[remoteLp
].isActive
391 && (event
->xSourceInstanceId
!=
392 viopathStatus
[remoteLp
].mTargetInst
)) {
393 printk(VIOPATH_KERN_WARN
394 "message from invalid partition. "
395 "int msg rcvd, source inst (%d) doesnt match (%d)\n",
396 viopathStatus
[remoteLp
].mTargetInst
,
397 event
->xSourceInstanceId
);
401 if (viopathStatus
[remoteLp
].isActive
402 && (event
->xTargetInstanceId
!=
403 viopathStatus
[remoteLp
].mSourceInst
)) {
404 printk(VIOPATH_KERN_WARN
405 "message from invalid partition. "
406 "int msg rcvd, target inst (%d) doesnt match (%d)\n",
407 viopathStatus
[remoteLp
].mSourceInst
,
408 event
->xTargetInstanceId
);
412 remoteLp
= event
->xTargetLp
;
413 if (event
->xSourceInstanceId
!=
414 viopathStatus
[remoteLp
].mSourceInst
) {
415 printk(VIOPATH_KERN_WARN
416 "message from invalid partition. "
417 "ack msg rcvd, source inst (%d) doesnt match (%d)\n",
418 viopathStatus
[remoteLp
].mSourceInst
,
419 event
->xSourceInstanceId
);
423 if (event
->xTargetInstanceId
!=
424 viopathStatus
[remoteLp
].mTargetInst
) {
425 printk(VIOPATH_KERN_WARN
426 "message from invalid partition. "
427 "viopath: ack msg rcvd, target inst (%d) doesnt match (%d)\n",
428 viopathStatus
[remoteLp
].mTargetInst
,
429 event
->xTargetInstanceId
);
434 if (vio_handler
[subtype
] == NULL
) {
435 printk(VIOPATH_KERN_WARN
436 "unexpected virtual io event subtype %d from partition %d\n",
437 event
->xSubtype
, remoteLp
);
438 /* No handler. Ack if necessary */
439 if ((event
->xFlags
.xFunction
== HvLpEvent_Function_Int
) &&
440 (event
->xFlags
.xAckInd
== HvLpEvent_AckInd_DoAck
)) {
441 event
->xRc
= HvLpEvent_Rc_InvalidSubtype
;
442 HvCallEvent_ackLpEvent(event
);
447 /* This innocuous little line is where all the real work happens */
448 (*vio_handler
[subtype
])(event
);
451 static void viopath_donealloc(void *parm
, int number
)
453 struct alloc_parms
*parmsp
= parm
;
455 parmsp
->number
= number
;
456 if (parmsp
->used_wait_atomic
)
457 atomic_set(&parmsp
->wait_atomic
, 0);
462 static int allocateEvents(HvLpIndex remoteLp
, int numEvents
)
464 struct alloc_parms parms
;
466 if (system_state
!= SYSTEM_RUNNING
) {
467 parms
.used_wait_atomic
= 1;
468 atomic_set(&parms
.wait_atomic
, 1);
470 parms
.used_wait_atomic
= 0;
471 init_MUTEX_LOCKED(&parms
.sem
);
473 mf_allocate_lp_events(remoteLp
, HvLpEvent_Type_VirtualIo
, 250, /* It would be nice to put a real number here! */
474 numEvents
, &viopath_donealloc
, &parms
);
475 if (system_state
!= SYSTEM_RUNNING
) {
476 while (atomic_read(&parms
.wait_atomic
))
483 int viopath_open(HvLpIndex remoteLp
, int subtype
, int numReq
)
487 int tempNumAllocated
;
489 if ((remoteLp
>= HVMAXARCHITECTEDLPS
) || (remoteLp
== HvLpIndexInvalid
))
492 subtype
= subtype
>> VIOMAJOR_SUBTYPE_SHIFT
;
493 if ((subtype
< 0) || (subtype
>= VIO_MAX_SUBTYPES
))
496 spin_lock_irqsave(&statuslock
, flags
);
498 if (!event_buffer_initialised
) {
499 for (i
= 0; i
< VIO_MAX_SUBTYPES
; i
++)
500 atomic_set(&event_buffer_available
[i
], 1);
501 event_buffer_initialised
= 1;
504 viopathStatus
[remoteLp
].users
[subtype
]++;
506 if (!viopathStatus
[remoteLp
].isOpen
) {
507 viopathStatus
[remoteLp
].isOpen
= 1;
508 HvCallEvent_openLpEventPath(remoteLp
, HvLpEvent_Type_VirtualIo
);
511 * Don't hold the spinlock during an operation that
514 spin_unlock_irqrestore(&statuslock
, flags
);
515 tempNumAllocated
= allocateEvents(remoteLp
, 1);
516 spin_lock_irqsave(&statuslock
, flags
);
518 viopathStatus
[remoteLp
].numberAllocated
+= tempNumAllocated
;
520 if (viopathStatus
[remoteLp
].numberAllocated
== 0) {
521 HvCallEvent_closeLpEventPath(remoteLp
,
522 HvLpEvent_Type_VirtualIo
);
524 spin_unlock_irqrestore(&statuslock
, flags
);
528 viopathStatus
[remoteLp
].mSourceInst
=
529 HvCallEvent_getSourceLpInstanceId(remoteLp
,
530 HvLpEvent_Type_VirtualIo
);
531 viopathStatus
[remoteLp
].mTargetInst
=
532 HvCallEvent_getTargetLpInstanceId(remoteLp
,
533 HvLpEvent_Type_VirtualIo
);
534 HvLpEvent_registerHandler(HvLpEvent_Type_VirtualIo
,
536 sendMonMsg(remoteLp
);
537 printk(VIOPATH_KERN_INFO
"opening connection to partition %d, "
538 "setting sinst %d, tinst %d\n",
539 remoteLp
, viopathStatus
[remoteLp
].mSourceInst
,
540 viopathStatus
[remoteLp
].mTargetInst
);
543 spin_unlock_irqrestore(&statuslock
, flags
);
544 tempNumAllocated
= allocateEvents(remoteLp
, numReq
);
545 spin_lock_irqsave(&statuslock
, flags
);
546 viopathStatus
[remoteLp
].numberAllocated
+= tempNumAllocated
;
547 spin_unlock_irqrestore(&statuslock
, flags
);
551 EXPORT_SYMBOL(viopath_open
);
553 int viopath_close(HvLpIndex remoteLp
, int subtype
, int numReq
)
558 struct alloc_parms parms
;
560 if ((remoteLp
>= HVMAXARCHITECTEDLPS
) || (remoteLp
== HvLpIndexInvalid
))
563 subtype
= subtype
>> VIOMAJOR_SUBTYPE_SHIFT
;
564 if ((subtype
< 0) || (subtype
>= VIO_MAX_SUBTYPES
))
567 spin_lock_irqsave(&statuslock
, flags
);
569 * If the viopath_close somehow gets called before a
570 * viopath_open it could decrement to -1 which is a non
571 * recoverable state so we'll prevent this from
574 if (viopathStatus
[remoteLp
].users
[subtype
] > 0)
575 viopathStatus
[remoteLp
].users
[subtype
]--;
577 spin_unlock_irqrestore(&statuslock
, flags
);
579 parms
.used_wait_atomic
= 0;
580 init_MUTEX_LOCKED(&parms
.sem
);
581 mf_deallocate_lp_events(remoteLp
, HvLpEvent_Type_VirtualIo
,
582 numReq
, &viopath_donealloc
, &parms
);
585 spin_lock_irqsave(&statuslock
, flags
);
586 for (i
= 0, numOpen
= 0; i
< VIO_MAX_SUBTYPES
; i
++)
587 numOpen
+= viopathStatus
[remoteLp
].users
[i
];
589 if ((viopathStatus
[remoteLp
].isOpen
) && (numOpen
== 0)) {
590 printk(VIOPATH_KERN_INFO
"closing connection to partition %d",
593 HvCallEvent_closeLpEventPath(remoteLp
,
594 HvLpEvent_Type_VirtualIo
);
595 viopathStatus
[remoteLp
].isOpen
= 0;
596 viopathStatus
[remoteLp
].isActive
= 0;
598 for (i
= 0; i
< VIO_MAX_SUBTYPES
; i
++)
599 atomic_set(&event_buffer_available
[i
], 0);
600 event_buffer_initialised
= 0;
602 spin_unlock_irqrestore(&statuslock
, flags
);
605 EXPORT_SYMBOL(viopath_close
);
607 void *vio_get_event_buffer(int subtype
)
609 subtype
= subtype
>> VIOMAJOR_SUBTYPE_SHIFT
;
610 if ((subtype
< 0) || (subtype
>= VIO_MAX_SUBTYPES
))
613 if (atomic_dec_if_positive(&event_buffer_available
[subtype
]) == 0)
614 return &event_buffer
[subtype
* 256];
618 EXPORT_SYMBOL(vio_get_event_buffer
);
620 void vio_free_event_buffer(int subtype
, void *buffer
)
622 subtype
= subtype
>> VIOMAJOR_SUBTYPE_SHIFT
;
623 if ((subtype
< 0) || (subtype
>= VIO_MAX_SUBTYPES
)) {
624 printk(VIOPATH_KERN_WARN
625 "unexpected subtype %d freeing event buffer\n", subtype
);
629 if (atomic_read(&event_buffer_available
[subtype
]) != 0) {
630 printk(VIOPATH_KERN_WARN
631 "freeing unallocated event buffer, subtype %d\n",
636 if (buffer
!= &event_buffer
[subtype
* 256]) {
637 printk(VIOPATH_KERN_WARN
638 "freeing invalid event buffer, subtype %d\n", subtype
);
641 atomic_set(&event_buffer_available
[subtype
], 1);
643 EXPORT_SYMBOL(vio_free_event_buffer
);
645 static const struct vio_error_entry vio_no_error
=
646 { 0, 0, "Non-VIO Error" };
647 static const struct vio_error_entry vio_unknown_error
=
648 { 0, EIO
, "Unknown Error" };
650 static const struct vio_error_entry vio_default_errors
[] = {
651 {0x0001, EIO
, "No Connection"},
652 {0x0002, EIO
, "No Receiver"},
653 {0x0003, EIO
, "No Buffer Available"},
654 {0x0004, EBADRQC
, "Invalid Message Type"},
658 const struct vio_error_entry
*vio_lookup_rc(
659 const struct vio_error_entry
*local_table
, u16 rc
)
661 const struct vio_error_entry
*cur
;
664 return &vio_no_error
;
666 for (cur
= local_table
; cur
->rc
; ++cur
)
669 for (cur
= vio_default_errors
; cur
->rc
; ++cur
)
672 return &vio_unknown_error
;
674 EXPORT_SYMBOL(vio_lookup_rc
);