LXR linux-old/drivers/net/wan/8253x/8253xsyn.c

   1/* -*- linux-c -*- */
   2/* $Id: 8253xsyn.c,v 1.17 2002/02/10 22:17:25 martillo Exp $
   3 * 8253xsyn.c: SYNC TTY Driver for the SIEMENS SAB8253X DUSCC.
   4 *
   5 * Implementation, modifications and extensions
   6 * Copyright (C) 2001 By Joachim Martillo, Telford Tools, Inc.
   7 *
   8 * This program is free software; you can redistribute it and/or
   9 * modify it under the terms of the GNU General Public License
  10 * as published by the Free Software Foundation; either version
  11 * 2 of the License, or (at your option) any later version.
  12 */
  13
  14/* Standard in kernel modules */
  15#define DEFINE_VARIABLE
  16#include <linux/module.h>   /* Specifically, a module */
  17#include <asm/io.h>
  18#include <linux/timer.h>
  19#include <linux/interrupt.h>
  20#include <linux/tty.h>
  21#include <linux/tty_flip.h>
  22#include <linux/mm.h>
  23#include <linux/version.h>
  24#include <asm/uaccess.h>
  25#include "8253xctl.h"
  26#include "8253x.h"
  27#include <linux/pci.h>
  28#include <linux/fs.h>
  29
  30#ifdef MODULE
  31#undef XCONFIG_SERIAL_CONSOLE
  32#endif
  33
  34
  35static void sab8253x_flush_to_ldiscS(void *private_) /* need a separate version for sync
  36                                                 there are no flags associated with
  37                                                 received sync TTY data*/
  38{
  39        struct tty_struct *tty = (struct tty_struct *) private_;
  40        unsigned char   *cp;
  41        int             count;
  42        struct sab_port *port;
  43        struct sk_buff *skb;  
  44        
  45        if(tty)
  46        {
  47                port = (struct sab_port *)tty->driver_data;
  48        }
  49        else
  50        {
  51                return;
  52        }
  53        if(port == NULL)
  54        {
  55                return;
  56        }
  57        
  58        if (test_bit(TTY_DONT_FLIP, &tty->flags)) 
  59        {
  60                queue_task(&tty->flip.tqueue, &tq_timer);
  61                return;
  62        }
  63        /* note that a hangup may have occurred -- perhaps should check for that */
  64        port->DoingInterrupt = 1;
  65        while(port->sab8253xc_rcvbuflist && (skb_queue_len(port->sab8253xc_rcvbuflist) > 0))
  66        {
  67                skb = skb_dequeue(port->sab8253xc_rcvbuflist);
  68                count = skb->data_len;
  69                cp = skb->data;
  70                (*tty->ldisc.receive_buf)(tty, cp, 0, count);
  71                dev_kfree_skb_any(skb);
  72        }
  73        port->DoingInterrupt = 0;
  74}
  75
  76void sab8253x_flush_charsS(struct tty_struct *tty)
  77{
  78        struct sab_port *port = (struct sab_port *)tty->driver_data;
  79        
  80        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_flush_chars"))
  81        {
  82                return;
  83        }
  84        
  85        if ((Sab8253xCountTransmit(port) <= 0) || tty->stopped || tty->hw_stopped)
  86        {                               /* can't flush */
  87                return;
  88        }
  89        
  90        sab8253x_start_txS(port);
  91}
  92
  93/*
  94 * ------------------------------------------------------------
  95 * sab8253x_stopS() and sab8253x_startS()
  96 *
  97 * This routines are called before setting or resetting tty->stopped.
  98 * They enable or disable transmitter interrupts, as necessary.
  99 * ------------------------------------------------------------
 100 */
 101
 102void sab8253x_stopS(struct tty_struct *tty)
 103{
 104        struct sab_port *port = (struct sab_port *)tty->driver_data;
 105        /* can't do anything here */
 106        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_stop"))
 107        {
 108                return;
 109        }
 110        /*  interrupt handles it all*/
 111        /* turning off XPR is not an option in sync mode */
 112}
 113
 114void sab8253x_startS(struct tty_struct *tty)
 115{
 116        struct sab_port *port = (struct sab_port *)tty->driver_data;
 117        
 118        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_start"))
 119        {
 120                return;
 121        }
 122        sab8253x_start_txS(port);
 123}
 124
 125
 126static void sab8253x_receive_charsS(struct sab_port *port,
 127                             union sab8253x_irq_status *stat)
 128{
 129        struct tty_struct *tty = port->tty;
 130        unsigned char buf[32];
 131        int free_fifo = 0;
 132        int reset_fifo = 0;
 133        int msg_done = 0;
 134        int msg_bad = 0;
 135        int count = 0;
 136        int total_size = 0;
 137        int rstatus = 0;
 138        struct sk_buff *skb;
 139        
 140        /* Read number of BYTES (Character + Status) available. */
 141        
 142        if((stat->images[ISR1_IDX] & SAB82532_ISR1_RDO) || (stat->images[ISR0_IDX] & SAB82532_ISR0_RFO) )
 143        {
 144                ++msg_bad;
 145                ++free_fifo;
 146                ++reset_fifo;
 147        }
 148        else
 149        {
 150                if (stat->images[ISR0_IDX] & SAB82532_ISR0_RPF) 
 151                {
 152                        count = port->recv_fifo_size;
 153                        ++free_fifo;
 154                }
 155                
 156                if (stat->images[ISR0_IDX] & SAB82532_ISR0_RME) 
 157                {
 158                        count = READB(port, rbcl);
 159                        count &= (port->recv_fifo_size - 1);
 160                        ++msg_done;
 161                        ++free_fifo;
 162                        
 163                        total_size = READB(port, rbch);
 164                        if(total_size & SAB82532_RBCH_OV) /* need to revisit for 4096 byte frames */
 165                        {
 166                                msg_bad++;
 167                        }
 168                        
 169                        rstatus = READB(port, rsta);
 170                        if((rstatus & SAB82532_RSTA_VFR) == 0)
 171                        {
 172                                msg_bad++;
 173                        }
 174                        if(rstatus & SAB82532_RSTA_RDO)
 175                        {
 176                                msg_bad++;
 177                        }
 178                        if((rstatus & SAB82532_RSTA_CRC) == 0)
 179                        {
 180                                msg_bad++;
 181                        }
 182                        if(rstatus & SAB82532_RSTA_RAB)
 183                        {
 184                                msg_bad++;
 185                        }
 186                }
 187        }
 188        
 189        /* Read the FIFO. */
 190        
 191        (*port->readfifo)(port, buf, count);
 192        
 193        
 194        /* Issue Receive Message Complete command. */
 195        
 196        if (free_fifo) 
 197        {
 198                sab8253x_cec_wait(port);
 199                WRITEB(port, cmdr, SAB82532_CMDR_RMC);
 200        }
 201        
 202        if(reset_fifo)
 203        {
 204                sab8253x_cec_wait(port);
 205                WRITEB(port, cmdr, SAB82532_CMDR_RHR);
 206        }
 207        
 208        if(msg_bad)
 209        {
 210                port->msgbufindex = 0;
 211                return;
 212        }
 213        
 214        memcpy(&port->msgbuf[port->msgbufindex], buf, count);
 215        port->msgbufindex += count;
 216        
 217#ifdef CONSOLE_SUPPORT
 218        if (port->is_console)
 219        {
 220                wake_up(&keypress_wait);
 221        }
 222#endif
 223        
 224        if(msg_done)
 225        {
 226                
 227                if(port->msgbufindex <= 3) /* min is 1 char + 2 CRC + status byte */
 228                {
 229                        port->msgbufindex = 0;
 230                        return;
 231                }
 232                
 233                total_size = port->msgbufindex - 3; /* strip off the crc16 and the status byte */
 234                port->msgbufindex = 0;
 235                
 236                /* ignore the receive buffer waiting -- we know the correct size here */
 237                
 238                if (!tty)
 239                {
 240                        return;
 241                }
 242                if(skb = dev_alloc_skb(total_size), skb)
 243                {
 244                        memcpy(skb->data, &port->msgbuf[0], total_size);
 245                        skb->tail = (skb->data + total_size);
 246                        skb->data_len = total_size;
 247                        skb->len = total_size;
 248                        skb_queue_tail(port->sab8253xc_rcvbuflist, skb);
 249                }
 250                queue_task(&tty->flip.tqueue, &tq_timer); /* clear out flip buffer as fast as possible
 251                                                           * maybe should not be done unconditionally hear
 252                                                           * but should be within the above consequence
 253                                                           * clause */
 254        }
 255}
 256
 257
 258static void sab8253x_check_statusS(struct sab_port *port,
 259                            union sab8253x_irq_status *stat)
 260{
 261        struct tty_struct *tty = port->tty;
 262        int modem_change = 0;
 263        mctlsig_t         *sig;
 264        
 265        if (!tty)
 266        {
 267                return;
 268        }
 269        
 270        /* check_modem:*/
 271        /* Checking DCD */
 272        sig = &port->dcd;
 273        if (stat->images[sig->irq] & sig->irqmask) 
 274        {
 275                sig->val = ISON(port,dcd);
 276                port->icount.dcd++;
 277                modem_change++;
 278        }
 279        /* Checking CTS */
 280        sig = &port->cts;
 281        if (stat->images[sig->irq] & sig->irqmask) 
 282        {
 283                sig->val = ISON(port,cts);
 284                port->icount.cts++;
 285                modem_change++;
 286        }
 287        /* Checking DSR */
 288        sig = &port->dsr;
 289        if (stat->images[sig->irq] & sig->irqmask) 
 290        {
 291                sig->val = ISON(port,dsr);
 292                port->icount.dsr++;
 293                modem_change++;
 294        }
 295        if (modem_change)
 296        {
 297                wake_up_interruptible(&port->delta_msr_wait);
 298        }
 299        
 300        sig = &port->dcd;
 301        if ((port->flags & FLAG8253X_CHECK_CD) &&
 302            (stat->images[sig->irq] & sig->irqmask)) 
 303        {
 304                
 305                if (sig->val)
 306                {
 307                        wake_up_interruptible(&port->open_wait);
 308                }
 309                else if (!((port->flags & FLAG8253X_CALLOUT_ACTIVE) &&
 310                           (port->flags & FLAG8253X_CALLOUT_NOHUP))) 
 311                {
 312#if 0                           /* requires more investigation */
 313                        MOD_INC_USE_COUNT;
 314                        if (schedule_task(&port->tqueue_hangup) == 0)
 315                        {
 316                                MOD_DEC_USE_COUNT;
 317                        }
 318#endif
 319                }
 320        }
 321        
 322        sig = &port->cts;
 323        if (port->flags & FLAG8253X_CTS_FLOW) 
 324        {                               /* not setting this yet */
 325                if (port->tty->hw_stopped) 
 326                {
 327                        if (sig->val) 
 328                        {
 329                                port->tty->hw_stopped = 0;
 330                                sab8253x_sched_event(port, SAB8253X_EVENT_WRITE_WAKEUP);
 331                                sab8253x_start_txS(port);
 332                        }
 333                } 
 334                
 335                else 
 336                {
 337                        if(!(getccr2configS(port) & SAB82532_CCR2_TOE))
 338                        {
 339                                if (!(sig->val)) 
 340                                {
 341                                        port->tty->hw_stopped = 1;
 342                                }
 343                        }
 344                }
 345        }
 346}
 347
 348/*
 349 * This routine is called to set the UART divisor registers to match
 350 * the specified baud rate for a serial port.
 351 */
 352static void sab8253x_change_speedS(struct sab_port *port)
 353{
 354        unsigned long   flags,baud;
 355        tcflag_t        cflag;
 356        u8              ccr2=0,ccr4=0,ebrg=0;
 357        int             i, bits;
 358#ifdef DEBUGGING
 359        printk("Change speed!  ");
 360#endif
 361        if (!port->tty || !port->tty->termios) 
 362        {
 363#ifdef DEBUGGING
 364                printk("NOT!\n");
 365#endif
 366                return;
 367        }
 368        
 369#ifdef DEBUGGING
 370        printk(" for real.\n");
 371#endif
 372        
 373        cflag = port->tty->termios->c_cflag;
 374        
 375        /* Byte size and parity */
 376        switch (cflag & CSIZE) 
 377        {
 378        case CS5: 
 379                bits = 7; 
 380                break;
 381        case CS6: 
 382                bits = 8; 
 383                break;
 384        case CS7: 
 385                bits = 9; 
 386                break;
 387        default:
 388        case CS8: 
 389                bits = 10; 
 390                break;
 391        }
 392        
 393        if (cflag & CSTOPB) 
 394        {
 395                bits++;
 396        }
 397        
 398        if (cflag & PARENB) 
 399        {
 400                bits++;
 401        }
 402        
 403        /* Determine EBRG values based on the "encoded"baud rate */
 404        i = cflag & CBAUD;
 405        switch(i)
 406        {
 407        case B0:
 408                baud=0;
 409                break;
 410        case  B50:
 411                baud=100;
 412                break;
 413        case  B75:
 414                baud=150;
 415                break;
 416        case  B110:
 417                baud=220;
 418                break;
 419        case  B134:
 420                baud=269;
 421                break;
 422        case  B150:
 423                baud=300;
 424                break;
 425        case  B200:
 426                baud=400;
 427                break;
 428        case B300:
 429                baud=600;
 430                break;
 431        case B600:
 432                baud=1200;
 433                break;
 434        case B1200:
 435                baud=2400;
 436                break;
 437        case B1800:
 438                baud=3600;
 439                break;
 440        case B2400:
 441                baud=4800;
 442                break;
 443        case B4800:
 444                baud=9600;
 445                break;
 446        case B9600:
 447                baud=19200;
 448                break;
 449        case B19200:
 450                baud=38400;
 451                break;
 452        case  B38400:
 453                if(port->custspeed)
 454                {
 455                        baud=port->custspeed<<1;
 456                }
 457                else
 458                {
 459                        baud=76800;
 460                }
 461                break;
 462        case B57600:
 463                baud=115200;
 464                break;
 465#ifdef SKIPTHIS
 466        case B76800:
 467                baud=153600;
 468                break;
 469        case B153600:
 470                baud=307200;
 471                break;
 472#endif
 473        case B230400:
 474                baud=460800;
 475                break;
 476        case  B460800:
 477                baud=921600;
 478                break;
 479        case B115200:
 480        default:
 481                baud=230400;
 482                break;
 483        }
 484        
 485        if(!sab8253x_baud(port,baud,&ebrg,&ccr2,&ccr4,&(port->baud))) 
 486        {
 487                printk("Aurora Warning. baudrate %ld could not be set! Using 115200",baud);
 488                baud=230400;
 489                sab8253x_baud(port,baud,&ebrg,&ccr2,&ccr4,&(port->baud));
 490        }
 491        
 492        if (port->baud)
 493                port->timeout = (port->xmit_fifo_size * HZ * bits) / port->baud;
 494        else
 495                port->timeout = 0;
 496        port->timeout += HZ / 50;               /* Add .02 seconds of slop */
 497        
 498        /* CTS flow control flags */
 499        if (cflag & CRTSCTS)
 500                port->flags |= FLAG8253X_CTS_FLOW;
 501        else
 502                port->flags &= ~(FLAG8253X_CTS_FLOW);
 503        
 504        if (cflag & CLOCAL)
 505                port->flags &= ~(FLAG8253X_CHECK_CD);
 506        else
 507                port->flags |= FLAG8253X_CHECK_CD;
 508        if (port->tty)
 509                port->tty->hw_stopped = 0;
 510        
 511        /*
 512         * Set up parity check flag
 513         * XXX: not implemented, yet.
 514         */
 515#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
 516        
 517        /*
 518         * Characters to ignore
 519         * XXX: not implemented, yet.
 520         */
 521        
 522        /*
 523         * !!! ignore all characters if CREAD is not set
 524         * XXX: not implemented, yet.
 525         */
 526        if ((cflag & CREAD) == 0)
 527                port->ignore_status_mask |= SAB82532_ISR0_RPF;
 528        
 529        save_flags(flags); 
 530        cli();
 531        sab8253x_cec_wait(port);
 532        
 533        WRITEB(port, bgr, ebrg);
 534        WRITEB(port, ccr2, READB(port, ccr2) & ~(0xc0)); /* clear out current baud rage */
 535        WRITEB(port, ccr2, READB(port, ccr2) | ccr2);
 536        WRITEB(port, ccr4, (READB(port,ccr4) & ~SAB82532_CCR4_EBRG) | ccr4);
 537        
 538        if (port->flags & FLAG8253X_CTS_FLOW) 
 539        {
 540                WRITEB(port, mode, READB(port,mode) & ~(SAB82532_MODE_RTS));
 541                port->interrupt_mask1 &= ~(SAB82532_IMR1_CSC);
 542                WRITEB(port, imr1, port->interrupt_mask1);
 543        } 
 544        else 
 545        {
 546                WRITEB(port, mode, READB(port,mode) | SAB82532_MODE_RTS);
 547                port->interrupt_mask1 |= SAB82532_IMR1_CSC;
 548                WRITEB(port, imr1, port->interrupt_mask1);
 549        }
 550        WRITEB(port, mode, READB(port, mode) | SAB82532_MODE_RAC);
 551        restore_flags(flags);
 552}
 553
 554void sab8253x_set_termiosS(struct tty_struct *tty,
 555                           struct termios *old_termios)
 556{
 557        struct sab_port *port = (struct sab_port *)tty->driver_data;
 558        
 559        if((tty->termios->c_cflag == old_termios->c_cflag) && 
 560           (RELEVANT_IFLAG(tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag)))
 561        {
 562                return;
 563        }
 564        if(!port)
 565        {
 566                return;
 567        }
 568        sab8253x_change_speedS(port);
 569        
 570        /* Handle transition to B0 status */
 571        if ((old_termios->c_cflag & CBAUD) &&
 572            !(tty->termios->c_cflag & CBAUD)) 
 573        {
 574                LOWER(port,rts);
 575                LOWER(port,dtr);
 576        }
 577        
 578        /* Handle transition away from B0 status */
 579        if (!(old_termios->c_cflag & CBAUD) &&
 580            (tty->termios->c_cflag & CBAUD)) 
 581        {
 582                RAISE(port,dtr);
 583                if (!tty->hw_stopped ||
 584                    !(tty->termios->c_cflag & CRTSCTS)) 
 585                {
 586                        RAISE(port,rts);
 587                }
 588        }
 589        
 590        /* Handle turning off CRTSCTS */
 591        if ((old_termios->c_cflag & CRTSCTS) &&
 592            !(tty->termios->c_cflag & CRTSCTS)) 
 593        {
 594                tty->hw_stopped = 0;
 595                sab8253x_startS(tty);
 596        }
 597}
 598
 599static int sab8253x_startupS(struct sab_port *port)
 600{
 601        unsigned long flags;
 602        int retval = 0;
 603        
 604        save_flags(flags); cli();
 605        
 606        port->msgbufindex = 0;
 607        port->xmit_buf = NULL;
 608        port->buffergreedy = 0;
 609        
 610        if (port->flags & FLAG8253X_INITIALIZED) 
 611        {
 612                goto errout;
 613        }
 614        
 615        if (!port->regs) 
 616        {
 617                if (port->tty)
 618                {
 619                        set_bit(TTY_IO_ERROR, &port->tty->flags);
 620                }
 621                retval = -ENODEV;
 622                goto errout;
 623        }
 624        /*
 625         * Initialize the Hardware
 626         */
 627        sab8253x_init_lineS(port);
 628        
 629#if 0                           /* maybe should be conditional */
 630        if (port->tty->termios->c_cflag & CBAUD) 
 631        {
 632#endif
 633                /* Activate RTS */
 634                RAISE(port,rts);
 635                /* Activate DTR */
 636                RAISE(port,dtr);
 637#if 0
 638        }
 639#endif
 640        
 641        /*
 642         * Initialize the modem signals values
 643         */
 644        port->dcd.val=ISON(port,dcd);
 645        port->cts.val=ISON(port,cts);
 646        port->dsr.val=ISON(port,dsr);
 647        /*
 648         * Finally, enable interrupts
 649         */
 650        
 651        port->interrupt_mask0 = SAB82532_IMR0_RFS | SAB82532_IMR0_PCE |
 652                SAB82532_IMR0_PLLA | SAB82532_IMR0_RSC | SAB82532_IMR0_CDSC;
 653        
 654        /*((port->ccontrol.ccr2 & SAB82532_CCR2_TOE) ? SAB82532_IMR0_CDSC : 0); */
 655        
 656        WRITEB(port,imr0,port->interrupt_mask0);
 657        port->interrupt_mask1 = SAB82532_IMR1_EOP | SAB82532_IMR1_XMR |
 658                SAB82532_IMR1_TIN | SAB82532_IMR1_XPR;
 659        WRITEB(port, imr1, port->interrupt_mask1);
 660        port->all_sent = 1;
 661        
 662        if (port->tty)
 663        {
 664                clear_bit(TTY_IO_ERROR, &port->tty->flags);
 665        }
 666        port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
 667        
 668        /*
 669         * and set the speed of the serial port
 670         */
 671        sab8253x_change_speedS(port);
 672        
 673        port->flags |= FLAG8253X_INITIALIZED;
 674        port->receive_chars = sab8253x_receive_charsS;
 675        port->transmit_chars = sab8253x_transmit_charsS;
 676        port->check_status = sab8253x_check_statusS;
 677        port->receive_test = (SAB82532_ISR0_RME | SAB82532_ISR0_RFO | SAB82532_ISR0_RPF);
 678        port->transmit_test = (SAB82532_ISR1_ALLS | SAB82532_ISR1_RDO | SAB82532_ISR1_XPR |
 679                               SAB82532_ISR1_XDU | SAB82532_ISR1_CSC);
 680        port->check_status_test = (SAB82532_ISR1_CSC);
 681        
 682        /*((port->ccontrol.ccr2 & SAB82532_CCR2_TOE) ? 0 : SAB82532_ISR0_CDSC));*/
 683        
 684        
 685        restore_flags(flags);
 686        return 0;
 687        
 688 errout:
 689        restore_flags(flags);
 690        return retval;
 691}
 692
 693static void sab8253x_shutdownS(struct sab_port *port)
 694{
 695        unsigned long flags;
 696        
 697        if (!(port->flags & FLAG8253X_INITIALIZED))
 698        {
 699                return;
 700        }
 701        
 702        save_flags(flags); cli(); /* Disable interrupts */
 703        
 704        /*
 705         * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
 706         * here so the queue might never be waken up
 707         */
 708        wake_up_interruptible(&port->delta_msr_wait);
 709        
 710        if (port->xmit_buf) 
 711        {
 712                port->xmit_buf = 0;
 713        }
 714#ifdef XCONFIG_SERIAL_CONSOLE
 715        if (port->is_console) 
 716        {
 717                port->interrupt_mask0 = 
 718                        SAB82532_IMR0_PERR | SAB82532_IMR0_FERR |
 719                        /*SAB82532_IMR0_TIME |*/
 720                        SAB82532_IMR0_PLLA | SAB82532_IMR0_CDSC;
 721                WRITEB(port,imr0,port->interrupt_mask0);
 722                port->interrupt_mask1 = 
 723                        SAB82532_IMR1_BRKT | SAB82532_IMR1_ALLS |
 724                        SAB82532_IMR1_XOFF | SAB82532_IMR1_TIN |
 725                        SAB82532_IMR1_CSC | SAB82532_IMR1_XON |
 726                        SAB82532_IMR1_XPR;
 727                WRITEB(port,imr1,port->interrupt_mask1);
 728                if (port->tty)
 729                {
 730                        set_bit(TTY_IO_ERROR, &port->tty->flags);
 731                }
 732                port->flags &= ~FLAG8253X_INITIALIZED;
 733                restore_flags(flags);
 734                return;
 735        }
 736#endif
 737        
 738        /* Disable Interrupts */
 739        
 740        port->interrupt_mask0 = 0xff;
 741        WRITEB(port, imr0, port->interrupt_mask0);
 742        port->interrupt_mask1 = 0xff;
 743        WRITEB(port, imr1, port->interrupt_mask1);
 744        
 745        if (!port->tty || (port->tty->termios->c_cflag & HUPCL)) 
 746        {
 747                LOWER(port,rts);
 748                LOWER(port,dtr);
 749        }
 750        
 751        /* Disable Receiver */  
 752        CLEAR_REG_BIT(port,mode,SAB82532_MODE_RAC);
 753        
 754        /* Power Down */        
 755        CLEAR_REG_BIT(port,ccr0,SAB82532_CCR0_PU);
 756        
 757        if (port->tty)
 758        {
 759                set_bit(TTY_IO_ERROR, &port->tty->flags);
 760        }
 761        
 762        port->flags &= ~FLAG8253X_INITIALIZED;
 763        restore_flags(flags);
 764}
 765
 766int sab8253x_writeS(struct tty_struct * tty, int from_user,
 767                    const unsigned char *buf, int count)
 768{
 769        struct sab_port *port = (struct sab_port *)tty->driver_data;
 770        struct sk_buff *skb;
 771        int truelength = 0;
 772        int do_queue = 1;
 773        
 774        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_write"))
 775        {
 776                return 0;
 777        }
 778        
 779        if(count == 0)
 780        {
 781                return 0;
 782        }
 783        
 784        if(port->active2.transmit == NULL)
 785        {
 786                return 0;
 787        }
 788        
 789        if((port->active2.transmit->Count & OWNER) == OWN_SAB)
 790        {
 791                sab8253x_start_txS(port);       /* no descriptor slot */
 792                return 0;
 793        }
 794        
 795#ifndef FREEININTERRUPT
 796        skb = port->active2.transmit->HostVaddr; /* current slot value */
 797        
 798        if(port->buffergreedy == 0)     /* are we avoiding buffer free's */
 799        {                               /* no */
 800                if((skb != NULL) || /* not OWN_SAB from above */
 801                   (port->active2.transmit->crcindex != 0)) 
 802                {
 803                        register RING_DESCRIPTOR *freeme;
 804                        
 805                        freeme = port->active2.transmit;
 806                        do
 807                        {
 808                                if((freeme->crcindex == 0) && (freeme->HostVaddr == NULL))
 809                                {
 810                                        break;
 811                                }
 812                                if(freeme->HostVaddr)
 813                                {
 814                                        skb_unlink((struct sk_buff*)freeme->HostVaddr);
 815                                        dev_kfree_skb_any((struct sk_buff*)freeme->HostVaddr);
 816                                        freeme->HostVaddr = NULL;
 817                                }
 818                                freeme->sendcrc = 0;
 819                                freeme->crcindex = 0;
 820                                freeme = (RING_DESCRIPTOR*) freeme->VNext;
 821                        }
 822                        while((freeme->Count & OWNER) != OWN_SAB);
 823                }
 824                skb = NULL;             /* buffer was freed */
 825        }
 826        
 827        if(skb != NULL)         /* potentially useful */
 828        {
 829                truelength = (skb->end - skb->head);
 830                if(truelength >= count)
 831                {
 832                        skb->data = skb->head; /* this buffer is already queued */
 833                        skb->tail = skb->head;
 834                        do_queue = 0;
 835                }
 836                else
 837                {
 838                        skb_unlink(skb);
 839                        dev_kfree_skb_any(skb);
 840                        skb = NULL;
 841                        port->active2.transmit->HostVaddr = NULL;
 842                }
 843        }
 844        /* in all cases the following is allowed */
 845        port->active2.transmit->sendcrc = 0;
 846        port->active2.transmit->crcindex = 0;
 847#endif
 848        
 849        if(skb == NULL)
 850        {
 851                if(port->DoingInterrupt)
 852                {
 853                        skb = alloc_skb(count, GFP_ATOMIC);
 854                }
 855                else
 856                {
 857                        skb = alloc_skb(count, GFP_KERNEL);
 858                }
 859        }
 860        
 861        if(skb == NULL)
 862        {
 863                printk(KERN_ALERT "sab8253xs: no skbuffs available.\n");
 864                return 0;
 865        }
 866        if(from_user)
 867        {
 868                copy_from_user(skb->data, buf, count);
 869        }
 870        else
 871        {
 872                memcpy(skb->data, buf, count);
 873        }
 874        skb->tail = (skb->data + count);
 875        skb->data_len = count;
 876        skb->len = count;
 877        
 878        if(do_queue)
 879        {
 880                skb_queue_head(port->sab8253xbuflist, skb);
 881        }
 882        
 883        port->active2.transmit->HostVaddr = skb;
 884        port->active2.transmit->sendcrc = 0;
 885        port->active2.transmit->crcindex = 0;
 886        port->active2.transmit->Count = (OWN_SAB|count);
 887        port->active2.transmit = port->active2.transmit->VNext;
 888        
 889        sab8253x_start_txS(port);
 890        return count;
 891}
 892
 893void sab8253x_throttleS(struct tty_struct * tty)
 894{
 895        struct sab_port *port = (struct sab_port *)tty->driver_data;
 896        
 897        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_throttleS"))
 898        {
 899                return;
 900        }
 901        
 902        if (!tty)
 903        {
 904                return;
 905        }
 906        
 907        if (I_IXOFF(tty))
 908        {
 909                sab8253x_send_xcharS(tty, STOP_CHAR(tty));
 910        }
 911}
 912
 913void sab8253x_unthrottleS(struct tty_struct * tty)
 914{
 915        struct sab_port *port = (struct sab_port *)tty->driver_data;
 916        
 917        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_unthrottle"))
 918        {
 919                return;
 920        }
 921        
 922        if (!tty)
 923        {
 924                return;
 925        }
 926        
 927        if (I_IXOFF(tty)) 
 928        {
 929                sab8253x_send_xcharS(tty, START_CHAR(tty));
 930        }
 931}
 932
 933void sab8253x_send_xcharS(struct tty_struct *tty, char ch)
 934{
 935        struct sab_port *port = (struct sab_port *)tty->driver_data;
 936        unsigned long flags;
 937        int stopped;
 938        int hw_stopped;
 939        
 940        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_send_xcharS"))
 941        {
 942                return;
 943        }
 944        
 945        if (!tty)
 946        {
 947                return;
 948        }
 949        
 950        if(port->sabnext2.transmit == NULL)
 951        {
 952                return;
 953        }
 954        
 955        save_flags(flags); cli();
 956        
 957        if((port->sabnext2.transmit->Count & OWNER) == OWN_SAB) /* may overwrite a character
 958                                                                 * -- but putting subsequent
 959                                                                 * XONs or XOFFs later in the
 960                                                                 * stream could cause problems
 961                                                                 * with the XON and XOFF protocol */
 962        {
 963                port->sabnext2.transmit->sendcrc = 1;
 964                port->sabnext2.transmit->crcindex = 3;
 965                port->sabnext2.transmit->crc = (ch << 24); /* LITTLE ENDIAN */
 966                restore_flags(flags);
 967        }
 968        else
 969        {
 970                restore_flags(flags);
 971                sab8253x_writeS(tty, 0, &ch, 1);
 972        }
 973        
 974        stopped = tty->stopped;
 975        hw_stopped = tty->hw_stopped;
 976        tty->stopped = 0;
 977        tty->hw_stopped = 0;
 978        
 979        sab8253x_start_txS(port);
 980        
 981        tty->stopped = stopped;
 982        tty->hw_stopped = hw_stopped;
 983}
 984
 985
 986void sab8253x_breakS(struct tty_struct *tty, int break_state)
 987{
 988        struct sab_port *port = (struct sab_port *) tty->driver_data;
 989        
 990        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_breakS"))
 991        {
 992                return;
 993        } /* can't break in sync mode */
 994}
 995
 996void sab8253x_closeS(struct tty_struct *tty, struct file * filp)
 997{
 998        struct sab_port *port = (struct sab_port *)tty->driver_data;
 999        unsigned long flags;
1000

1001        MOD_DEC_USE_COUNT;      
1002        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_closeS"))
1003        {
1004                return;
1005        }
1006
1007        if(port->open_type == OPEN_SYNC_NET)
1008        {                               /* port->tty field should already be NULL */
1009                return;
1010        }
1011        
1012        save_flags(flags); cli();
1013        --(port->count);
1014        if (tty_hung_up_p(filp)) 
1015        {
1016                if(port->count == 0)    /* I think the reason for the weirdness
1017                                           relates to freeing of structures in
1018                                           the tty driver */
1019                {
1020                        port->open_type = OPEN_NOT;
1021                }
1022                else if(port->count < 0)
1023                {
1024                        printk(KERN_ALERT "XX20: port->count went negative.\n");
1025                        port->count = 0;
1026                        port->open_type = OPEN_NOT;
1027                }
1028                restore_flags(flags);
1029                return;
1030        }
1031        
1032#if 0
1033        if ((tty->count == 1) && (port->count != 0)) 
1034        {
1035                /*
1036                 * Uh, oh.  tty->count is 1, which means that the tty
1037                 * structure will be freed.  port->count should always
1038                 * be one in these conditions.  If it's greater than
1039                 * one, we've got real problems, since it means the
1040                 * serial port won't be shutdown.
1041                 */
1042                printk("sab8253x_close: bad serial port count; tty->count is 1,"
1043                       " port->count is %d\n", port->count);
1044                port->count = 0;
1045        }
1046#endif
1047        
1048        if (port->count < 0) 
1049        {
1050                printk(KERN_ALERT "sab8253x_close: bad serial port count for ttys%d: %d\n",
1051                       port->line, port->count);
1052                port->count = 0;
1053        }
1054        if (port->count) 
1055        {
1056                restore_flags(flags);
1057                return;
1058        }
1059        port->flags |= FLAG8253X_CLOSING;
1060        
1061        /*
1062         * Save the termios structure, since this port may have
1063         * separate termios for callout and dialin.
1064         */
1065        if (port->flags & FLAG8253X_NORMAL_ACTIVE)
1066        {
1067                port->normal_termios = *tty->termios;
1068        }
1069        if (port->flags & FLAG8253X_CALLOUT_ACTIVE)
1070        {
1071                port->callout_termios = *tty->termios;
1072        }
1073        /*
1074         * Now we wait for the transmit buffer to clear; and we notify 
1075         * the line discipline to only process XON/XOFF characters.
1076         */
1077        tty->closing = 1;
1078        if (port->closing_wait != SAB8253X_CLOSING_WAIT_NONE) 
1079        {
1080                tty_wait_until_sent(tty, port->closing_wait);
1081        }
1082        
1083        /*
1084         * At this point we stop accepting input.  To do this, we
1085         * disable the receive line status interrupts, and turn off
1086         * the receiver.
1087         */
1088        
1089#if 0
1090        port->interrupt_mask0 |= SAB82532_IMR0_TCD; /* not needed for sync */
1091#endif
1092        WRITEB(port,imr0,port->interrupt_mask0);
1093        
1094        CLEAR_REG_BIT(port, mode, SAB82532_MODE_RAC); /* turn off receiver */
1095        
1096        if (port->flags & FLAG8253X_INITIALIZED) 
1097        {
1098                /*
1099                 * Before we drop DTR, make sure the UART transmitter
1100                 * has completely drained; this is especially
1101                 * important if there is a transmit FIFO!
1102                 */
1103                sab8253x_wait_until_sent(tty, port->timeout);
1104        }
1105        sab8253x_shutdownS(port);
1106        Sab8253xCleanUpTransceiveN(port);
1107        if (tty->driver.flush_buffer)
1108        {
1109                tty->driver.flush_buffer(tty);
1110        }
1111        tty_ldisc_flush(tty);
1112        tty->closing = 0;
1113        port->event = 0;
1114        port->tty = 0;
1115        if (port->blocked_open) 
1116        {
1117                if (port->close_delay) 
1118                {
1119                        current->state = TASK_INTERRUPTIBLE;
1120                        schedule_timeout(port->close_delay);
1121                }
1122                wake_up_interruptible(&port->open_wait);
1123        }
1124        port->flags &= ~(FLAG8253X_NORMAL_ACTIVE|FLAG8253X_CALLOUT_ACTIVE|
1125                         FLAG8253X_CLOSING);
1126        wake_up_interruptible(&port->close_wait);
1127        port->open_type = OPEN_NOT;
1128        restore_flags(flags);
1129}
1130
1131
1132void sab8253x_hangupS(struct tty_struct *tty)
1133{
1134        struct sab_port * port = (struct sab_port *)tty->driver_data;
1135        
1136        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_hangupS"))
1137        {
1138                return;
1139        }
1140        
1141#ifdef XCONFIG_SERIAL_CONSOLE
1142        if (port->is_console)
1143        {
1144                return;
1145        }
1146#endif
1147        
1148        sab8253x_flush_buffer(tty);
1149        if(port)
1150        {
1151                sab8253x_shutdownS(port);
1152                Sab8253xCleanUpTransceiveN(port);
1153                port->event = 0;
1154                port->flags &= ~(FLAG8253X_NORMAL_ACTIVE|FLAG8253X_CALLOUT_ACTIVE);
1155                port->tty = 0;
1156                wake_up_interruptible(&port->open_wait);
1157        }
1158}
1159
1160int sab8253x_openS(struct tty_struct *tty, struct file * filp)
1161{
1162        struct sab_port *port;
1163        int retval, line;
1164        int counter;
1165        unsigned long flags;
1166        
1167        MOD_INC_USE_COUNT;  
1168        line = MINOR(tty->device) - tty->driver.minor_start;
1169        
1170        for(counter = 0, port = AuraPortRoot; 
1171            (counter < line) && (port != NULL); 
1172            ++counter)
1173        {
1174                port = port->next;
1175        }
1176        
1177        if (!port) 
1178        {
1179                printk(KERN_ALERT "sab8253x_openS: can't find structure for line %d\n",
1180                       line);
1181                return -ENODEV;
1182        }
1183        
1184        save_flags(flags);              /* Need to protect port->tty element */
1185        cli();
1186        
1187        if(port->tty == 0)
1188        {
1189                port->tty = tty;
1190                tty->flip.tqueue.routine = sab8253x_flush_to_ldiscS;
1191        }
1192        tty->driver_data = port;
1193        
1194        if(port->function != FUNCTION_NR)
1195        {
1196                ++(port->count);
1197                restore_flags(flags);
1198                return -ENODEV;         /* only allowed if there are no restrictions on the port */
1199        }
1200        
1201        if(port->open_type == OPEN_SYNC_NET)
1202        {
1203                port->tty = NULL;       /* Don't bother with open counting here
1204                                           but make sure the tty field is NULL*/
1205                restore_flags(flags);
1206                return -EBUSY;
1207        }
1208        
1209        restore_flags(flags);
1210        
1211        if (sab8253x_serial_paranoia_check(port, tty->device, "sab8253x_openS"))
1212        {
1213                ++(port->count);
1214                return -ENODEV;
1215        }
1216        
1217#ifdef DEBUG_OPEN
1218        printk("sab8253x_open %s%d, count = %d\n", tty->driver.name, port->line,
1219               port->count);
1220#endif
1221        
1222        /*
1223         * If the port is in the middle of closing, bail out now.
1224         */
1225        if (tty_hung_up_p(filp) ||
1226            (port->flags & FLAG8253X_CLOSING)) 
1227        {
1228                
1229                if (port->flags & FLAG8253X_CLOSING)
1230                {
1231                        interruptible_sleep_on(&port->close_wait);
1232                }
1233#ifdef SERIAL_DO_RESTART
1234                ++(port->count);
1235                return ((port->flags & FLAG8253X_HUP_NOTIFY) ?
1236                        -EAGAIN : -ERESTARTSYS);
1237#else
1238                ++(port->count);
1239                return -EAGAIN;
1240#endif
1241        }
1242        
1243        if(port->flags & FLAG8253X_NORMAL_ACTIVE)
1244        {
1245                if(port->open_type == OPEN_ASYNC)
1246                {
1247                        ++(port->count);
1248                        return -EBUSY;  /* can't reopen in sync mode */
1249                }
1250        }
1251        if(port->open_type > OPEN_SYNC) /* can reopen a SYNC_TTY */
1252        {
1253                return -EBUSY;
1254        }
1255        if(Sab8253xSetUpLists(port))
1256        {
1257                ++(port->count);
1258                return -ENODEV;
1259        }
1260        if(Sab8253xInitDescriptors2(port, sab8253xs_listsize, sab8253xs_rbufsize))
1261        {
1262                ++(port->count);
1263                return -ENODEV;
1264        }
1265        
1266        retval = sab8253x_startupS(port);
1267        if (retval)
1268        {
1269                ++(port->count);
1270                return retval;          /* does not check channel mode */
1271        }
1272        
1273        retval = sab8253x_block_til_ready(tty, filp, port); /* checks channel mode */
1274        ++(port->count);
1275        if (retval) 
1276        {
1277                return retval;
1278        }
1279        
1280        port->tty = tty;                /* may change here once through the block */
1281        /* because now the port belongs to an new tty */
1282        tty->flip.tqueue.routine = sab8253x_flush_to_ldiscS;
1283        if(Sab8253xSetUpLists(port))
1284        {
1285                return -ENODEV;
1286        }
1287        if(Sab8253xInitDescriptors2(port, sab8253xs_listsize, sab8253xs_rbufsize))
1288        {
1289                Sab8253xCleanUpTransceiveN(port);       /* the network functions should be okay -- only difference */
1290                /* is the crc32 that is appended */
1291                return -ENODEV;
1292        }
1293        
1294        /*
1295         * Start up serial port
1296         */
1297        retval = sab8253x_startupS(port); /* in case cu was running the first time
1298                                           * the function was called*/
1299        if (retval)
1300        {
1301                return retval;          /* does not check channel mode */
1302        }
1303        
1304        if ((port->count == 1) &&
1305            (port->flags & FLAG8253X_SPLIT_TERMIOS)) 
1306        {
1307                if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
1308                {
1309                        *tty->termios = port->normal_termios;
1310                }
1311                else 
1312                {
1313                        *tty->termios = port->callout_termios;
1314                }
1315                sab8253x_change_speedS(port);
1316        }
1317        
1318        
1319#ifdef XCONFIG_SERIAL_CONSOLE
1320        if (sab8253x_console.cflag && sab8253x_console.index == line) 
1321        {
1322                tty->termios->c_cflag = sab8253x_console.cflag;
1323                sab8253x_console.cflag = 0;
1324                change_speed(port);
1325        }
1326#endif
1327        
1328        port->session = current->session;
1329        port->pgrp = current->pgrp;
1330        port->open_type = OPEN_SYNC;
1331        return 0;
1332}
1333
1334
1335
1336
1337