merge filename and modify reference to iseries/hv_lp_config.h
[linux-2.6.git] / arch / powerpc / platforms / iseries / viopath.c
1 /* -*- linux-c -*-
2  *
3  *  iSeries Virtual I/O Message Path code
4  *
5  *  Authors: Dave Boutcher <boutcher@us.ibm.com>
6  *           Ryan Arnold <ryanarn@us.ibm.com>
7  *           Colin Devilbiss <devilbis@us.ibm.com>
8  *
9  * (C) Copyright 2000-2005 IBM Corporation
10  *
11  * This code is used by the iSeries virtual disk, cd,
12  * tape, and console to communicate with OS/400 in another
13  * partition.
14  *
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.
19  *
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.
24  *
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
28  *
29  */
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>
41
42 #include <asm/system.h>
43 #include <asm/uaccess.h>
44 #include <asm/iSeries/HvTypes.h>
45 #include <asm/iSeries/ItExtVpdPanel.h>
46 #include <asm/iSeries/HvLpEvent.h>
47 #include <asm/iseries/hv_lp_config.h>
48 #include <asm/iSeries/mf.h>
49 #include <asm/iSeries/vio.h>
50
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.
55  */
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;
62         int numberAllocated;
63 } viopathStatus[HVMAXARCHITECTEDLPS];
64
65 static DEFINE_SPINLOCK(statuslock);
66
67 /*
68  * For each kind of event we allocate a buffer that is
69  * guaranteed not to cross a page boundary
70  */
71 static unsigned char event_buffer[VIO_MAX_SUBTYPES * 256] __page_aligned;
72 static atomic_t event_buffer_available[VIO_MAX_SUBTYPES];
73 static int event_buffer_initialised;
74
75 static void handleMonitorEvent(struct HvLpEvent *event);
76
77 /*
78  * We use this structure to handle asynchronous responses.  The caller
79  * blocks on the semaphore and the handler posts the semaphore.  However,
80  * if system_state is not SYSTEM_RUNNING, then wait_atomic is used ...
81  */
82 struct alloc_parms {
83         struct semaphore sem;
84         int number;
85         atomic_t wait_atomic;
86         int used_wait_atomic;
87 };
88
89 /* Put a sequence number in each mon msg.  The value is not
90  * important.  Start at something other than 0 just for
91  * readability.  wrapping this is ok.
92  */
93 static u8 viomonseq = 22;
94
95 /* Our hosting logical partition.  We get this at startup
96  * time, and different modules access this variable directly.
97  */
98 HvLpIndex viopath_hostLp = HvLpIndexInvalid;
99 EXPORT_SYMBOL(viopath_hostLp);
100 HvLpIndex viopath_ourLp = HvLpIndexInvalid;
101 EXPORT_SYMBOL(viopath_ourLp);
102
103 /* For each kind of incoming event we set a pointer to a
104  * routine to call.
105  */
106 static vio_event_handler_t *vio_handler[VIO_MAX_SUBTYPES];
107
108 #define VIOPATH_KERN_WARN       KERN_WARNING "viopath: "
109 #define VIOPATH_KERN_INFO       KERN_INFO "viopath: "
110
111 static int proc_viopath_show(struct seq_file *m, void *v)
112 {
113         char *buf;
114         u16 vlanMap;
115         dma_addr_t handle;
116         HvLpEvent_Rc hvrc;
117         DECLARE_MUTEX_LOCKED(Semaphore);
118
119         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
120         if (!buf)
121                 return 0;
122         memset(buf, 0, PAGE_SIZE);
123
124         handle = dma_map_single(iSeries_vio_dev, buf, PAGE_SIZE,
125                                 DMA_FROM_DEVICE);
126
127         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
128                         HvLpEvent_Type_VirtualIo,
129                         viomajorsubtype_config | vioconfigget,
130                         HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
131                         viopath_sourceinst(viopath_hostLp),
132                         viopath_targetinst(viopath_hostLp),
133                         (u64)(unsigned long)&Semaphore, VIOVERSION << 16,
134                         ((u64)handle) << 32, PAGE_SIZE, 0, 0);
135
136         if (hvrc != HvLpEvent_Rc_Good)
137                 printk(VIOPATH_KERN_WARN "hv error on op %d\n", (int)hvrc);
138
139         down(&Semaphore);
140
141         vlanMap = HvLpConfig_getVirtualLanIndexMap();
142
143         buf[PAGE_SIZE-1] = '\0';
144         seq_printf(m, "%s", buf);
145         seq_printf(m, "AVAILABLE_VETH=%x\n", vlanMap);
146         seq_printf(m, "SRLNBR=%c%c%c%c%c%c%c\n",
147                    e2a(xItExtVpdPanel.mfgID[2]),
148                    e2a(xItExtVpdPanel.mfgID[3]),
149                    e2a(xItExtVpdPanel.systemSerial[1]),
150                    e2a(xItExtVpdPanel.systemSerial[2]),
151                    e2a(xItExtVpdPanel.systemSerial[3]),
152                    e2a(xItExtVpdPanel.systemSerial[4]),
153                    e2a(xItExtVpdPanel.systemSerial[5]));
154
155         dma_unmap_single(iSeries_vio_dev, handle, PAGE_SIZE, DMA_FROM_DEVICE);
156         kfree(buf);
157
158         return 0;
159 }
160
161 static int proc_viopath_open(struct inode *inode, struct file *file)
162 {
163         return single_open(file, proc_viopath_show, NULL);
164 }
165
166 static struct file_operations proc_viopath_operations = {
167         .open           = proc_viopath_open,
168         .read           = seq_read,
169         .llseek         = seq_lseek,
170         .release        = single_release,
171 };
172
173 static int __init vio_proc_init(void)
174 {
175         struct proc_dir_entry *e;
176
177         e = create_proc_entry("iSeries/config", 0, NULL);
178         if (e)
179                 e->proc_fops = &proc_viopath_operations;
180
181         return 0;
182 }
183 __initcall(vio_proc_init);
184
185 /* See if a given LP is active.  Allow for invalid lps to be passed in
186  * and just return invalid
187  */
188 int viopath_isactive(HvLpIndex lp)
189 {
190         if (lp == HvLpIndexInvalid)
191                 return 0;
192         if (lp < HVMAXARCHITECTEDLPS)
193                 return viopathStatus[lp].isActive;
194         else
195                 return 0;
196 }
197 EXPORT_SYMBOL(viopath_isactive);
198
199 /*
200  * We cache the source and target instance ids for each
201  * partition.
202  */
203 HvLpInstanceId viopath_sourceinst(HvLpIndex lp)
204 {
205         return viopathStatus[lp].mSourceInst;
206 }
207 EXPORT_SYMBOL(viopath_sourceinst);
208
209 HvLpInstanceId viopath_targetinst(HvLpIndex lp)
210 {
211         return viopathStatus[lp].mTargetInst;
212 }
213 EXPORT_SYMBOL(viopath_targetinst);
214
215 /*
216  * Send a monitor message.  This is a message with the acknowledge
217  * bit on that the other side will NOT explicitly acknowledge.  When
218  * the other side goes down, the hypervisor will acknowledge any
219  * outstanding messages....so we will know when the other side dies.
220  */
221 static void sendMonMsg(HvLpIndex remoteLp)
222 {
223         HvLpEvent_Rc hvrc;
224
225         viopathStatus[remoteLp].mSourceInst =
226                 HvCallEvent_getSourceLpInstanceId(remoteLp,
227                                 HvLpEvent_Type_VirtualIo);
228         viopathStatus[remoteLp].mTargetInst =
229                 HvCallEvent_getTargetLpInstanceId(remoteLp,
230                                 HvLpEvent_Type_VirtualIo);
231
232         /*
233          * Deliberately ignore the return code here.  if we call this
234          * more than once, we don't care.
235          */
236         vio_setHandler(viomajorsubtype_monitor, handleMonitorEvent);
237
238         hvrc = HvCallEvent_signalLpEventFast(remoteLp, HvLpEvent_Type_VirtualIo,
239                         viomajorsubtype_monitor, HvLpEvent_AckInd_DoAck,
240                         HvLpEvent_AckType_DeferredAck,
241                         viopathStatus[remoteLp].mSourceInst,
242                         viopathStatus[remoteLp].mTargetInst,
243                         viomonseq++, 0, 0, 0, 0, 0);
244
245         if (hvrc == HvLpEvent_Rc_Good)
246                 viopathStatus[remoteLp].isActive = 1;
247         else {
248                 printk(VIOPATH_KERN_WARN "could not connect to partition %d\n",
249                                 remoteLp);
250                 viopathStatus[remoteLp].isActive = 0;
251         }
252 }
253
254 static void handleMonitorEvent(struct HvLpEvent *event)
255 {
256         HvLpIndex remoteLp;
257         int i;
258
259         /*
260          * This handler is _also_ called as part of the loop
261          * at the end of this routine, so it must be able to
262          * ignore NULL events...
263          */
264         if (!event)
265                 return;
266
267         /*
268          * First see if this is just a normal monitor message from the
269          * other partition
270          */
271         if (event->xFlags.xFunction == HvLpEvent_Function_Int) {
272                 remoteLp = event->xSourceLp;
273                 if (!viopathStatus[remoteLp].isActive)
274                         sendMonMsg(remoteLp);
275                 return;
276         }
277
278         /*
279          * This path is for an acknowledgement; the other partition
280          * died
281          */
282         remoteLp = event->xTargetLp;
283         if ((event->xSourceInstanceId != viopathStatus[remoteLp].mSourceInst) ||
284             (event->xTargetInstanceId != viopathStatus[remoteLp].mTargetInst)) {
285                 printk(VIOPATH_KERN_WARN "ignoring ack....mismatched instances\n");
286                 return;
287         }
288
289         printk(VIOPATH_KERN_WARN "partition %d ended\n", remoteLp);
290
291         viopathStatus[remoteLp].isActive = 0;
292
293         /*
294          * For each active handler, pass them a NULL
295          * message to indicate that the other partition
296          * died
297          */
298         for (i = 0; i < VIO_MAX_SUBTYPES; i++) {
299                 if (vio_handler[i] != NULL)
300                         (*vio_handler[i])(NULL);
301         }
302 }
303
304 int vio_setHandler(int subtype, vio_event_handler_t *beh)
305 {
306         subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT;
307         if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES))
308                 return -EINVAL;
309         if (vio_handler[subtype] != NULL)
310                 return -EBUSY;
311         vio_handler[subtype] = beh;
312         return 0;
313 }
314 EXPORT_SYMBOL(vio_setHandler);
315
316 int vio_clearHandler(int subtype)
317 {
318         subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT;
319         if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES))
320                 return -EINVAL;
321         if (vio_handler[subtype] == NULL)
322                 return -EAGAIN;
323         vio_handler[subtype] = NULL;
324         return 0;
325 }
326 EXPORT_SYMBOL(vio_clearHandler);
327
328 static void handleConfig(struct HvLpEvent *event)
329 {
330         if (!event)
331                 return;
332         if (event->xFlags.xFunction == HvLpEvent_Function_Int) {
333                 printk(VIOPATH_KERN_WARN
334                        "unexpected config request from partition %d",
335                        event->xSourceLp);
336
337                 if ((event->xFlags.xFunction == HvLpEvent_Function_Int) &&
338                     (event->xFlags.xAckInd == HvLpEvent_AckInd_DoAck)) {
339                         event->xRc = HvLpEvent_Rc_InvalidSubtype;
340                         HvCallEvent_ackLpEvent(event);
341                 }
342                 return;
343         }
344
345         up((struct semaphore *)event->xCorrelationToken);
346 }
347
348 /*
349  * Initialization of the hosting partition
350  */
351 void vio_set_hostlp(void)
352 {
353         /*
354          * If this has already been set then we DON'T want to either change
355          * it or re-register the proc file system
356          */
357         if (viopath_hostLp != HvLpIndexInvalid)
358                 return;
359
360         /*
361          * Figure out our hosting partition.  This isn't allowed to change
362          * while we're active
363          */
364         viopath_ourLp = HvLpConfig_getLpIndex();
365         viopath_hostLp = HvLpConfig_getHostingLpIndex(viopath_ourLp);
366
367         if (viopath_hostLp != HvLpIndexInvalid)
368                 vio_setHandler(viomajorsubtype_config, handleConfig);
369 }
370 EXPORT_SYMBOL(vio_set_hostlp);
371
372 static void vio_handleEvent(struct HvLpEvent *event, struct pt_regs *regs)
373 {
374         HvLpIndex remoteLp;
375         int subtype = (event->xSubtype & VIOMAJOR_SUBTYPE_MASK)
376                 >> VIOMAJOR_SUBTYPE_SHIFT;
377
378         if (event->xFlags.xFunction == HvLpEvent_Function_Int) {
379                 remoteLp = event->xSourceLp;
380                 /*
381                  * The isActive is checked because if the hosting partition
382                  * went down and came back up it would not be active but it
383                  * would have different source and target instances, in which
384                  * case we'd want to reset them.  This case really protects
385                  * against an unauthorized active partition sending interrupts
386                  * or acks to this linux partition.
387                  */
388                 if (viopathStatus[remoteLp].isActive
389                     && (event->xSourceInstanceId !=
390                         viopathStatus[remoteLp].mTargetInst)) {
391                         printk(VIOPATH_KERN_WARN
392                                "message from invalid partition. "
393                                "int msg rcvd, source inst (%d) doesnt match (%d)\n",
394                                viopathStatus[remoteLp].mTargetInst,
395                                event->xSourceInstanceId);
396                         return;
397                 }
398
399                 if (viopathStatus[remoteLp].isActive
400                     && (event->xTargetInstanceId !=
401                         viopathStatus[remoteLp].mSourceInst)) {
402                         printk(VIOPATH_KERN_WARN
403                                "message from invalid partition. "
404                                "int msg rcvd, target inst (%d) doesnt match (%d)\n",
405                                viopathStatus[remoteLp].mSourceInst,
406                                event->xTargetInstanceId);
407                         return;
408                 }
409         } else {
410                 remoteLp = event->xTargetLp;
411                 if (event->xSourceInstanceId !=
412                     viopathStatus[remoteLp].mSourceInst) {
413                         printk(VIOPATH_KERN_WARN
414                                "message from invalid partition. "
415                                "ack msg rcvd, source inst (%d) doesnt match (%d)\n",
416                                viopathStatus[remoteLp].mSourceInst,
417                                event->xSourceInstanceId);
418                         return;
419                 }
420
421                 if (event->xTargetInstanceId !=
422                     viopathStatus[remoteLp].mTargetInst) {
423                         printk(VIOPATH_KERN_WARN
424                                "message from invalid partition. "
425                                "viopath: ack msg rcvd, target inst (%d) doesnt match (%d)\n",
426                                viopathStatus[remoteLp].mTargetInst,
427                                event->xTargetInstanceId);
428                         return;
429                 }
430         }
431
432         if (vio_handler[subtype] == NULL) {
433                 printk(VIOPATH_KERN_WARN
434                        "unexpected virtual io event subtype %d from partition %d\n",
435                        event->xSubtype, remoteLp);
436                 /* No handler.  Ack if necessary */
437                 if ((event->xFlags.xFunction == HvLpEvent_Function_Int) &&
438                     (event->xFlags.xAckInd == HvLpEvent_AckInd_DoAck)) {
439                         event->xRc = HvLpEvent_Rc_InvalidSubtype;
440                         HvCallEvent_ackLpEvent(event);
441                 }
442                 return;
443         }
444
445         /* This innocuous little line is where all the real work happens */
446         (*vio_handler[subtype])(event);
447 }
448
449 static void viopath_donealloc(void *parm, int number)
450 {
451         struct alloc_parms *parmsp = parm;
452
453         parmsp->number = number;
454         if (parmsp->used_wait_atomic)
455                 atomic_set(&parmsp->wait_atomic, 0);
456         else
457                 up(&parmsp->sem);
458 }
459
460 static int allocateEvents(HvLpIndex remoteLp, int numEvents)
461 {
462         struct alloc_parms parms;
463
464         if (system_state != SYSTEM_RUNNING) {
465                 parms.used_wait_atomic = 1;
466                 atomic_set(&parms.wait_atomic, 1);
467         } else {
468                 parms.used_wait_atomic = 0;
469                 init_MUTEX_LOCKED(&parms.sem);
470         }
471         mf_allocate_lp_events(remoteLp, HvLpEvent_Type_VirtualIo, 250,  /* It would be nice to put a real number here! */
472                             numEvents, &viopath_donealloc, &parms);
473         if (system_state != SYSTEM_RUNNING) {
474                 while (atomic_read(&parms.wait_atomic))
475                         mb();
476         } else
477                 down(&parms.sem);
478         return parms.number;
479 }
480
481 int viopath_open(HvLpIndex remoteLp, int subtype, int numReq)
482 {
483         int i;
484         unsigned long flags;
485         int tempNumAllocated;
486
487         if ((remoteLp >= HVMAXARCHITECTEDLPS) || (remoteLp == HvLpIndexInvalid))
488                 return -EINVAL;
489
490         subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT;
491         if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES))
492                 return -EINVAL;
493
494         spin_lock_irqsave(&statuslock, flags);
495
496         if (!event_buffer_initialised) {
497                 for (i = 0; i < VIO_MAX_SUBTYPES; i++)
498                         atomic_set(&event_buffer_available[i], 1);
499                 event_buffer_initialised = 1;
500         }
501
502         viopathStatus[remoteLp].users[subtype]++;
503
504         if (!viopathStatus[remoteLp].isOpen) {
505                 viopathStatus[remoteLp].isOpen = 1;
506                 HvCallEvent_openLpEventPath(remoteLp, HvLpEvent_Type_VirtualIo);
507
508                 /*
509                  * Don't hold the spinlock during an operation that
510                  * can sleep.
511                  */
512                 spin_unlock_irqrestore(&statuslock, flags);
513                 tempNumAllocated = allocateEvents(remoteLp, 1);
514                 spin_lock_irqsave(&statuslock, flags);
515
516                 viopathStatus[remoteLp].numberAllocated += tempNumAllocated;
517
518                 if (viopathStatus[remoteLp].numberAllocated == 0) {
519                         HvCallEvent_closeLpEventPath(remoteLp,
520                                         HvLpEvent_Type_VirtualIo);
521
522                         spin_unlock_irqrestore(&statuslock, flags);
523                         return -ENOMEM;
524                 }
525
526                 viopathStatus[remoteLp].mSourceInst =
527                         HvCallEvent_getSourceLpInstanceId(remoteLp,
528                                         HvLpEvent_Type_VirtualIo);
529                 viopathStatus[remoteLp].mTargetInst =
530                         HvCallEvent_getTargetLpInstanceId(remoteLp,
531                                         HvLpEvent_Type_VirtualIo);
532                 HvLpEvent_registerHandler(HvLpEvent_Type_VirtualIo,
533                                           &vio_handleEvent);
534                 sendMonMsg(remoteLp);
535                 printk(VIOPATH_KERN_INFO "opening connection to partition %d, "
536                                 "setting sinst %d, tinst %d\n",
537                                 remoteLp, viopathStatus[remoteLp].mSourceInst,
538                                 viopathStatus[remoteLp].mTargetInst);
539         }
540
541         spin_unlock_irqrestore(&statuslock, flags);
542         tempNumAllocated = allocateEvents(remoteLp, numReq);
543         spin_lock_irqsave(&statuslock, flags);
544         viopathStatus[remoteLp].numberAllocated += tempNumAllocated;
545         spin_unlock_irqrestore(&statuslock, flags);
546
547         return 0;
548 }
549 EXPORT_SYMBOL(viopath_open);
550
551 int viopath_close(HvLpIndex remoteLp, int subtype, int numReq)
552 {
553         unsigned long flags;
554         int i;
555         int numOpen;
556         struct alloc_parms parms;
557
558         if ((remoteLp >= HVMAXARCHITECTEDLPS) || (remoteLp == HvLpIndexInvalid))
559                 return -EINVAL;
560
561         subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT;
562         if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES))
563                 return -EINVAL;
564
565         spin_lock_irqsave(&statuslock, flags);
566         /*
567          * If the viopath_close somehow gets called before a
568          * viopath_open it could decrement to -1 which is a non
569          * recoverable state so we'll prevent this from
570          * happening.
571          */
572         if (viopathStatus[remoteLp].users[subtype] > 0)
573                 viopathStatus[remoteLp].users[subtype]--;
574
575         spin_unlock_irqrestore(&statuslock, flags);
576
577         parms.used_wait_atomic = 0;
578         init_MUTEX_LOCKED(&parms.sem);
579         mf_deallocate_lp_events(remoteLp, HvLpEvent_Type_VirtualIo,
580                               numReq, &viopath_donealloc, &parms);
581         down(&parms.sem);
582
583         spin_lock_irqsave(&statuslock, flags);
584         for (i = 0, numOpen = 0; i < VIO_MAX_SUBTYPES; i++)
585                 numOpen += viopathStatus[remoteLp].users[i];
586
587         if ((viopathStatus[remoteLp].isOpen) && (numOpen == 0)) {
588                 printk(VIOPATH_KERN_INFO "closing connection to partition %d",
589                                 remoteLp);
590
591                 HvCallEvent_closeLpEventPath(remoteLp,
592                                              HvLpEvent_Type_VirtualIo);
593                 viopathStatus[remoteLp].isOpen = 0;
594                 viopathStatus[remoteLp].isActive = 0;
595
596                 for (i = 0; i < VIO_MAX_SUBTYPES; i++)
597                         atomic_set(&event_buffer_available[i], 0);
598                 event_buffer_initialised = 0;
599         }
600         spin_unlock_irqrestore(&statuslock, flags);
601         return 0;
602 }
603 EXPORT_SYMBOL(viopath_close);
604
605 void *vio_get_event_buffer(int subtype)
606 {
607         subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT;
608         if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES))
609                 return NULL;
610
611         if (atomic_dec_if_positive(&event_buffer_available[subtype]) == 0)
612                 return &event_buffer[subtype * 256];
613         else
614                 return NULL;
615 }
616 EXPORT_SYMBOL(vio_get_event_buffer);
617
618 void vio_free_event_buffer(int subtype, void *buffer)
619 {
620         subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT;
621         if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES)) {
622                 printk(VIOPATH_KERN_WARN
623                        "unexpected subtype %d freeing event buffer\n", subtype);
624                 return;
625         }
626
627         if (atomic_read(&event_buffer_available[subtype]) != 0) {
628                 printk(VIOPATH_KERN_WARN
629                        "freeing unallocated event buffer, subtype %d\n",
630                        subtype);
631                 return;
632         }
633
634         if (buffer != &event_buffer[subtype * 256]) {
635                 printk(VIOPATH_KERN_WARN
636                        "freeing invalid event buffer, subtype %d\n", subtype);
637         }
638
639         atomic_set(&event_buffer_available[subtype], 1);
640 }
641 EXPORT_SYMBOL(vio_free_event_buffer);
642
643 static const struct vio_error_entry vio_no_error =
644     { 0, 0, "Non-VIO Error" };
645 static const struct vio_error_entry vio_unknown_error =
646     { 0, EIO, "Unknown Error" };
647
648 static const struct vio_error_entry vio_default_errors[] = {
649         {0x0001, EIO, "No Connection"},
650         {0x0002, EIO, "No Receiver"},
651         {0x0003, EIO, "No Buffer Available"},
652         {0x0004, EBADRQC, "Invalid Message Type"},
653         {0x0000, 0, NULL},
654 };
655
656 const struct vio_error_entry *vio_lookup_rc(
657                 const struct vio_error_entry *local_table, u16 rc)
658 {
659         const struct vio_error_entry *cur;
660
661         if (!rc)
662                 return &vio_no_error;
663         if (local_table)
664                 for (cur = local_table; cur->rc; ++cur)
665                         if (cur->rc == rc)
666                                 return cur;
667         for (cur = vio_default_errors; cur->rc; ++cur)
668                 if (cur->rc == rc)
669                         return cur;
670         return &vio_unknown_error;
671 }
672 EXPORT_SYMBOL(vio_lookup_rc);