err.no Git - linux-2.6/blob - drivers/char/rio/riointr.c

   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/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
  83 static void RIOReceive(struct rio_info *, struct Port *);
  84
  85
  86 static 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 */
  99 void 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 */
 175 static int RupIntr;
 176 static int RxIntr;
 177 static int TxIntr;
 178
 179 void 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 */
 519 static 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