?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'kvm-updates/2.6.36' of git://git.kernel.org/pub/scm/virt/kvm/kvm
[linux-rapidio-2.6.git] / drivers / char / rio / riointr.c
blob2e71aecae206a434fb72501df914f34e90a6b6fb
1 /*
2 ** -----------------------------------------------------------------------------
3 **
4 ** Perle Specialix driver for Linux
5 ** Ported from existing RIO Driver for SCO sources.
6 *
7 * (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 **
23 ** Module : riointr.c
24 ** SID : 1.2
25 ** Last Modified : 11/6/98 10:33:44
26 ** Retrieved : 11/6/98 10:33:49
27 **
28 ** ident @(#)riointr.c 1.2
29 **
30 ** -----------------------------------------------------------------------------
31 */
32
33 #include <linux/module.h>
34 #include <linux/errno.h>
35 #include <linux/tty.h>
36 #include <linux/tty_flip.h>
37 #include <asm/io.h>
38 #include <asm/system.h>
39 #include <asm/string.h>
40 #include <asm/uaccess.h>
41
42 #include <linux/termios.h>
43 #include <linux/serial.h>
44
45 #include <linux/generic_serial.h>
46
47 #include <linux/delay.h>
48
49 #include "linux_compat.h"
50 #include "rio_linux.h"
51 #include "pkt.h"
52 #include "daemon.h"
53 #include "rio.h"
54 #include "riospace.h"
55 #include "cmdpkt.h"
56 #include "map.h"
57 #include "rup.h"
58 #include "port.h"
59 #include "riodrvr.h"
60 #include "rioinfo.h"
61 #include "func.h"
62 #include "errors.h"
63 #include "pci.h"
64
65 #include "parmmap.h"
66 #include "unixrup.h"
67 #include "board.h"
68 #include "host.h"
69 #include "phb.h"
70 #include "link.h"
71 #include "cmdblk.h"
72 #include "route.h"
73 #include "cirrus.h"
74 #include "rioioctl.h"
75
76
77 static void RIOReceive(struct rio_info *, struct Port *);
78
79
80 static char *firstchars(char *p, int nch)
81 {
82 static char buf[2][128];
83 static int t = 0;
84 t = !t;
85 memcpy(buf[t], p, nch);
86 buf[t][nch] = 0;
87 return buf[t];
88 }
89
90
91 #define INCR( P, I ) ((P) = (((P)+(I)) & p->RIOBufferMask))
92 /* Enable and start the transmission of packets */
93 void RIOTxEnable(char *en)
94 {
95 struct Port *PortP;
96 struct rio_info *p;
97 struct tty_struct *tty;
98 int c;
99 struct PKT __iomem *PacketP;
100 unsigned long flags;
101
102 PortP = (struct Port *) en;
103 p = (struct rio_info *) PortP->p;
104 tty = PortP->gs.port.tty;
105
106
107 rio_dprintk(RIO_DEBUG_INTR, "tx port %d: %d chars queued.\n", PortP->PortNum, PortP->gs.xmit_cnt);
108
109 if (!PortP->gs.xmit_cnt)
110 return;
111
112
113 /* This routine is an order of magnitude simpler than the specialix
114 version. One of the disadvantages is that this version will send
115 an incomplete packet (usually 64 bytes instead of 72) once for
116 every 4k worth of data. Let's just say that this won't influence
117 performance significantly..... */
118
119 rio_spin_lock_irqsave(&PortP->portSem, flags);
120
121 while (can_add_transmit(&PacketP, PortP)) {
122 c = PortP->gs.xmit_cnt;
123 if (c > PKT_MAX_DATA_LEN)
124 c = PKT_MAX_DATA_LEN;
125
126 /* Don't copy past the end of the source buffer */
127 if (c > SERIAL_XMIT_SIZE - PortP->gs.xmit_tail)
128 c = SERIAL_XMIT_SIZE - PortP->gs.xmit_tail;
129
130 {
131 int t;
132 t = (c > 10) ? 10 : c;
133
134 rio_dprintk(RIO_DEBUG_INTR, "rio: tx port %d: copying %d chars: %s - %s\n", PortP->PortNum, c, firstchars(PortP->gs.xmit_buf + PortP->gs.xmit_tail, t), firstchars(PortP->gs.xmit_buf + PortP->gs.xmit_tail + c - t, t));
135 }
136 /* If for one reason or another, we can't copy more data,
137 we're done! */
138 if (c == 0)
139 break;
140
141 rio_memcpy_toio(PortP->HostP->Caddr, PacketP->data, PortP->gs.xmit_buf + PortP->gs.xmit_tail, c);
142 /* udelay (1); */
143
144 writeb(c, &(PacketP->len));
145 if (!(PortP->State & RIO_DELETED)) {
146 add_transmit(PortP);
147 /*
148 ** Count chars tx'd for port statistics reporting
149 */
150 if (PortP->statsGather)
151 PortP->txchars += c;
152 }
153 PortP->gs.xmit_tail = (PortP->gs.xmit_tail + c) & (SERIAL_XMIT_SIZE - 1);
154 PortP->gs.xmit_cnt -= c;
155 }
156
157 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
158
159 if (PortP->gs.xmit_cnt <= (PortP->gs.wakeup_chars + 2 * PKT_MAX_DATA_LEN))
160 tty_wakeup(PortP->gs.port.tty);
161
162 }
163
164
165 /*
166 ** RIO Host Service routine. Does all the work traditionally associated with an
167 ** interrupt.
168 */
169 static int RupIntr;
170 static int RxIntr;
171 static int TxIntr;
172
173 void RIOServiceHost(struct rio_info *p, struct Host *HostP)
174 {
175 rio_spin_lock(&HostP->HostLock);
176 if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
177 static int t = 0;
178 rio_spin_unlock(&HostP->HostLock);
179 if ((t++ % 200) == 0)
180 rio_dprintk(RIO_DEBUG_INTR, "Interrupt but host not running. flags=%x.\n", (int) HostP->Flags);
181 return;
182 }
183 rio_spin_unlock(&HostP->HostLock);
184
185 if (readw(&HostP->ParmMapP->rup_intr)) {
186 writew(0, &HostP->ParmMapP->rup_intr);
187 p->RIORupCount++;
188 RupIntr++;
189 rio_dprintk(RIO_DEBUG_INTR, "rio: RUP interrupt on host %Zd\n", HostP - p->RIOHosts);
190 RIOPollHostCommands(p, HostP);
191 }
192
193 if (readw(&HostP->ParmMapP->rx_intr)) {
194 int port;
195
196 writew(0, &HostP->ParmMapP->rx_intr);
197 p->RIORxCount++;
198 RxIntr++;
199
200 rio_dprintk(RIO_DEBUG_INTR, "rio: RX interrupt on host %Zd\n", HostP - p->RIOHosts);
201 /*
202 ** Loop through every port. If the port is mapped into
203 ** the system ( i.e. has /dev/ttyXXXX associated ) then it is
204 ** worth checking. If the port isn't open, grab any packets
205 ** hanging on its receive queue and stuff them on the free
206 ** list; check for commands on the way.
207 */
208 for (port = p->RIOFirstPortsBooted; port < p->RIOLastPortsBooted + PORTS_PER_RTA; port++) {
209 struct Port *PortP = p->RIOPortp[port];
210 struct tty_struct *ttyP;
211 struct PKT __iomem *PacketP;
212
213 /*
214 ** not mapped in - most of the RIOPortp[] information
215 ** has not been set up!
216 ** Optimise: ports come in bundles of eight.
217 */
218 if (!PortP->Mapped) {
219 port += 7;
220 continue; /* with the next port */
221 }
222
223 /*
224 ** If the host board isn't THIS host board, check the next one.
225 ** optimise: ports come in bundles of eight.
226 */
227 if (PortP->HostP != HostP) {
228 port += 7;
229 continue;
230 }
231
232 /*
233 ** Let us see - is the port open? If not, then don't service it.
234 */
235 if (!(PortP->PortState & PORT_ISOPEN)) {
236 continue;
237 }
238
239 /*
240 ** find corresponding tty structure. The process of mapping
241 ** the ports puts these here.
242 */
243 ttyP = PortP->gs.port.tty;
244
245 /*
246 ** Lock the port before we begin working on it.
247 */
248 rio_spin_lock(&PortP->portSem);
249
250 /*
251 ** Process received data if there is any.
252 */
253 if (can_remove_receive(&PacketP, PortP))
254 RIOReceive(p, PortP);
255
256 /*
257 ** If there is no data left to be read from the port, and
258 ** it's handshake bit is set, then we must clear the handshake,
259 ** so that that downstream RTA is re-enabled.
260 */
261 if (!can_remove_receive(&PacketP, PortP) && (readw(&PortP->PhbP->handshake) == PHB_HANDSHAKE_SET)) {
262 /*
263 ** MAGIC! ( Basically, handshake the RX buffer, so that
264 ** the RTAs upstream can be re-enabled. )
265 */
266 rio_dprintk(RIO_DEBUG_INTR, "Set RX handshake bit\n");
267 writew(PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET, &PortP->PhbP->handshake);
268 }
269 rio_spin_unlock(&PortP->portSem);
270 }
271 }
272
273 if (readw(&HostP->ParmMapP->tx_intr)) {
274 int port;
275
276 writew(0, &HostP->ParmMapP->tx_intr);
277
278 p->RIOTxCount++;
279 TxIntr++;
280 rio_dprintk(RIO_DEBUG_INTR, "rio: TX interrupt on host %Zd\n", HostP - p->RIOHosts);
281
282 /*
283 ** Loop through every port.
284 ** If the port is mapped into the system ( i.e. has /dev/ttyXXXX
285 ** associated ) then it is worth checking.
286 */
287 for (port = p->RIOFirstPortsBooted; port < p->RIOLastPortsBooted + PORTS_PER_RTA; port++) {
288 struct Port *PortP = p->RIOPortp[port];
289 struct tty_struct *ttyP;
290 struct PKT __iomem *PacketP;
291
292 /*
293 ** not mapped in - most of the RIOPortp[] information
294 ** has not been set up!
295 */
296 if (!PortP->Mapped) {
297 port += 7;
298 continue; /* with the next port */
299 }
300
301 /*
302 ** If the host board isn't running, then its data structures
303 ** are no use to us - continue quietly.
304 */
305 if (PortP->HostP != HostP) {
306 port += 7;
307 continue; /* with the next port */
308 }
309
310 /*
311 ** Let us see - is the port open? If not, then don't service it.
312 */
313 if (!(PortP->PortState & PORT_ISOPEN)) {
314 continue;
315 }
316
317 rio_dprintk(RIO_DEBUG_INTR, "rio: Looking into port %d.\n", port);
318 /*
319 ** Lock the port before we begin working on it.
320 */
321 rio_spin_lock(&PortP->portSem);
322
323 /*
324 ** If we can't add anything to the transmit queue, then
325 ** we need do none of this processing.
326 */
327 if (!can_add_transmit(&PacketP, PortP)) {
328 rio_dprintk(RIO_DEBUG_INTR, "Can't add to port, so skipping.\n");
329 rio_spin_unlock(&PortP->portSem);
330 continue;
331 }
332
333 /*
334 ** find corresponding tty structure. The process of mapping
335 ** the ports puts these here.
336 */
337 ttyP = PortP->gs.port.tty;
338 /* If ttyP is NULL, the port is getting closed. Forget about it. */
339 if (!ttyP) {
340 rio_dprintk(RIO_DEBUG_INTR, "no tty, so skipping.\n");
341 rio_spin_unlock(&PortP->portSem);
342 continue;
343 }
344 /*
345 ** If there is more room available we start up the transmit
346 ** data process again. This can be direct I/O, if the cookmode
347 ** is set to COOK_RAW or COOK_MEDIUM, or will be a call to the
348 ** riotproc( T_OUTPUT ) if we are in COOK_WELL mode, to fetch
349 ** characters via the line discipline. We must always call
350 ** the line discipline,
351 ** so that user input characters can be echoed correctly.
352 **
353 ** ++++ Update +++++
354 ** With the advent of double buffering, we now see if
355 ** TxBufferOut-In is non-zero. If so, then we copy a packet
356 ** to the output place, and set it going. If this empties
357 ** the buffer, then we must issue a wakeup( ) on OUT.
358 ** If it frees space in the buffer then we must issue
359 ** a wakeup( ) on IN.
360 **
361 ** ++++ Extra! Extra! If PortP->WflushFlag is set, then we
362 ** have to send a WFLUSH command down the PHB, to mark the
363 ** end point of a WFLUSH. We also need to clear out any
364 ** data from the double buffer! ( note that WflushFlag is a
365 ** *count* of the number of WFLUSH commands outstanding! )
366 **
367 ** ++++ And there's more!
368 ** If an RTA is powered off, then on again, and rebooted,
369 ** whilst it has ports open, then we need to re-open the ports.
370 ** ( reasonable enough ). We can't do this when we spot the
371 ** re-boot, in interrupt time, because the queue is probably
372 ** full. So, when we come in here, we need to test if any
373 ** ports are in this condition, and re-open the port before
374 ** we try to send any more data to it. Now, the re-booted
375 ** RTA will be discarding packets from the PHB until it
376 ** receives this open packet, but don't worry tooo much
377 ** about that. The one thing that is interesting is the
378 ** combination of this effect and the WFLUSH effect!
379 */
380 /* For now don't handle RTA reboots. -- REW.
381 Reenabled. Otherwise RTA reboots didn't work. Duh. -- REW */
382 if (PortP->MagicFlags) {
383 if (PortP->MagicFlags & MAGIC_REBOOT) {
384 /*
385 ** well, the RTA has been rebooted, and there is room
386 ** on its queue to add the open packet that is required.
387 **
388 ** The messy part of this line is trying to decide if
389 ** we need to call the Param function as a tty or as
390 ** a modem.
391 ** DONT USE CLOCAL AS A TEST FOR THIS!
392 **
393 ** If we can't param the port, then move on to the
394 ** next port.
395 */
396 PortP->InUse = NOT_INUSE;
397
398 rio_spin_unlock(&PortP->portSem);
399 if (RIOParam(PortP, RIOC_OPEN, ((PortP->Cor2Copy & (RIOC_COR2_RTSFLOW | RIOC_COR2_CTSFLOW)) == (RIOC_COR2_RTSFLOW | RIOC_COR2_CTSFLOW)) ? 1 : 0, DONT_SLEEP) == RIO_FAIL)
400 continue; /* with next port */
401 rio_spin_lock(&PortP->portSem);
402 PortP->MagicFlags &= ~MAGIC_REBOOT;
403 }
404
405 /*
406 ** As mentioned above, this is a tacky hack to cope
407 ** with WFLUSH
408 */
409 if (PortP->WflushFlag) {
410 rio_dprintk(RIO_DEBUG_INTR, "Want to WFLUSH mark this port\n");
411
412 if (PortP->InUse)
413 rio_dprintk(RIO_DEBUG_INTR, "FAILS - PORT IS IN USE\n");
414 }
415
416 while (PortP->WflushFlag && can_add_transmit(&PacketP, PortP) && (PortP->InUse == NOT_INUSE)) {
417 int p;
418 struct PktCmd __iomem *PktCmdP;
419
420 rio_dprintk(RIO_DEBUG_INTR, "Add WFLUSH marker to data queue\n");
421 /*
422 ** make it look just like a WFLUSH command
423 */
424 PktCmdP = (struct PktCmd __iomem *) &PacketP->data[0];
425
426 writeb(RIOC_WFLUSH, &PktCmdP->Command);
427
428 p = PortP->HostPort % (u16) PORTS_PER_RTA;
429
430 /*
431 ** If second block of ports for 16 port RTA, add 8
432 ** to index 8-15.
433 */
434 if (PortP->SecondBlock)
435 p += PORTS_PER_RTA;
436
437 writeb(p, &PktCmdP->PhbNum);
438
439 /*
440 ** to make debuggery easier
441 */
442 writeb('W', &PacketP->data[2]);
443 writeb('F', &PacketP->data[3]);
444 writeb('L', &PacketP->data[4]);
445 writeb('U', &PacketP->data[5]);
446 writeb('S', &PacketP->data[6]);
447 writeb('H', &PacketP->data[7]);
448 writeb(' ', &PacketP->data[8]);
449 writeb('0' + PortP->WflushFlag, &PacketP->data[9]);
450 writeb(' ', &PacketP->data[10]);
451 writeb(' ', &PacketP->data[11]);
452 writeb('\0', &PacketP->data[12]);
453
454 /*
455 ** its two bytes long!
456 */
457 writeb(PKT_CMD_BIT | 2, &PacketP->len);
458
459 /*
460 ** queue it!
461 */
462 if (!(PortP->State & RIO_DELETED)) {
463 add_transmit(PortP);
464 /*
465 ** Count chars tx'd for port statistics reporting
466 */
467 if (PortP->statsGather)
468 PortP->txchars += 2;
469 }
470
471 if (--(PortP->WflushFlag) == 0) {
472 PortP->MagicFlags &= ~MAGIC_FLUSH;
473 }
474
475 rio_dprintk(RIO_DEBUG_INTR, "Wflush count now stands at %d\n", PortP->WflushFlag);
476 }
477 if (PortP->MagicFlags & MORE_OUTPUT_EYGOR) {
478 if (PortP->MagicFlags & MAGIC_FLUSH) {
479 PortP->MagicFlags |= MORE_OUTPUT_EYGOR;
480 } else {
481 if (!can_add_transmit(&PacketP, PortP)) {
482 rio_spin_unlock(&PortP->portSem);
483 continue;
484 }
485 rio_spin_unlock(&PortP->portSem);
486 RIOTxEnable((char *) PortP);
487 rio_spin_lock(&PortP->portSem);
488 PortP->MagicFlags &= ~MORE_OUTPUT_EYGOR;
489 }
490 }
491 }
492
493
494 /*
495 ** If we can't add anything to the transmit queue, then
496 ** we need do none of the remaining processing.
497 */
498 if (!can_add_transmit(&PacketP, PortP)) {
499 rio_spin_unlock(&PortP->portSem);
500 continue;
501 }
502
503 rio_spin_unlock(&PortP->portSem);
504 RIOTxEnable((char *) PortP);
505 }
506 }
507 }
508
509 /*
510 ** Routine for handling received data for tty drivers
511 */
512 static void RIOReceive(struct rio_info *p, struct Port *PortP)
513 {
514 struct tty_struct *TtyP;
515 unsigned short transCount;
516 struct PKT __iomem *PacketP;
517 register unsigned int DataCnt;
518 unsigned char __iomem *ptr;
519 unsigned char *buf;
520 int copied = 0;
521
522 static int intCount, RxIntCnt;
523
524 /*
525 ** The receive data process is to remove packets from the
526 ** PHB until there aren't any more or the current cblock
527 ** is full. When this occurs, there will be some left over
528 ** data in the packet, that we must do something with.
529 ** As we haven't unhooked the packet from the read list
530 ** yet, we can just leave the packet there, having first
531 ** made a note of how far we got. This means that we need
532 ** a pointer per port saying where we start taking the
533 ** data from - this will normally be zero, but when we
534 ** run out of space it will be set to the offset of the
535 ** next byte to copy from the packet data area. The packet
536 ** length field is decremented by the number of bytes that
537 ** we successfully removed from the packet. When this reaches
538 ** zero, we reset the offset pointer to be zero, and free
539 ** the packet from the front of the queue.
540 */
541
542 intCount++;
543
544 TtyP = PortP->gs.port.tty;
545 if (!TtyP) {
546 rio_dprintk(RIO_DEBUG_INTR, "RIOReceive: tty is null. \n");
547 return;
548 }
549
550 if (PortP->State & RIO_THROTTLE_RX) {
551 rio_dprintk(RIO_DEBUG_INTR, "RIOReceive: Throttled. Can't handle more input.\n");
552 return;
553 }
554
555 if (PortP->State & RIO_DELETED) {
556 while (can_remove_receive(&PacketP, PortP)) {
557 remove_receive(PortP);
558 put_free_end(PortP->HostP, PacketP);
559 }
560 } else {
561 /*
562 ** loop, just so long as:
563 ** i ) there's some data ( i.e. can_remove_receive )
564 ** ii ) we haven't been blocked
565 ** iii ) there's somewhere to put the data
566 ** iv ) we haven't outstayed our welcome
567 */
568 transCount = 1;
569 while (can_remove_receive(&PacketP, PortP)
570 && transCount) {
571 RxIntCnt++;
572
573 /*
574 ** check that it is not a command!
575 */
576 if (readb(&PacketP->len) & PKT_CMD_BIT) {
577 rio_dprintk(RIO_DEBUG_INTR, "RIO: unexpected command packet received on PHB\n");
578 /* rio_dprint(RIO_DEBUG_INTR, (" sysport = %d\n", p->RIOPortp->PortNum)); */
579 rio_dprintk(RIO_DEBUG_INTR, " dest_unit = %d\n", readb(&PacketP->dest_unit));
580 rio_dprintk(RIO_DEBUG_INTR, " dest_port = %d\n", readb(&PacketP->dest_port));
581 rio_dprintk(RIO_DEBUG_INTR, " src_unit = %d\n", readb(&PacketP->src_unit));
582 rio_dprintk(RIO_DEBUG_INTR, " src_port = %d\n", readb(&PacketP->src_port));
583 rio_dprintk(RIO_DEBUG_INTR, " len = %d\n", readb(&PacketP->len));
584 rio_dprintk(RIO_DEBUG_INTR, " control = %d\n", readb(&PacketP->control));
585 rio_dprintk(RIO_DEBUG_INTR, " csum = %d\n", readw(&PacketP->csum));
586 rio_dprintk(RIO_DEBUG_INTR, " data bytes: ");
587 for (DataCnt = 0; DataCnt < PKT_MAX_DATA_LEN; DataCnt++)
588 rio_dprintk(RIO_DEBUG_INTR, "%d\n", readb(&PacketP->data[DataCnt]));
589 remove_receive(PortP);
590 put_free_end(PortP->HostP, PacketP);
591 continue; /* with next packet */
592 }
593
594 /*
595 ** How many characters can we move 'upstream' ?
596 **
597 ** Determine the minimum of the amount of data
598 ** available and the amount of space in which to
599 ** put it.
600 **
601 ** 1. Get the packet length by masking 'len'
602 ** for only the length bits.
603 ** 2. Available space is [buffer size] - [space used]
604 **
605 ** Transfer count is the minimum of packet length
606 ** and available space.
607 */
608
609 transCount = tty_buffer_request_room(TtyP, readb(&PacketP->len) & PKT_LEN_MASK);
610 rio_dprintk(RIO_DEBUG_REC, "port %d: Copy %d bytes\n", PortP->PortNum, transCount);
611 /*
612 ** To use the following 'kkprintfs' for debugging - change the '#undef'
613 ** to '#define', (this is the only place ___DEBUG_IT___ occurs in the
614 ** driver).
615 */
616 ptr = (unsigned char __iomem *) PacketP->data + PortP->RxDataStart;
617
618 tty_prepare_flip_string(TtyP, &buf, transCount);
619 rio_memcpy_fromio(buf, ptr, transCount);
620 PortP->RxDataStart += transCount;
621 writeb(readb(&PacketP->len)-transCount, &PacketP->len);
622 copied += transCount;
623
624
625
626 if (readb(&PacketP->len) == 0) {
627 /*
628 ** If we have emptied the packet, then we can
629 ** free it, and reset the start pointer for
630 ** the next packet.
631 */
632 remove_receive(PortP);
633 put_free_end(PortP->HostP, PacketP);
634 PortP->RxDataStart = 0;
635 }
636 }
637 }
638 if (copied) {
639 rio_dprintk(RIO_DEBUG_REC, "port %d: pushing tty flip buffer: %d total bytes copied.\n", PortP->PortNum, copied);
640 tty_flip_buffer_push(TtyP);
641 }
642
643 return;
644 }
645
Linux RapidIO development tree