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