?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[POWERPC] Add thread_info_cache_init() weak hook
[linux-2.6/verdex.git] / drivers / char / rio / riointr.c
blob4734e26e1ccd8a694ba23e090e56b35fe890598c
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, OPEN, ((PortP->Cor2Copy & (COR2_RTSFLOW | COR2_CTSFLOW)) == (COR2_RTSFLOW | COR2_CTSFLOW)) ? 1 : 0, DONT_SLEEP) == RIO_FAIL) {
405 continue; /* with next port */
406 }
407 rio_spin_lock(&PortP->portSem);
408 PortP->MagicFlags &= ~MAGIC_REBOOT;
409 }
410
411 /*
412 ** As mentioned above, this is a tacky hack to cope
413 ** with WFLUSH
414 */
415 if (PortP->WflushFlag) {
416 rio_dprintk(RIO_DEBUG_INTR, "Want to WFLUSH mark this port\n");
417
418 if (PortP->InUse)
419 rio_dprintk(RIO_DEBUG_INTR, "FAILS - PORT IS IN USE\n");
420 }
421
422 while (PortP->WflushFlag && can_add_transmit(&PacketP, PortP) && (PortP->InUse == NOT_INUSE)) {
423 int p;
424 struct PktCmd __iomem *PktCmdP;
425
426 rio_dprintk(RIO_DEBUG_INTR, "Add WFLUSH marker to data queue\n");
427 /*
428 ** make it look just like a WFLUSH command
429 */
430 PktCmdP = (struct PktCmd __iomem *) &PacketP->data[0];
431
432 writeb(WFLUSH, &PktCmdP->Command);
433
434 p = PortP->HostPort % (u16) PORTS_PER_RTA;
435
436 /*
437 ** If second block of ports for 16 port RTA, add 8
438 ** to index 8-15.
439 */
440 if (PortP->SecondBlock)
441 p += PORTS_PER_RTA;
442
443 writeb(p, &PktCmdP->PhbNum);
444
445 /*
446 ** to make debuggery easier
447 */
448 writeb('W', &PacketP->data[2]);
449 writeb('F', &PacketP->data[3]);
450 writeb('L', &PacketP->data[4]);
451 writeb('U', &PacketP->data[5]);
452 writeb('S', &PacketP->data[6]);
453 writeb('H', &PacketP->data[7]);
454 writeb(' ', &PacketP->data[8]);
455 writeb('0' + PortP->WflushFlag, &PacketP->data[9]);
456 writeb(' ', &PacketP->data[10]);
457 writeb(' ', &PacketP->data[11]);
458 writeb('\0', &PacketP->data[12]);
459
460 /*
461 ** its two bytes long!
462 */
463 writeb(PKT_CMD_BIT | 2, &PacketP->len);
464
465 /*
466 ** queue it!
467 */
468 if (!(PortP->State & RIO_DELETED)) {
469 add_transmit(PortP);
470 /*
471 ** Count chars tx'd for port statistics reporting
472 */
473 if (PortP->statsGather)
474 PortP->txchars += 2;
475 }
476
477 if (--(PortP->WflushFlag) == 0) {
478 PortP->MagicFlags &= ~MAGIC_FLUSH;
479 }
480
481 rio_dprintk(RIO_DEBUG_INTR, "Wflush count now stands at %d\n", PortP->WflushFlag);
482 }
483 if (PortP->MagicFlags & MORE_OUTPUT_EYGOR) {
484 if (PortP->MagicFlags & MAGIC_FLUSH) {
485 PortP->MagicFlags |= MORE_OUTPUT_EYGOR;
486 } else {
487 if (!can_add_transmit(&PacketP, PortP)) {
488 rio_spin_unlock(&PortP->portSem);
489 continue;
490 }
491 rio_spin_unlock(&PortP->portSem);
492 RIOTxEnable((char *) PortP);
493 rio_spin_lock(&PortP->portSem);
494 PortP->MagicFlags &= ~MORE_OUTPUT_EYGOR;
495 }
496 }
497 }
498
499
500 /*
501 ** If we can't add anything to the transmit queue, then
502 ** we need do none of the remaining processing.
503 */
504 if (!can_add_transmit(&PacketP, PortP)) {
505 rio_spin_unlock(&PortP->portSem);
506 continue;
507 }
508
509 rio_spin_unlock(&PortP->portSem);
510 RIOTxEnable((char *) PortP);
511 }
512 }
513 }
514
515 /*
516 ** Routine for handling received data for tty drivers
517 */
518 static void RIOReceive(struct rio_info *p, struct Port *PortP)
519 {
520 struct tty_struct *TtyP;
521 unsigned short transCount;
522 struct PKT __iomem *PacketP;
523 register unsigned int DataCnt;
524 unsigned char __iomem *ptr;
525 unsigned char *buf;
526 int copied = 0;
527
528 static int intCount, RxIntCnt;
529
530 /*
531 ** The receive data process is to remove packets from the
532 ** PHB until there aren't any more or the current cblock
533 ** is full. When this occurs, there will be some left over
534 ** data in the packet, that we must do something with.
535 ** As we haven't unhooked the packet from the read list
536 ** yet, we can just leave the packet there, having first
537 ** made a note of how far we got. This means that we need
538 ** a pointer per port saying where we start taking the
539 ** data from - this will normally be zero, but when we
540 ** run out of space it will be set to the offset of the
541 ** next byte to copy from the packet data area. The packet
542 ** length field is decremented by the number of bytes that
543 ** we successfully removed from the packet. When this reaches
544 ** zero, we reset the offset pointer to be zero, and free
545 ** the packet from the front of the queue.
546 */
547
548 intCount++;
549
550 TtyP = PortP->gs.tty;
551 if (!TtyP) {
552 rio_dprintk(RIO_DEBUG_INTR, "RIOReceive: tty is null. \n");
553 return;
554 }
555
556 if (PortP->State & RIO_THROTTLE_RX) {
557 rio_dprintk(RIO_DEBUG_INTR, "RIOReceive: Throttled. Can't handle more input.\n");
558 return;
559 }
560
561 if (PortP->State & RIO_DELETED) {
562 while (can_remove_receive(&PacketP, PortP)) {
563 remove_receive(PortP);
564 put_free_end(PortP->HostP, PacketP);
565 }
566 } else {
567 /*
568 ** loop, just so long as:
569 ** i ) there's some data ( i.e. can_remove_receive )
570 ** ii ) we haven't been blocked
571 ** iii ) there's somewhere to put the data
572 ** iv ) we haven't outstayed our welcome
573 */
574 transCount = 1;
575 while (can_remove_receive(&PacketP, PortP)
576 && transCount) {
577 RxIntCnt++;
578
579 /*
580 ** check that it is not a command!
581 */
582 if (readb(&PacketP->len) & PKT_CMD_BIT) {
583 rio_dprintk(RIO_DEBUG_INTR, "RIO: unexpected command packet received on PHB\n");
584 /* rio_dprint(RIO_DEBUG_INTR, (" sysport = %d\n", p->RIOPortp->PortNum)); */
585 rio_dprintk(RIO_DEBUG_INTR, " dest_unit = %d\n", readb(&PacketP->dest_unit));
586 rio_dprintk(RIO_DEBUG_INTR, " dest_port = %d\n", readb(&PacketP->dest_port));
587 rio_dprintk(RIO_DEBUG_INTR, " src_unit = %d\n", readb(&PacketP->src_unit));
588 rio_dprintk(RIO_DEBUG_INTR, " src_port = %d\n", readb(&PacketP->src_port));
589 rio_dprintk(RIO_DEBUG_INTR, " len = %d\n", readb(&PacketP->len));
590 rio_dprintk(RIO_DEBUG_INTR, " control = %d\n", readb(&PacketP->control));
591 rio_dprintk(RIO_DEBUG_INTR, " csum = %d\n", readw(&PacketP->csum));
592 rio_dprintk(RIO_DEBUG_INTR, " data bytes: ");
593 for (DataCnt = 0; DataCnt < PKT_MAX_DATA_LEN; DataCnt++)
594 rio_dprintk(RIO_DEBUG_INTR, "%d\n", readb(&PacketP->data[DataCnt]));
595 remove_receive(PortP);
596 put_free_end(PortP->HostP, PacketP);
597 continue; /* with next packet */
598 }
599
600 /*
601 ** How many characters can we move 'upstream' ?
602 **
603 ** Determine the minimum of the amount of data
604 ** available and the amount of space in which to
605 ** put it.
606 **
607 ** 1. Get the packet length by masking 'len'
608 ** for only the length bits.
609 ** 2. Available space is [buffer size] - [space used]
610 **
611 ** Transfer count is the minimum of packet length
612 ** and available space.
613 */
614
615 transCount = tty_buffer_request_room(TtyP, readb(&PacketP->len) & PKT_LEN_MASK);
616 rio_dprintk(RIO_DEBUG_REC, "port %d: Copy %d bytes\n", PortP->PortNum, transCount);
617 /*
618 ** To use the following 'kkprintfs' for debugging - change the '#undef'
619 ** to '#define', (this is the only place ___DEBUG_IT___ occurs in the
620 ** driver).
621 */
622 ptr = (unsigned char __iomem *) PacketP->data + PortP->RxDataStart;
623
624 tty_prepare_flip_string(TtyP, &buf, transCount);
625 rio_memcpy_fromio(buf, ptr, transCount);
626 PortP->RxDataStart += transCount;
627 writeb(readb(&PacketP->len)-transCount, &PacketP->len);
628 copied += transCount;
629
630
631
632 if (readb(&PacketP->len) == 0) {
633 /*
634 ** If we have emptied the packet, then we can
635 ** free it, and reset the start pointer for
636 ** the next packet.
637 */
638 remove_receive(PortP);
639 put_free_end(PortP->HostP, PacketP);
640 PortP->RxDataStart = 0;
641 }
642 }
643 }
644 if (copied) {
645 rio_dprintk(RIO_DEBUG_REC, "port %d: pushing tty flip buffer: %d total bytes copied.\n", PortP->PortNum, copied);
646 tty_flip_buffer_push(TtyP);
647 }
648
649 return;
650 }
651
Verdex Pro support