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 77static void RIOReceive(struct rio_info *, struct Port *); 78 79 80static 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 */ 93void 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*/ 169static int RupIntr; 170static int RxIntr; 171static int TxIntr; 172 173void 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*/ 512static 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