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 : riotty.c 24** SID : 1.3 25** Last Modified : 11/6/98 10:33:47 26** Retrieved : 11/6/98 10:33:50 27** 28** ident @(#)riotty.c 1.3 29** 30** ----------------------------------------------------------------------------- 31*/ 32#ifdef SCCS_LABELS 33static char *_riotty_c_sccs_ = "@(#)riotty.c 1.3"; 34#endif 35 36 37#define __EXPLICIT_DEF_H__ 38 39#include <linux/module.h> 40#include <linux/slab.h> 41#include <linux/errno.h> 42#include <linux/tty.h> 43#include <linux/string.h> 44#include <asm/io.h> 45#include <asm/system.h> 46#include <asm/string.h> 47#include <asm/semaphore.h> 48#include <asm/uaccess.h> 49 50#include <linux/termios.h> 51 52#include <linux/serial.h> 53 54#include <linux/generic_serial.h> 55 56 57#include "linux_compat.h" 58#include "rio_linux.h" 59#include "pkt.h" 60#include "daemon.h" 61#include "rio.h" 62#include "riospace.h" 63#include "cmdpkt.h" 64#include "map.h" 65#include "rup.h" 66#include "port.h" 67#include "riodrvr.h" 68#include "rioinfo.h" 69#include "func.h" 70#include "errors.h" 71#include "pci.h" 72 73#include "parmmap.h" 74#include "unixrup.h" 75#include "board.h" 76#include "host.h" 77#include "phb.h" 78#include "link.h" 79#include "cmdblk.h" 80#include "route.h" 81#include "cirrus.h" 82#include "rioioctl.h" 83#include "param.h" 84 85static void RIOClearUp(struct Port *PortP); 86 87/* Below belongs in func.h */ 88int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg); 89 90 91extern struct rio_info *p; 92 93 94int riotopen(struct tty_struct *tty, struct file *filp) 95{ 96 unsigned int SysPort; 97 int repeat_this = 250; 98 struct Port *PortP; /* pointer to the port structure */ 99 unsigned long flags; 100 int retval = 0; 101 102 func_enter(); 103 104 /* Make sure driver_data is NULL in case the rio isn't booted jet. Else gs_close 105 is going to oops. 106 */ 107 tty->driver_data = NULL; 108 109 SysPort = rio_minor(tty); 110 111 if (p->RIOFailed) { 112 rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n"); 113 func_exit(); 114 return -ENXIO; 115 } 116 117 rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (mapped:%d)\n", SysPort, p->RIOPortp[SysPort]->Mapped); 118 119 /* 120 ** Validate that we have received a legitimate request. 121 ** Currently, just check that we are opening a port on 122 ** a host card that actually exists, and that the port 123 ** has been mapped onto a host. 124 */ 125 if (SysPort >= RIO_PORTS) { /* out of range ? */ 126 rio_dprintk(RIO_DEBUG_TTY, "Illegal port number %d\n", SysPort); 127 func_exit(); 128 return -ENXIO; 129 } 130 131 /* 132 ** Grab pointer to the port stucture 133 */ 134 PortP = p->RIOPortp[SysPort]; /* Get control struc */ 135 rio_dprintk(RIO_DEBUG_TTY, "PortP: %p\n", PortP); 136 if (!PortP->Mapped) { /* we aren't mapped yet! */ 137 /* 138 ** The system doesn't know which RTA this port 139 ** corresponds to. 140 */ 141 rio_dprintk(RIO_DEBUG_TTY, "port not mapped into system\n"); 142 func_exit(); 143 return -ENXIO; 144 } 145 146 tty->driver_data = PortP; 147 148 PortP->gs.tty = tty; 149 PortP->gs.count++; 150 151 rio_dprintk(RIO_DEBUG_TTY, "%d bytes in tx buffer\n", PortP->gs.xmit_cnt); 152 153 retval = gs_init_port(&PortP->gs); 154 if (retval) { 155 PortP->gs.count--; 156 return -ENXIO; 157 } 158 /* 159 ** If the host hasn't been booted yet, then 160 ** fail 161 */ 162 if ((PortP->HostP->Flags & RUN_STATE) != RC_RUNNING) { 163 rio_dprintk(RIO_DEBUG_TTY, "Host not running\n"); 164 func_exit(); 165 return -ENXIO; 166 } 167 168 /* 169 ** If the RTA has not booted yet and the user has choosen to block 170 ** until the RTA is present then we must spin here waiting for 171 ** the RTA to boot. 172 */ 173 /* I find the above code a bit hairy. I find the below code 174 easier to read and shorter. Now, if it works too that would 175 be great... -- REW 176 */ 177 rio_dprintk(RIO_DEBUG_TTY, "Checking if RTA has booted... \n"); 178 while (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) { 179 if (!PortP->WaitUntilBooted) { 180 rio_dprintk(RIO_DEBUG_TTY, "RTA never booted\n"); 181 func_exit(); 182 return -ENXIO; 183 } 184 185 /* Under Linux you'd normally use a wait instead of this 186 busy-waiting. I'll stick with the old implementation for 187 now. --REW 188 */ 189 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) { 190 rio_dprintk(RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n"); 191 func_exit(); 192 return -EINTR; 193 } 194 if (repeat_this-- <= 0) { 195 rio_dprintk(RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n"); 196 func_exit(); 197 return -EIO; 198 } 199 } 200 rio_dprintk(RIO_DEBUG_TTY, "RTA has been booted\n"); 201 rio_spin_lock_irqsave(&PortP->portSem, flags); 202 if (p->RIOHalted) { 203 goto bombout; 204 } 205 206 /* 207 ** If the port is in the final throws of being closed, 208 ** we should wait here (politely), waiting 209 ** for it to finish, so that it doesn't close us! 210 */ 211 while ((PortP->State & RIO_CLOSING) && !p->RIOHalted) { 212 rio_dprintk(RIO_DEBUG_TTY, "Waiting for RIO_CLOSING to go away\n"); 213 if (repeat_this-- <= 0) { 214 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n"); 215 RIOPreemptiveCmd(p, PortP, FCLOSE); 216 retval = -EINTR; 217 goto bombout; 218 } 219 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 220 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) { 221 rio_spin_lock_irqsave(&PortP->portSem, flags); 222 retval = -EINTR; 223 goto bombout; 224 } 225 rio_spin_lock_irqsave(&PortP->portSem, flags); 226 } 227 228 if (!PortP->Mapped) { 229 rio_dprintk(RIO_DEBUG_TTY, "Port unmapped while closing!\n"); 230 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 231 retval = -ENXIO; 232 func_exit(); 233 return retval; 234 } 235 236 if (p->RIOHalted) { 237 goto bombout; 238 } 239 240/* 241** 15.10.1998 ARG - ESIL 0761 part fix 242** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure, 243** we need to make sure that the flags are clear when the port is opened. 244*/ 245 /* Uh? Suppose I turn these on and then another process opens 246 the port again? The flags get cleared! Not good. -- REW */ 247 if (!(PortP->State & (RIO_LOPEN | RIO_MOPEN))) { 248 PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW); 249 } 250 251 if (!(PortP->firstOpen)) { /* First time ? */ 252 rio_dprintk(RIO_DEBUG_TTY, "First open for this port\n"); 253 254 255 PortP->firstOpen++; 256 PortP->CookMode = 0; 257 PortP->InUse = NOT_INUSE; 258 259 /* PortP->gs.xmit_cnt = 0; */ 260 261 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 262 263 /* Someone explain to me why this delay/config is 264 here. If I read the docs correctly the "open" 265 command piggybacks the parameters immediately. 266 -- REW */ 267 RIOParam(PortP, OPEN, 1, OK_TO_SLEEP); /* Open the port */ 268 rio_spin_lock_irqsave(&PortP->portSem, flags); 269 270 /* 271 ** wait for the port to be not closed. 272 */ 273 while (!(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted) { 274 rio_dprintk(RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n", PortP->PortState); 275 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 276 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) { 277 rio_dprintk(RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n"); 278 RIOPreemptiveCmd(p, PortP, FCLOSE); 279 func_exit(); 280 return -EINTR; 281 } 282 rio_spin_lock_irqsave(&PortP->portSem, flags); 283 } 284 285 if (p->RIOHalted) { 286 retval = -EIO; 287 bombout: 288 /* RIOClearUp( PortP ); */ 289 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 290 return retval; 291 } 292 rio_dprintk(RIO_DEBUG_TTY, "PORT_ISOPEN found\n"); 293 } 294 rio_dprintk(RIO_DEBUG_TTY, "Modem - test for carrier\n"); 295 /* 296 ** ACTION 297 ** insert test for carrier here. -- ??? 298 ** I already see that test here. What's the deal? -- REW 299 */ 300 if ((PortP->gs.tty->termios->c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD)) { 301 rio_dprintk(RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort); 302 /* 303 tp->tm.c_state |= CARR_ON; 304 wakeup((caddr_t) &tp->tm.c_canq); 305 */ 306 PortP->State |= RIO_CARR_ON; 307 wake_up_interruptible(&PortP->gs.open_wait); 308 } else { /* no carrier - wait for DCD */ 309 /* 310 while (!(PortP->gs.tty->termios->c_state & CARR_ON) && 311 !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted ) 312 */ 313 while (!(PortP->State & RIO_CARR_ON) && !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted) { 314 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n", SysPort); 315 /* 316 PortP->gs.tty->termios->c_state |= WOPEN; 317 */ 318 PortP->State |= RIO_WOPEN; 319 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 320 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) { 321 /* 322 ** ACTION: verify that this is a good thing 323 ** to do here. -- ??? 324 ** I think it's OK. -- REW 325 */ 326 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n", SysPort); 327 RIOPreemptiveCmd(p, PortP, FCLOSE); 328 /* 329 tp->tm.c_state &= ~WOPEN; 330 */ 331 PortP->State &= ~RIO_WOPEN; 332 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 333 func_exit(); 334 return -EINTR; 335 } 336 } 337 PortP->State &= ~RIO_WOPEN; 338 } 339 if (p->RIOHalted) 340 goto bombout; 341 rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n"); 342 PortP->State |= RIO_MOPEN; 343 344 if (p->RIOHalted) 345 goto bombout; 346 347 rio_dprintk(RIO_DEBUG_TTY, "high level open done\n"); 348 349 /* 350 ** Count opens for port statistics reporting 351 */ 352 if (PortP->statsGather) 353 PortP->opens++; 354 355 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 356 rio_dprintk(RIO_DEBUG_TTY, "Returning from open\n"); 357 func_exit(); 358 return 0; 359} 360 361/* 362** RIOClose the port. 363** The operating system thinks that this is last close for the device. 364** As there are two interfaces to the port (Modem and tty), we need to 365** check that both are closed before we close the device. 366*/ 367int riotclose(void *ptr) 368{ 369 struct Port *PortP = ptr; /* pointer to the port structure */ 370 int deleted = 0; 371 int try = -1; /* Disable the timeouts by setting them to -1 */ 372 int repeat_this = -1; /* Congrats to those having 15 years of 373 uptime! (You get to break the driver.) */ 374 unsigned long end_time; 375 struct tty_struct *tty; 376 unsigned long flags; 377 int rv = 0; 378 379 rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum); 380 381 /* PortP = p->RIOPortp[SysPort]; */ 382 rio_dprintk(RIO_DEBUG_TTY, "Port is at address %p\n", PortP); 383 /* tp = PortP->TtyP; *//* Get tty */ 384 tty = PortP->gs.tty; 385 rio_dprintk(RIO_DEBUG_TTY, "TTY is at address %p\n", tty); 386 387 if (PortP->gs.closing_wait) 388 end_time = jiffies + PortP->gs.closing_wait; 389 else 390 end_time = jiffies + MAX_SCHEDULE_TIMEOUT; 391 392 rio_spin_lock_irqsave(&PortP->portSem, flags); 393 394 /* 395 ** Setting this flag will make any process trying to open 396 ** this port block until we are complete closing it. 397 */ 398 PortP->State |= RIO_CLOSING; 399 400 if ((PortP->State & RIO_DELETED)) { 401 rio_dprintk(RIO_DEBUG_TTY, "Close on deleted RTA\n"); 402 deleted = 1; 403 } 404 405 if (p->RIOHalted) { 406 RIOClearUp(PortP); 407 rv = -EIO; 408 goto close_end; 409 } 410 411 rio_dprintk(RIO_DEBUG_TTY, "Clear bits\n"); 412 /* 413 ** clear the open bits for this device 414 */ 415 PortP->State &= ~RIO_MOPEN; 416 PortP->State &= ~RIO_CARR_ON; 417 PortP->ModemState &= ~MSVR1_CD; 418 /* 419 ** If the device was open as both a Modem and a tty line 420 ** then we need to wimp out here, as the port has not really 421 ** been finally closed (gee, whizz!) The test here uses the 422 ** bit for the OTHER mode of operation, to see if THAT is 423 ** still active! 424 */ 425 if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) { 426 /* 427 ** The port is still open for the other task - 428 ** return, pretending that we are still active. 429 */ 430 rio_dprintk(RIO_DEBUG_TTY, "Channel %d still open !\n", PortP->PortNum); 431 PortP->State &= ~RIO_CLOSING; 432 if (PortP->firstOpen) 433 PortP->firstOpen--; 434 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 435 return -EIO; 436 } 437 438 rio_dprintk(RIO_DEBUG_TTY, "Closing down - everything must go!\n"); 439 440 PortP->State &= ~RIO_DYNOROD; 441 442 /* 443 ** This is where we wait for the port 444 ** to drain down before closing. Bye-bye.... 445 ** (We never meant to do this) 446 */ 447 rio_dprintk(RIO_DEBUG_TTY, "Timeout 1 starts\n"); 448 449 if (!deleted) 450 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted && (PortP->TxBufferIn != PortP->TxBufferOut)) { 451 if (repeat_this-- <= 0) { 452 rv = -EINTR; 453 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n"); 454 RIOPreemptiveCmd(p, PortP, FCLOSE); 455 goto close_end; 456 } 457 rio_dprintk(RIO_DEBUG_TTY, "Calling timeout to flush in closing\n"); 458 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 459 if (RIODelay_ni(PortP, HUNDRED_MS * 10) == RIO_FAIL) { 460 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n"); 461 rv = -EINTR; 462 rio_spin_lock_irqsave(&PortP->portSem, flags); 463 goto close_end; 464 } 465 rio_spin_lock_irqsave(&PortP->portSem, flags); 466 } 467 468 PortP->TxBufferIn = PortP->TxBufferOut = 0; 469 repeat_this = 0xff; 470 471 PortP->InUse = 0; 472 if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) { 473 /* 474 ** The port has been re-opened for the other task - 475 ** return, pretending that we are still active. 476 */ 477 rio_dprintk(RIO_DEBUG_TTY, "Channel %d re-open!\n", PortP->PortNum); 478 PortP->State &= ~RIO_CLOSING; 479 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 480 if (PortP->firstOpen) 481 PortP->firstOpen--; 482 return -EIO; 483 } 484 485 if (p->RIOHalted) { 486 RIOClearUp(PortP); 487 goto close_end; 488 } 489 490 /* Can't call RIOShortCommand with the port locked. */ 491 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 492 493 if (RIOShortCommand(p, PortP, CLOSE, 1, 0) == RIO_FAIL) { 494 RIOPreemptiveCmd(p, PortP, FCLOSE); 495 goto close_end; 496 } 497 498 if (!deleted) 499 while (try && (PortP->PortState & PORT_ISOPEN)) { 500 try--; 501 if (time_after(jiffies, end_time)) { 502 rio_dprintk(RIO_DEBUG_TTY, "Run out of tries - force the bugger shut!\n"); 503 RIOPreemptiveCmd(p, PortP, FCLOSE); 504 break; 505 } 506 rio_dprintk(RIO_DEBUG_TTY, "Close: PortState:ISOPEN is %d\n", PortP->PortState & PORT_ISOPEN); 507 508 if (p->RIOHalted) { 509 RIOClearUp(PortP); 510 goto close_end; 511 } 512 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) { 513 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n"); 514 RIOPreemptiveCmd(p, PortP, FCLOSE); 515 break; 516 } 517 } 518 rio_spin_lock_irqsave(&PortP->portSem, flags); 519 rio_dprintk(RIO_DEBUG_TTY, "Close: try was %d on completion\n", try); 520 521 /* RIOPreemptiveCmd(p, PortP, FCLOSE); */ 522 523/* 524** 15.10.1998 ARG - ESIL 0761 part fix 525** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,** we need to make sure that the flags are clear when the port is opened. 526*/ 527 PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW); 528 529 /* 530 ** Count opens for port statistics reporting 531 */ 532 if (PortP->statsGather) 533 PortP->closes++; 534 535close_end: 536 PortP->State &= ~(RIO_CLOSING | RIO_DELETED); 537 if (PortP->firstOpen) 538 PortP->firstOpen--; 539 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 540 rio_dprintk(RIO_DEBUG_TTY, "Return from close\n"); 541 return rv; 542} 543 544 545 546static void RIOClearUp(struct Port *PortP) 547{ 548 rio_dprintk(RIO_DEBUG_TTY, "RIOHalted set\n"); 549 PortP->Config = 0; /* Direct semaphore */ 550 PortP->PortState = 0; 551 PortP->firstOpen = 0; 552 PortP->FlushCmdBodge = 0; 553 PortP->ModemState = PortP->CookMode = 0; 554 PortP->Mapped = 0; 555 PortP->WflushFlag = 0; 556 PortP->MagicFlags = 0; 557 PortP->RxDataStart = 0; 558 PortP->TxBufferIn = 0; 559 PortP->TxBufferOut = 0; 560} 561 562/* 563** Put a command onto a port. 564** The PortPointer, command, length and arg are passed. 565** The len is the length *inclusive* of the command byte, 566** and so for a command that takes no data, len==1. 567** The arg is a single byte, and is only used if len==2. 568** Other values of len aren't allowed, and will cause 569** a panic. 570*/ 571int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg) 572{ 573 struct PKT __iomem *PacketP; 574 int retries = 20; /* at 10 per second -> 2 seconds */ 575 unsigned long flags; 576 577 rio_dprintk(RIO_DEBUG_TTY, "entering shortcommand.\n"); 578 579 if (PortP->State & RIO_DELETED) { 580 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n"); 581 return RIO_FAIL; 582 } 583 rio_spin_lock_irqsave(&PortP->portSem, flags); 584 585 /* 586 ** If the port is in use for pre-emptive command, then wait for it to 587 ** be free again. 588 */ 589 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted) { 590 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not in use (%d)\n", retries); 591 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 592 if (retries-- <= 0) { 593 return RIO_FAIL; 594 } 595 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) { 596 return RIO_FAIL; 597 } 598 rio_spin_lock_irqsave(&PortP->portSem, flags); 599 } 600 if (PortP->State & RIO_DELETED) { 601 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n"); 602 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 603 return RIO_FAIL; 604 } 605 606 while (!can_add_transmit(&PacketP, PortP) && !p->RIOHalted) { 607 rio_dprintk(RIO_DEBUG_TTY, "Waiting to add short command to queue (%d)\n", retries); 608 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 609 if (retries-- <= 0) { 610 rio_dprintk(RIO_DEBUG_TTY, "out of tries. Failing\n"); 611 return RIO_FAIL; 612 } 613 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) { 614 return RIO_FAIL; 615 } 616 rio_spin_lock_irqsave(&PortP->portSem, flags); 617 } 618 619 if (p->RIOHalted) { 620 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 621 return RIO_FAIL; 622 } 623 624 /* 625 ** set the command byte and the argument byte 626 */ 627 writeb(command, &PacketP->data[0]); 628 629 if (len == 2) 630 writeb(arg, &PacketP->data[1]); 631 632 /* 633 ** set the length of the packet and set the command bit. 634 */ 635 writeb(PKT_CMD_BIT | len, &PacketP->len); 636 637 add_transmit(PortP); 638 /* 639 ** Count characters transmitted for port statistics reporting 640 */ 641 if (PortP->statsGather) 642 PortP->txchars += len; 643 644 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 645 return p->RIOHalted ? RIO_FAIL : ~RIO_FAIL; 646} 647