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