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