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