drivers/char/epca.c

   1 /*
   2
   3
   4         Copyright (C) 1996  Digi International.
   5
   6         For technical support please email digiLinux@dgii.com or
   7         call Digi tech support at (612) 912-3456
   8
   9         ** This driver is no longer supported by Digi **
  10
  11         Much of this design and code came from epca.c which was
  12         copyright (C) 1994, 1995 Troy De Jongh, and subsquently
  13         modified by David Nugent, Christoph Lameter, Mike McLagan.
  14
  15         This program is free software; you can redistribute it and/or modify
  16         it under the terms of the GNU General Public License as published by
  17         the Free Software Foundation; either version 2 of the License, or
  18         (at your option) any later version.
  19
  20         This program is distributed in the hope that it will be useful,
  21         but WITHOUT ANY WARRANTY; without even the implied warranty of
  22         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23         GNU General Public License for more details.
  24
  25         You should have received a copy of the GNU General Public License
  26         along with this program; if not, write to the Free Software
  27         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28
  29 --------------------------------------------------------------------------- */
  30 /* See README.epca for change history --DAT*/
  31
  32
  33 #include <linux/config.h>
  34 #include <linux/module.h>
  35 #include <linux/kernel.h>
  36 #include <linux/types.h>
  37 #include <linux/init.h>
  38 #include <linux/serial.h>
  39 #include <linux/delay.h>
  40 #include <linux/ctype.h>
  41 #include <linux/tty.h>
  42 #include <linux/tty_flip.h>
  43 #include <linux/slab.h>
  44 #include <linux/ioport.h>
  45 #include <linux/interrupt.h>
  46 #include <asm/uaccess.h>
  47 #include <asm/io.h>
  48 #include <linux/spinlock.h>
  49 #include <linux/pci.h>
  50 #include "digiPCI.h"
  51
  52
  53 #include "digi1.h"
  54 #include "digiFep1.h"
  55 #include "epca.h"
  56 #include "epcaconfig.h"
  57
  58 /* ---------------------- Begin defines ------------------------ */
  59
  60 #define VERSION            "1.3.0.1-LK2.6"
  61
  62 /* This major needs to be submitted to Linux to join the majors list */
  63
  64 #define DIGIINFOMAJOR       35  /* For Digi specific ioctl */
  65
  66
  67 #define MAXCARDS 7
  68 #define epcaassert(x, msg)  if (!(x)) epca_error(__LINE__, msg)
  69
  70 #define PFX "epca: "
  71
  72 /* ----------------- Begin global definitions ------------------- */
  73
  74 static int nbdevs, num_cards, liloconfig;
  75 static int digi_poller_inhibited = 1 ;
  76
  77 static int setup_error_code;
  78 static int invalid_lilo_config;
  79
  80 /* The ISA boards do window flipping into the same spaces so its only sane
  81    with a single lock. It's still pretty efficient */
  82
  83 static DEFINE_SPINLOCK(epca_lock);
  84
  85 /* -----------------------------------------------------------------------
  86         MAXBOARDS is typically 12, but ISA and EISA cards are restricted to
  87         7 below.
  88 --------------------------------------------------------------------------*/
  89 static struct board_info boards[MAXBOARDS];
  90
  91
  92 /* ------------- Begin structures used for driver registeration ---------- */
  93
  94 static struct tty_driver *pc_driver;
  95 static struct tty_driver *pc_info;
  96
  97 /* ------------------ Begin Digi specific structures -------------------- */
  98
  99 /* ------------------------------------------------------------------------
 100         digi_channels represents an array of structures that keep track of
 101         each channel of the Digi product.  Information such as transmit and
 102         receive pointers, termio data, and signal definitions (DTR, CTS, etc ...)
 103         are stored here.  This structure is NOT used to overlay the cards
 104         physical channel structure.
 105 -------------------------------------------------------------------------- */
 106
 107 static struct channel digi_channels[MAX_ALLOC];
 108
 109 /* ------------------------------------------------------------------------
 110         card_ptr is an array used to hold the address of the
 111         first channel structure of each card.  This array will hold
 112         the addresses of various channels located in digi_channels.
 113 -------------------------------------------------------------------------- */
 114 static struct channel *card_ptr[MAXCARDS];
 115
 116 static struct timer_list epca_timer;
 117
 118 /* ---------------------- Begin function prototypes --------------------- */
 119
 120 /* ----------------------------------------------------------------------
 121         Begin generic memory functions.  These functions will be alias
 122         (point at) more specific functions dependent on the board being
 123         configured.
 124 ----------------------------------------------------------------------- */
 125
 126 static void memwinon(struct board_info *b, unsigned int win);
 127 static void memwinoff(struct board_info *b, unsigned int win);
 128 static void globalwinon(struct channel *ch);
 129 static void rxwinon(struct channel *ch);
 130 static void txwinon(struct channel *ch);
 131 static void memoff(struct channel *ch);
 132 static void assertgwinon(struct channel *ch);
 133 static void assertmemoff(struct channel *ch);
 134
 135 /* ---- Begin more 'specific' memory functions for cx_like products --- */
 136
 137 static void pcxem_memwinon(struct board_info *b, unsigned int win);
 138 static void pcxem_memwinoff(struct board_info *b, unsigned int win);
 139 static void pcxem_globalwinon(struct channel *ch);
 140 static void pcxem_rxwinon(struct channel *ch);
 141 static void pcxem_txwinon(struct channel *ch);
 142 static void pcxem_memoff(struct channel *ch);
 143
 144 /* ------ Begin more 'specific' memory functions for the pcxe ------- */
 145
 146 static void pcxe_memwinon(struct board_info *b, unsigned int win);
 147 static void pcxe_memwinoff(struct board_info *b, unsigned int win);
 148 static void pcxe_globalwinon(struct channel *ch);
 149 static void pcxe_rxwinon(struct channel *ch);
 150 static void pcxe_txwinon(struct channel *ch);
 151 static void pcxe_memoff(struct channel *ch);
 152
 153 /* ---- Begin more 'specific' memory functions for the pc64xe and pcxi ---- */
 154 /* Note : pc64xe and pcxi share the same windowing routines */
 155
 156 static void pcxi_memwinon(struct board_info *b, unsigned int win);
 157 static void pcxi_memwinoff(struct board_info *b, unsigned int win);
 158 static void pcxi_globalwinon(struct channel *ch);
 159 static void pcxi_rxwinon(struct channel *ch);
 160 static void pcxi_txwinon(struct channel *ch);
 161 static void pcxi_memoff(struct channel *ch);
 162
 163 /* - Begin 'specific' do nothing memory functions needed for some cards - */
 164
 165 static void dummy_memwinon(struct board_info *b, unsigned int win);
 166 static void dummy_memwinoff(struct board_info *b, unsigned int win);
 167 static void dummy_globalwinon(struct channel *ch);
 168 static void dummy_rxwinon(struct channel *ch);
 169 static void dummy_txwinon(struct channel *ch);
 170 static void dummy_memoff(struct channel *ch);
 171 static void dummy_assertgwinon(struct channel *ch);
 172 static void dummy_assertmemoff(struct channel *ch);
 173
 174 /* ------------------- Begin declare functions ----------------------- */
 175
 176 static struct channel *verifyChannel(struct tty_struct *);
 177 static void pc_sched_event(struct channel *, int);
 178 static void epca_error(int, char *);
 179 static void pc_close(struct tty_struct *, struct file *);
 180 static void shutdown(struct channel *);
 181 static void pc_hangup(struct tty_struct *);
 182 static void pc_put_char(struct tty_struct *, unsigned char);
 183 static int pc_write_room(struct tty_struct *);
 184 static int pc_chars_in_buffer(struct tty_struct *);
 185 static void pc_flush_buffer(struct tty_struct *);
 186 static void pc_flush_chars(struct tty_struct *);
 187 static int block_til_ready(struct tty_struct *, struct file *,
 188                            struct channel *);
 189 static int pc_open(struct tty_struct *, struct file *);
 190 static void post_fep_init(unsigned int crd);
 191 static void epcapoll(unsigned long);
 192 static void doevent(int);
 193 static void fepcmd(struct channel *, int, int, int, int, int);
 194 static unsigned termios2digi_h(struct channel *ch, unsigned);
 195 static unsigned termios2digi_i(struct channel *ch, unsigned);
 196 static unsigned termios2digi_c(struct channel *ch, unsigned);
 197 static void epcaparam(struct tty_struct *, struct channel *);
 198 static void receive_data(struct channel *);
 199 static int pc_ioctl(struct tty_struct *, struct file *,
 200                     unsigned int, unsigned long);
 201 static int info_ioctl(struct tty_struct *, struct file *,
 202                     unsigned int, unsigned long);
 203 static void pc_set_termios(struct tty_struct *, struct termios *);
 204 static void do_softint(void *);
 205 static void pc_stop(struct tty_struct *);
 206 static void pc_start(struct tty_struct *);
 207 static void pc_throttle(struct tty_struct * tty);
 208 static void pc_unthrottle(struct tty_struct *tty);
 209 static void digi_send_break(struct channel *ch, int msec);
 210 static void setup_empty_event(struct tty_struct *tty, struct channel *ch);
 211 void epca_setup(char *, int *);
 212
 213 static int get_termio(struct tty_struct *, struct termio __user *);
 214 static int pc_write(struct tty_struct *, const unsigned char *, int);
 215 static int pc_init(void);
 216 static int init_PCI(void);
 217
 218
 219 /* ------------------------------------------------------------------
 220         Table of functions for each board to handle memory.  Mantaining
 221         parallelism is a *very* good idea here.  The idea is for the
 222         runtime code to blindly call these functions, not knowing/caring
 223         about the underlying hardware.  This stuff should contain no
 224         conditionals; if more functionality is needed a different entry
 225         should be established.  These calls are the interface calls and
 226         are the only functions that should be accessed.  Anyone caught
 227         making direct calls deserves what they get.
 228 -------------------------------------------------------------------- */
 229
 230 static void memwinon(struct board_info *b, unsigned int win)
 231 {
 232         (b->memwinon)(b, win);
 233 }
 234
 235 static void memwinoff(struct board_info *b, unsigned int win)
 236 {
 237         (b->memwinoff)(b, win);
 238 }
 239
 240 static void globalwinon(struct channel *ch)
 241 {
 242         (ch->board->globalwinon)(ch);
 243 }
 244
 245 static void rxwinon(struct channel *ch)
 246 {
 247         (ch->board->rxwinon)(ch);
 248 }
 249
 250 static void txwinon(struct channel *ch)
 251 {
 252         (ch->board->txwinon)(ch);
 253 }
 254
 255 static void memoff(struct channel *ch)
 256 {
 257         (ch->board->memoff)(ch);
 258 }
 259 static void assertgwinon(struct channel *ch)
 260 {
 261         (ch->board->assertgwinon)(ch);
 262 }
 263
 264 static void assertmemoff(struct channel *ch)
 265 {
 266         (ch->board->assertmemoff)(ch);
 267 }
 268
 269 /* ---------------------------------------------------------
 270         PCXEM windowing is the same as that used in the PCXR
 271         and CX series cards.
 272 ------------------------------------------------------------ */
 273
 274 static void pcxem_memwinon(struct board_info *b, unsigned int win)
 275 {
 276         outb_p(FEPWIN|win, b->port + 1);
 277 }
 278
 279 static void pcxem_memwinoff(struct board_info *b, unsigned int win)
 280 {
 281         outb_p(0, b->port + 1);
 282 }
 283
 284 static void pcxem_globalwinon(struct channel *ch)
 285 {
 286         outb_p( FEPWIN, (int)ch->board->port + 1);
 287 }
 288
 289 static void pcxem_rxwinon(struct channel *ch)
 290 {
 291         outb_p(ch->rxwin, (int)ch->board->port + 1);
 292 }
 293
 294 static void pcxem_txwinon(struct channel *ch)
 295 {
 296         outb_p(ch->txwin, (int)ch->board->port + 1);
 297 }
 298
 299 static void pcxem_memoff(struct channel *ch)
 300 {
 301         outb_p(0, (int)ch->board->port + 1);
 302 }
 303
 304 /* ----------------- Begin pcxe memory window stuff ------------------ */
 305
 306 static void pcxe_memwinon(struct board_info *b, unsigned int win)
 307 {
 308                outb_p(FEPWIN | win, b->port + 1);
 309 }
 310
 311 static void pcxe_memwinoff(struct board_info *b, unsigned int win)
 312 {
 313         outb_p(inb(b->port) & ~FEPMEM,
 314                    b->port + 1);
 315         outb_p(0, b->port + 1);
 316 }
 317
 318 static void pcxe_globalwinon(struct channel *ch)
 319 {
 320         outb_p( FEPWIN, (int)ch->board->port + 1);
 321 }
 322
 323 static void pcxe_rxwinon(struct channel *ch)
 324 {
 325                 outb_p(ch->rxwin, (int)ch->board->port + 1);
 326 }
 327
 328 static void pcxe_txwinon(struct channel *ch)
 329 {
 330                 outb_p(ch->txwin, (int)ch->board->port + 1);
 331 }
 332
 333 static void pcxe_memoff(struct channel *ch)
 334 {
 335         outb_p(0, (int)ch->board->port);
 336         outb_p(0, (int)ch->board->port + 1);
 337 }
 338
 339 /* ------------- Begin pc64xe and pcxi memory window stuff -------------- */
 340
 341 static void pcxi_memwinon(struct board_info *b, unsigned int win)
 342 {
 343                outb_p(inb(b->port) | FEPMEM, b->port);
 344 }
 345
 346 static void pcxi_memwinoff(struct board_info *b, unsigned int win)
 347 {
 348         outb_p(inb(b->port) & ~FEPMEM, b->port);
 349 }
 350
 351 static void pcxi_globalwinon(struct channel *ch)
 352 {
 353         outb_p(FEPMEM, ch->board->port);
 354 }
 355
 356 static void pcxi_rxwinon(struct channel *ch)
 357 {
 358                 outb_p(FEPMEM, ch->board->port);
 359 }
 360
 361 static void pcxi_txwinon(struct channel *ch)
 362 {
 363                 outb_p(FEPMEM, ch->board->port);
 364 }
 365
 366 static void pcxi_memoff(struct channel *ch)
 367 {
 368         outb_p(0, ch->board->port);
 369 }
 370
 371 static void pcxi_assertgwinon(struct channel *ch)
 372 {
 373         epcaassert(inb(ch->board->port) & FEPMEM, "Global memory off");
 374 }
 375
 376 static void pcxi_assertmemoff(struct channel *ch)
 377 {
 378         epcaassert(!(inb(ch->board->port) & FEPMEM), "Memory on");
 379 }
 380
 381
 382 /* ----------------------------------------------------------------------
 383         Not all of the cards need specific memory windowing routines.  Some
 384         cards (Such as PCI) needs no windowing routines at all.  We provide
 385         these do nothing routines so that the same code base can be used.
 386         The driver will ALWAYS call a windowing routine if it thinks it needs
 387         to; regardless of the card.  However, dependent on the card the routine
 388         may or may not do anything.
 389 ---------------------------------------------------------------------------*/
 390
 391 static void dummy_memwinon(struct board_info *b, unsigned int win)
 392 {
 393 }
 394
 395 static void dummy_memwinoff(struct board_info *b, unsigned int win)
 396 {
 397 }
 398
 399 static void dummy_globalwinon(struct channel *ch)
 400 {
 401 }
 402
 403 static void dummy_rxwinon(struct channel *ch)
 404 {
 405 }
 406
 407 static void dummy_txwinon(struct channel *ch)
 408 {
 409 }
 410
 411 static void dummy_memoff(struct channel *ch)
 412 {
 413 }
 414
 415 static void dummy_assertgwinon(struct channel *ch)
 416 {
 417 }
 418
 419 static void dummy_assertmemoff(struct channel *ch)
 420 {
 421 }
 422
 423 /* ----------------- Begin verifyChannel function ----------------------- */
 424 static struct channel *verifyChannel(struct tty_struct *tty)
 425 { /* Begin verifyChannel */
 426         /* --------------------------------------------------------------------
 427                 This routine basically provides a sanity check.  It insures that
 428                 the channel returned is within the proper range of addresses as
 429                 well as properly initialized.  If some bogus info gets passed in
 430                 through tty->driver_data this should catch it.
 431                 --------------------------------------------------------------------- */
 432         if (tty) {
 433                 struct channel *ch = (struct channel *)tty->driver_data;
 434                 if ((ch >= &digi_channels[0]) && (ch < &digi_channels[nbdevs])) {
 435                         if (ch->magic == EPCA_MAGIC)
 436                                 return ch;
 437                 }
 438         }
 439         return NULL;
 440
 441 } /* End verifyChannel */
 442
 443 /* ------------------ Begin pc_sched_event ------------------------- */
 444
 445 static void pc_sched_event(struct channel *ch, int event)
 446 {
 447         /* ----------------------------------------------------------------------
 448                 We call this to schedule interrupt processing on some event.  The
 449                 kernel sees our request and calls the related routine in OUR driver.
 450         -------------------------------------------------------------------------*/
 451         ch->event |= 1 << event;
 452         schedule_work(&ch->tqueue);
 453 } /* End pc_sched_event */
 454
 455 /* ------------------ Begin epca_error ------------------------- */
 456
 457 static void epca_error(int line, char *msg)
 458 {
 459         printk(KERN_ERR "epca_error (Digi): line = %d %s\n",line,msg);
 460 }
 461
 462 /* ------------------ Begin pc_close ------------------------- */
 463 static void pc_close(struct tty_struct * tty, struct file * filp)
 464 {
 465         struct channel *ch;
 466         unsigned long flags;
 467         /* ---------------------------------------------------------
 468                 verifyChannel returns the channel from the tty struct
 469                 if it is valid.  This serves as a sanity check.
 470         ------------------------------------------------------------- */
 471         if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if ch != NULL */
 472                 spin_lock_irqsave(&epca_lock, flags);
 473                 if (tty_hung_up_p(filp)) {
 474                         spin_unlock_irqrestore(&epca_lock, flags);
 475                         return;
 476                 }
 477                 /* Check to see if the channel is open more than once */
 478                 if (ch->count-- > 1)  {
 479                         /* Begin channel is open more than once */
 480                         /* -------------------------------------------------------------
 481                                 Return without doing anything.  Someone might still be using
 482                                 the channel.
 483                         ---------------------------------------------------------------- */
 484                         spin_unlock_irqrestore(&epca_lock, flags);
 485                         return;
 486                 } /* End channel is open more than once */
 487
 488                 /* Port open only once go ahead with shutdown & reset */
 489                 BUG_ON(ch->count < 0);
 490
 491                 /* ---------------------------------------------------------------
 492                         Let the rest of the driver know the channel is being closed.
 493                         This becomes important if an open is attempted before close
 494                         is finished.
 495                 ------------------------------------------------------------------ */
 496                 ch->asyncflags |= ASYNC_CLOSING;
 497                 tty->closing = 1;
 498
 499                 spin_unlock_irqrestore(&epca_lock, flags);
 500
 501                 if (ch->asyncflags & ASYNC_INITIALIZED)  {
 502                         /* Setup an event to indicate when the transmit buffer empties */
 503                         setup_empty_event(tty, ch);
 504                         tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
 505                 }
 506                 if (tty->driver->flush_buffer)
 507                         tty->driver->flush_buffer(tty);
 508
 509                 tty_ldisc_flush(tty);
 510                 shutdown(ch);
 511
 512                 spin_lock_irqsave(&epca_lock, flags);
 513                 tty->closing = 0;
 514                 ch->event = 0;
 515                 ch->tty = NULL;
 516                 spin_unlock_irqrestore(&epca_lock, flags);
 517
 518                 if (ch->blocked_open)  { /* Begin if blocked_open */
 519                         if (ch->close_delay)
 520                                 msleep_interruptible(jiffies_to_msecs(ch->close_delay));
 521                         wake_up_interruptible(&ch->open_wait);
 522                 } /* End if blocked_open */
 523                 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED |
 524                                       ASYNC_CLOSING);
 525                 wake_up_interruptible(&ch->close_wait);
 526         } /* End if ch != NULL */
 527 } /* End pc_close */
 528
 529 /* ------------------ Begin shutdown  ------------------------- */
 530
 531 static void shutdown(struct channel *ch)
 532 { /* Begin shutdown */
 533
 534         unsigned long flags;
 535         struct tty_struct *tty;
 536         struct board_chan __iomem *bc;
 537
 538         if (!(ch->asyncflags & ASYNC_INITIALIZED))
 539                 return;
 540
 541         spin_lock_irqsave(&epca_lock, flags);
 542
 543         globalwinon(ch);
 544         bc = ch->brdchan;
 545
 546         /* ------------------------------------------------------------------
 547                 In order for an event to be generated on the receipt of data the
 548                 idata flag must be set. Since we are shutting down, this is not
 549                 necessary clear this flag.
 550         --------------------------------------------------------------------- */
 551
 552         if (bc)
 553                 writeb(0, &bc->idata);
 554         tty = ch->tty;
 555
 556         /* ----------------------------------------------------------------
 557            If we're a modem control device and HUPCL is on, drop RTS & DTR.
 558         ------------------------------------------------------------------ */
 559
 560         if (tty->termios->c_cflag & HUPCL)  {
 561                 ch->omodem &= ~(ch->m_rts | ch->m_dtr);
 562                 fepcmd(ch, SETMODEM, 0, ch->m_dtr | ch->m_rts, 10, 1);
 563         }
 564         memoff(ch);
 565
 566         /* ------------------------------------------------------------------
 567                 The channel has officialy been closed.  The next time it is opened
 568                 it will have to reinitialized.  Set a flag to indicate this.
 569         ---------------------------------------------------------------------- */
 570
 571         /* Prevent future Digi programmed interrupts from coming active */
 572
 573         ch->asyncflags &= ~ASYNC_INITIALIZED;
 574         spin_unlock_irqrestore(&epca_lock, flags);
 575
 576 } /* End shutdown */
 577
 578 /* ------------------ Begin pc_hangup  ------------------------- */
 579
 580 static void pc_hangup(struct tty_struct *tty)
 581 { /* Begin pc_hangup */
 582         struct channel *ch;
 583
 584         /* ---------------------------------------------------------
 585                 verifyChannel returns the channel from the tty struct
 586                 if it is valid.  This serves as a sanity check.
 587         ------------------------------------------------------------- */
 588
 589         if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if ch != NULL */
 590                 unsigned long flags;
 591
 592                 if (tty->driver->flush_buffer)
 593                         tty->driver->flush_buffer(tty);
 594                 tty_ldisc_flush(tty);
 595                 shutdown(ch);
 596
 597                 spin_lock_irqsave(&epca_lock, flags);
 598                 ch->tty   = NULL;
 599                 ch->event = 0;
 600                 ch->count = 0;
 601                 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED);
 602                 spin_unlock_irqrestore(&epca_lock, flags);
 603                 wake_up_interruptible(&ch->open_wait);
 604         } /* End if ch != NULL */
 605
 606 } /* End pc_hangup */
 607
 608 /* ------------------ Begin pc_write  ------------------------- */
 609
 610 static int pc_write(struct tty_struct * tty,
 611                     const unsigned char *buf, int bytesAvailable)
 612 { /* Begin pc_write */
 613         unsigned int head, tail;
 614         int dataLen;
 615         int size;
 616         int amountCopied;
 617         struct channel *ch;
 618         unsigned long flags;
 619         int remain;
 620         struct board_chan __iomem *bc;
 621
 622         /* ----------------------------------------------------------------
 623                 pc_write is primarily called directly by the kernel routine
 624                 tty_write (Though it can also be called by put_char) found in
 625                 tty_io.c.  pc_write is passed a line discipline buffer where
 626                 the data to be written out is stored.  The line discipline
 627                 implementation itself is done at the kernel level and is not
 628                 brought into the driver.
 629         ------------------------------------------------------------------- */
 630
 631         /* ---------------------------------------------------------
 632                 verifyChannel returns the channel from the tty struct
 633                 if it is valid.  This serves as a sanity check.
 634         ------------------------------------------------------------- */
 635
 636         if ((ch = verifyChannel(tty)) == NULL)
 637                 return 0;
 638
 639         /* Make a pointer to the channel data structure found on the board. */
 640
 641         bc   = ch->brdchan;
 642         size = ch->txbufsize;
 643         amountCopied = 0;
 644
 645         spin_lock_irqsave(&epca_lock, flags);
 646         globalwinon(ch);
 647
 648         head = readw(&bc->tin) & (size - 1);
 649         tail = readw(&bc->tout);
 650
 651         if (tail != readw(&bc->tout))
 652                 tail = readw(&bc->tout);
 653         tail &= (size - 1);
 654
 655         /*      If head >= tail, head has not wrapped around. */
 656         if (head >= tail)  { /* Begin head has not wrapped */
 657                 /* ---------------------------------------------------------------
 658                         remain (much like dataLen above) represents the total amount of
 659                         space available on the card for data.  Here dataLen represents
 660                         the space existing between the head pointer and the end of
 661                         buffer.  This is important because a memcpy cannot be told to
 662                         automatically wrap around when it hits the buffer end.
 663                 ------------------------------------------------------------------ */
 664                 dataLen = size - head;
 665                 remain = size - (head - tail) - 1;
 666         } else { /* Begin head has wrapped around */
 667
 668                 remain = tail - head - 1;
 669                 dataLen = remain;
 670
 671         } /* End head has wrapped around */
 672         /* -------------------------------------------------------------------
 673                         Check the space on the card.  If we have more data than
 674                         space; reduce the amount of data to fit the space.
 675         ---------------------------------------------------------------------- */
 676         bytesAvailable = min(remain, bytesAvailable);
 677         txwinon(ch);
 678         while (bytesAvailable > 0)
 679         { /* Begin while there is data to copy onto card */
 680
 681                 /* -----------------------------------------------------------------
 682                         If head is not wrapped, the below will make sure the first
 683                         data copy fills to the end of card buffer.
 684                 ------------------------------------------------------------------- */
 685
 686                 dataLen = min(bytesAvailable, dataLen);
 687                 memcpy_toio(ch->txptr + head, buf, dataLen);
 688                 buf += dataLen;
 689                 head += dataLen;
 690                 amountCopied += dataLen;
 691                 bytesAvailable -= dataLen;
 692
 693                 if (head >= size) {
 694                         head = 0;
 695                         dataLen = tail;
 696                 }
 697         } /* End while there is data to copy onto card */
 698         ch->statusflags |= TXBUSY;
 699         globalwinon(ch);
 700         writew(head, &bc->tin);
 701
 702         if ((ch->statusflags & LOWWAIT) == 0)  {
 703                 ch->statusflags |= LOWWAIT;
 704                 writeb(1, &bc->ilow);
 705         }
 706         memoff(ch);
 707         spin_unlock_irqrestore(&epca_lock, flags);
 708         return(amountCopied);
 709
 710 } /* End pc_write */
 711
 712 /* ------------------ Begin pc_put_char  ------------------------- */
 713
 714 static void pc_put_char(struct tty_struct *tty, unsigned char c)
 715 { /* Begin pc_put_char */
 716         pc_write(tty, &c, 1);
 717 } /* End pc_put_char */
 718
 719 /* ------------------ Begin pc_write_room  ------------------------- */
 720
 721 static int pc_write_room(struct tty_struct *tty)
 722 { /* Begin pc_write_room */
 723
 724         int remain;
 725         struct channel *ch;
 726         unsigned long flags;
 727         unsigned int head, tail;
 728         struct board_chan __iomem *bc;
 729
 730         remain = 0;
 731
 732         /* ---------------------------------------------------------
 733                 verifyChannel returns the channel from the tty struct
 734                 if it is valid.  This serves as a sanity check.
 735         ------------------------------------------------------------- */
 736
 737         if ((ch = verifyChannel(tty)) != NULL)  {
 738                 spin_lock_irqsave(&epca_lock, flags);
 739                 globalwinon(ch);
 740
 741                 bc   = ch->brdchan;
 742                 head = readw(&bc->tin) & (ch->txbufsize - 1);
 743                 tail = readw(&bc->tout);
 744
 745                 if (tail != readw(&bc->tout))
 746                         tail = readw(&bc->tout);
 747                 /* Wrap tail if necessary */
 748                 tail &= (ch->txbufsize - 1);
 749
 750                 if ((remain = tail - head - 1) < 0 )
 751                         remain += ch->txbufsize;
 752
 753                 if (remain && (ch->statusflags & LOWWAIT) == 0) {
 754                         ch->statusflags |= LOWWAIT;
 755                         writeb(1, &bc->ilow);
 756                 }
 757                 memoff(ch);
 758                 spin_unlock_irqrestore(&epca_lock, flags);
 759         }
 760         /* Return how much room is left on card */
 761         return remain;
 762
 763 } /* End pc_write_room */
 764
 765 /* ------------------ Begin pc_chars_in_buffer  ---------------------- */
 766
 767 static int pc_chars_in_buffer(struct tty_struct *tty)
 768 { /* Begin pc_chars_in_buffer */
 769
 770         int chars;
 771         unsigned int ctail, head, tail;
 772         int remain;
 773         unsigned long flags;
 774         struct channel *ch;
 775         struct board_chan __iomem *bc;
 776
 777         /* ---------------------------------------------------------
 778                 verifyChannel returns the channel from the tty struct
 779                 if it is valid.  This serves as a sanity check.
 780         ------------------------------------------------------------- */
 781
 782         if ((ch = verifyChannel(tty)) == NULL)
 783                 return(0);
 784
 785         spin_lock_irqsave(&epca_lock, flags);
 786         globalwinon(ch);
 787
 788         bc = ch->brdchan;
 789         tail = readw(&bc->tout);
 790         head = readw(&bc->tin);
 791         ctail = readw(&ch->mailbox->cout);
 792
 793         if (tail == head && readw(&ch->mailbox->cin) == ctail && readb(&bc->tbusy) == 0)
 794                 chars = 0;
 795         else  { /* Begin if some space on the card has been used */
 796                 head = readw(&bc->tin) & (ch->txbufsize - 1);
 797                 tail &= (ch->txbufsize - 1);
 798                 /*  --------------------------------------------------------------
 799                         The logic here is basically opposite of the above pc_write_room
 800                         here we are finding the amount of bytes in the buffer filled.
 801                         Not the amount of bytes empty.
 802                 ------------------------------------------------------------------- */
 803                 if ((remain = tail - head - 1) < 0 )
 804                         remain += ch->txbufsize;
 805                 chars = (int)(ch->txbufsize - remain);
 806                 /* -------------------------------------------------------------
 807                         Make it possible to wakeup anything waiting for output
 808                         in tty_ioctl.c, etc.
 809
 810                         If not already set.  Setup an event to indicate when the
 811                         transmit buffer empties
 812                 ----------------------------------------------------------------- */
 813                 if (!(ch->statusflags & EMPTYWAIT))
 814                         setup_empty_event(tty,ch);
 815
 816         } /* End if some space on the card has been used */
 817         memoff(ch);
 818         spin_unlock_irqrestore(&epca_lock, flags);
 819         /* Return number of characters residing on card. */
 820         return(chars);
 821
 822 } /* End pc_chars_in_buffer */
 823
 824 /* ------------------ Begin pc_flush_buffer  ---------------------- */
 825
 826 static void pc_flush_buffer(struct tty_struct *tty)
 827 { /* Begin pc_flush_buffer */
 828
 829         unsigned int tail;
 830         unsigned long flags;
 831         struct channel *ch;
 832         struct board_chan __iomem *bc;
 833         /* ---------------------------------------------------------
 834                 verifyChannel returns the channel from the tty struct
 835                 if it is valid.  This serves as a sanity check.
 836         ------------------------------------------------------------- */
 837         if ((ch = verifyChannel(tty)) == NULL)
 838                 return;
 839
 840         spin_lock_irqsave(&epca_lock, flags);
 841         globalwinon(ch);
 842         bc   = ch->brdchan;
 843         tail = readw(&bc->tout);
 844         /* Have FEP move tout pointer; effectively flushing transmit buffer */
 845         fepcmd(ch, STOUT, (unsigned) tail, 0, 0, 0);
 846         memoff(ch);
 847         spin_unlock_irqrestore(&epca_lock, flags);
 848         wake_up_interruptible(&tty->write_wait);
 849         tty_wakeup(tty);
 850 } /* End pc_flush_buffer */
 851
 852 /* ------------------ Begin pc_flush_chars  ---------------------- */
 853
 854 static void pc_flush_chars(struct tty_struct *tty)
 855 { /* Begin pc_flush_chars */
 856         struct channel * ch;
 857         /* ---------------------------------------------------------
 858                 verifyChannel returns the channel from the tty struct
 859                 if it is valid.  This serves as a sanity check.
 860         ------------------------------------------------------------- */
 861         if ((ch = verifyChannel(tty)) != NULL) {
 862                 unsigned long flags;
 863                 spin_lock_irqsave(&epca_lock, flags);
 864                 /* ----------------------------------------------------------------
 865                         If not already set and the transmitter is busy setup an event
 866                         to indicate when the transmit empties.
 867                 ------------------------------------------------------------------- */
 868                 if ((ch->statusflags & TXBUSY) && !(ch->statusflags & EMPTYWAIT))
 869                         setup_empty_event(tty,ch);
 870                 spin_unlock_irqrestore(&epca_lock, flags);
 871         }
 872 } /* End pc_flush_chars */
 873
 874 /* ------------------ Begin block_til_ready  ---------------------- */
 875
 876 static int block_til_ready(struct tty_struct *tty,
 877                            struct file *filp, struct channel *ch)
 878 { /* Begin block_til_ready */
 879         DECLARE_WAITQUEUE(wait,current);
 880         int     retval, do_clocal = 0;
 881         unsigned long flags;
 882
 883         if (tty_hung_up_p(filp)) {
 884                 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
 885                         retval = -EAGAIN;
 886                 else
 887                         retval = -ERESTARTSYS;
 888                 return(retval);
 889         }
 890
 891         /* -----------------------------------------------------------------
 892                 If the device is in the middle of being closed, then block
 893                 until it's done, and then try again.
 894         -------------------------------------------------------------------- */
 895         if (ch->asyncflags & ASYNC_CLOSING) {
 896                 interruptible_sleep_on(&ch->close_wait);
 897
 898                 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
 899                         return -EAGAIN;
 900                 else
 901                         return -ERESTARTSYS;
 902         }
 903
 904         if (filp->f_flags & O_NONBLOCK)  {
 905                 /* -----------------------------------------------------------------
 906                  If non-blocking mode is set, then make the check up front
 907                  and then exit.
 908                 -------------------------------------------------------------------- */
 909                 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
 910                 return 0;
 911         }
 912         if (tty->termios->c_cflag & CLOCAL)
 913                 do_clocal = 1;
 914         /* Block waiting for the carrier detect and the line to become free */
 915
 916         retval = 0;
 917         add_wait_queue(&ch->open_wait, &wait);
 918
 919         spin_lock_irqsave(&epca_lock, flags);
 920         /* We dec count so that pc_close will know when to free things */
 921         if (!tty_hung_up_p(filp))
 922                 ch->count--;
 923         ch->blocked_open++;
 924         while(1)
 925         { /* Begin forever while  */
 926                 set_current_state(TASK_INTERRUPTIBLE);
 927                 if (tty_hung_up_p(filp) ||
 928                     !(ch->asyncflags & ASYNC_INITIALIZED))
 929                 {
 930                         if (ch->asyncflags & ASYNC_HUP_NOTIFY)
 931                                 retval = -EAGAIN;
 932                         else
 933                                 retval = -ERESTARTSYS;
 934                         break;
 935                 }
 936                 if (!(ch->asyncflags & ASYNC_CLOSING) &&
 937                           (do_clocal || (ch->imodem & ch->dcd)))
 938                         break;
 939                 if (signal_pending(current)) {
 940                         retval = -ERESTARTSYS;
 941                         break;
 942                 }
 943                 spin_unlock_irqrestore(&epca_lock, flags);
 944                 /* ---------------------------------------------------------------
 945                         Allow someone else to be scheduled.  We will occasionally go
 946                         through this loop until one of the above conditions change.
 947                         The below schedule call will allow other processes to enter and
 948                         prevent this loop from hogging the cpu.
 949                 ------------------------------------------------------------------ */
 950                 schedule();
 951                 spin_lock_irqsave(&epca_lock, flags);
 952
 953         } /* End forever while  */
 954
 955         current->state = TASK_RUNNING;
 956         remove_wait_queue(&ch->open_wait, &wait);
 957         if (!tty_hung_up_p(filp))
 958                 ch->count++;
 959         ch->blocked_open--;
 960
 961         spin_unlock_irqrestore(&epca_lock, flags);
 962
 963         if (retval)
 964                 return retval;
 965
 966         ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
 967         return 0;
 968 } /* End block_til_ready */
 969
 970 /* ------------------ Begin pc_open  ---------------------- */
 971
 972 static int pc_open(struct tty_struct *tty, struct file * filp)
 973 { /* Begin pc_open */
 974
 975         struct channel *ch;
 976         unsigned long flags;
 977         int line, retval, boardnum;
 978         struct board_chan __iomem *bc;
 979         unsigned int head;
 980
 981         line = tty->index;
 982         if (line < 0 || line >= nbdevs)
 983                 return -ENODEV;
 984
 985         ch = &digi_channels[line];
 986         boardnum = ch->boardnum;
 987
 988         /* Check status of board configured in system.  */
 989
 990         /* -----------------------------------------------------------------
 991                 I check to see if the epca_setup routine detected an user error.
 992                 It might be better to put this in pc_init, but for the moment it
 993                 goes here.
 994         ---------------------------------------------------------------------- */
 995
 996         if (invalid_lilo_config) {
 997                 if (setup_error_code & INVALID_BOARD_TYPE)
 998                         printk(KERN_ERR "epca: pc_open: Invalid board type specified in kernel options.\n");
 999                 if (setup_error_code & INVALID_NUM_PORTS)
1000                         printk(KERN_ERR "epca: pc_open: Invalid number of ports specified in kernel options.\n");
1001                 if (setup_error_code & INVALID_MEM_BASE)
1002                         printk(KERN_ERR "epca: pc_open: Invalid board memory address specified in kernel options.\n");
1003                 if (setup_error_code & INVALID_PORT_BASE)
1004                         printk(KERN_ERR "epca; pc_open: Invalid board port address specified in kernel options.\n");
1005                 if (setup_error_code & INVALID_BOARD_STATUS)
1006                         printk(KERN_ERR "epca: pc_open: Invalid board status specified in kernel options.\n");
1007                 if (setup_error_code & INVALID_ALTPIN)
1008                         printk(KERN_ERR "epca: pc_open: Invalid board altpin specified in kernel options;\n");
1009                 tty->driver_data = NULL;   /* Mark this device as 'down' */
1010                 return -ENODEV;
1011         }
1012         if (boardnum >= num_cards || boards[boardnum].status == DISABLED)  {
1013                 tty->driver_data = NULL;   /* Mark this device as 'down' */
1014                 return(-ENODEV);
1015         }
1016
1017         if ((bc = ch->brdchan) == 0) {
1018                 tty->driver_data = NULL;
1019                 return -ENODEV;
1020         }
1021
1022         spin_lock_irqsave(&epca_lock, flags);
1023         /* ------------------------------------------------------------------
1024                 Every time a channel is opened, increment a counter.  This is
1025                 necessary because we do not wish to flush and shutdown the channel
1026                 until the last app holding the channel open, closes it.
1027         --------------------------------------------------------------------- */
1028         ch->count++;
1029         /* ----------------------------------------------------------------
1030                 Set a kernel structures pointer to our local channel
1031                 structure.  This way we can get to it when passed only
1032                 a tty struct.
1033         ------------------------------------------------------------------ */
1034         tty->driver_data = ch;
1035         /* ----------------------------------------------------------------
1036                 If this is the first time the channel has been opened, initialize
1037                 the tty->termios struct otherwise let pc_close handle it.
1038         -------------------------------------------------------------------- */
1039         globalwinon(ch);
1040         ch->statusflags = 0;
1041
1042         /* Save boards current modem status */
1043         ch->imodem = readb(&bc->mstat);
1044
1045         /* ----------------------------------------------------------------
1046            Set receive head and tail ptrs to each other.  This indicates
1047            no data available to read.
1048         ----------------------------------------------------------------- */
1049         head = readw(&bc->rin);
1050         writew(head, &bc->rout);
1051
1052         /* Set the channels associated tty structure */
1053         ch->tty = tty;
1054
1055         /* -----------------------------------------------------------------
1056                 The below routine generally sets up parity, baud, flow control
1057                 issues, etc.... It effect both control flags and input flags.
1058         -------------------------------------------------------------------- */
1059         epcaparam(tty,ch);
1060         ch->asyncflags |= ASYNC_INITIALIZED;
1061         memoff(ch);
1062         spin_unlock_irqrestore(&epca_lock, flags);
1063
1064         retval = block_til_ready(tty, filp, ch);
1065         if (retval)
1066                 return retval;
1067         /* -------------------------------------------------------------
1068                 Set this again in case a hangup set it to zero while this
1069                 open() was waiting for the line...
1070         --------------------------------------------------------------- */
1071         spin_lock_irqsave(&epca_lock, flags);
1072         ch->tty = tty;
1073         globalwinon(ch);
1074         /* Enable Digi Data events */
1075         writeb(1, &bc->idata);
1076         memoff(ch);
1077         spin_unlock_irqrestore(&epca_lock, flags);
1078         return 0;
1079 } /* End pc_open */
1080
1081 static int __init epca_module_init(void)
1082 { /* Begin init_module */
1083         return pc_init();
1084 }
1085
1086 module_init(epca_module_init);
1087
1088 static struct pci_driver epca_driver;
1089
1090 static void __exit epca_module_exit(void)
1091 {
1092         int               count, crd;
1093         struct board_info *bd;
1094         struct channel    *ch;
1095
1096         del_timer_sync(&epca_timer);
1097
1098         if ((tty_unregister_driver(pc_driver)) ||
1099             (tty_unregister_driver(pc_info)))
1100         {
1101                 printk(KERN_WARNING "epca: cleanup_module failed to un-register tty driver\n");
1102                 return;
1103         }
1104         put_tty_driver(pc_driver);
1105         put_tty_driver(pc_info);
1106
1107         for (crd = 0; crd < num_cards; crd++)  { /* Begin for each card */
1108                 bd = &boards[crd];
1109                 if (!bd)
1110                 { /* Begin sanity check */
1111                         printk(KERN_ERR "<Error> - Digi : cleanup_module failed\n");
1112                         return;
1113                 } /* End sanity check */
1114                 ch = card_ptr[crd];
1115                 for (count = 0; count < bd->numports; count++, ch++)
1116                 { /* Begin for each port */
1117                         if (ch) {
1118                                 if (ch->tty)
1119                                         tty_hangup(ch->tty);
1120                                 kfree(ch->tmp_buf);
1121                         }
1122                 } /* End for each port */
1123         } /* End for each card */
1124         pci_unregister_driver (&epca_driver);
1125 }
1126
1127 module_exit(epca_module_exit);
1128
1129 static struct tty_operations pc_ops = {
1130         .open = pc_open,
1131         .close = pc_close,
1132         .write = pc_write,
1133         .write_room = pc_write_room,
1134         .flush_buffer = pc_flush_buffer,
1135         .chars_in_buffer = pc_chars_in_buffer,
1136         .flush_chars = pc_flush_chars,
1137         .put_char = pc_put_char,
1138         .ioctl = pc_ioctl,
1139         .set_termios = pc_set_termios,
1140         .stop = pc_stop,
1141         .start = pc_start,
1142         .throttle = pc_throttle,
1143         .unthrottle = pc_unthrottle,
1144         .hangup = pc_hangup,
1145 };
1146
1147 static int info_open(struct tty_struct *tty, struct file * filp)
1148 {
1149         return 0;
1150 }
1151
1152 static struct tty_operations info_ops = {
1153         .open = info_open,
1154         .ioctl = info_ioctl,
1155 };
1156
1157 /* ------------------ Begin pc_init  ---------------------- */
1158
1159 static int __init pc_init(void)
1160 { /* Begin pc_init */
1161         int crd;
1162         struct board_info *bd;
1163         unsigned char board_id = 0;
1164
1165         int pci_boards_found, pci_count;
1166
1167         pci_count = 0;
1168
1169         pc_driver = alloc_tty_driver(MAX_ALLOC);
1170         if (!pc_driver)
1171                 return -ENOMEM;
1172
1173         pc_info = alloc_tty_driver(MAX_ALLOC);
1174         if (!pc_info) {
1175                 put_tty_driver(pc_driver);
1176                 return -ENOMEM;
1177         }
1178
1179         /* -----------------------------------------------------------------------
1180                 If epca_setup has not been ran by LILO set num_cards to defaults; copy
1181                 board structure defined by digiConfig into drivers board structure.
1182                 Note : If LILO has ran epca_setup then epca_setup will handle defining
1183                 num_cards as well as copying the data into the board structure.
1184         -------------------------------------------------------------------------- */
1185         if (!liloconfig) { /* Begin driver has been configured via. epcaconfig */
1186
1187                 nbdevs = NBDEVS;
1188                 num_cards = NUMCARDS;
1189                 memcpy((void *)&boards, (void *)&static_boards,
1190                        (sizeof(struct board_info) * NUMCARDS));
1191         } /* End driver has been configured via. epcaconfig */
1192
1193         /* -----------------------------------------------------------------
1194                 Note : If lilo was used to configure the driver and the
1195                 ignore epcaconfig option was choosen (digiepca=2) then
1196                 nbdevs and num_cards will equal 0 at this point.  This is
1197                 okay; PCI cards will still be picked up if detected.
1198         --------------------------------------------------------------------- */
1199
1200         /*  -----------------------------------------------------------
1201                 Set up interrupt, we will worry about memory allocation in
1202                 post_fep_init.
1203         --------------------------------------------------------------- */
1204
1205
1206         printk(KERN_INFO "DIGI epca driver version %s loaded.\n",VERSION);
1207
1208         /* ------------------------------------------------------------------
1209                 NOTE : This code assumes that the number of ports found in
1210                        the boards array is correct.  This could be wrong if
1211                        the card in question is PCI (And therefore has no ports
1212                        entry in the boards structure.)  The rest of the
1213                        information will be valid for PCI because the beginning
1214                        of pc_init scans for PCI and determines i/o and base
1215                        memory addresses.  I am not sure if it is possible to
1216                        read the number of ports supported by the card prior to
1217                        it being booted (Since that is the state it is in when
1218                        pc_init is run).  Because it is not possible to query the
1219                        number of supported ports until after the card has booted;
1220                        we are required to calculate the card_ptrs as the card is
1221                        is initialized (Inside post_fep_init).  The negative thing
1222                        about this approach is that digiDload's call to GET_INFO
1223                        will have a bad port value.  (Since this is called prior
1224                        to post_fep_init.)
1225
1226         --------------------------------------------------------------------- */
1227
1228         pci_boards_found = 0;
1229         if(num_cards < MAXBOARDS)
1230                 pci_boards_found += init_PCI();
1231         num_cards += pci_boards_found;
1232
1233         pc_driver->owner = THIS_MODULE;
1234         pc_driver->name = "ttyD";
1235         pc_driver->devfs_name = "tts/D";
1236         pc_driver->major = DIGI_MAJOR;
1237         pc_driver->minor_start = 0;
1238         pc_driver->type = TTY_DRIVER_TYPE_SERIAL;
1239         pc_driver->subtype = SERIAL_TYPE_NORMAL;
1240         pc_driver->init_termios = tty_std_termios;
1241         pc_driver->init_termios.c_iflag = 0;
1242         pc_driver->init_termios.c_oflag = 0;
1243         pc_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
1244         pc_driver->init_termios.c_lflag = 0;
1245         pc_driver->flags = TTY_DRIVER_REAL_RAW;
1246         tty_set_operations(pc_driver, &pc_ops);
1247
1248         pc_info->owner = THIS_MODULE;
1249         pc_info->name = "digi_ctl";
1250         pc_info->major = DIGIINFOMAJOR;
1251         pc_info->minor_start = 0;
1252         pc_info->type = TTY_DRIVER_TYPE_SERIAL;
1253         pc_info->subtype = SERIAL_TYPE_INFO;
1254         pc_info->init_termios = tty_std_termios;
1255         pc_info->init_termios.c_iflag = 0;
1256         pc_info->init_termios.c_oflag = 0;
1257         pc_info->init_termios.c_lflag = 0;
1258         pc_info->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
1259         pc_info->flags = TTY_DRIVER_REAL_RAW;
1260         tty_set_operations(pc_info, &info_ops);
1261
1262
1263         for (crd = 0; crd < num_cards; crd++)
1264         { /* Begin for each card */
1265
1266                 /*  ------------------------------------------------------------------
1267                         This is where the appropriate memory handlers for the hardware is
1268                         set.  Everything at runtime blindly jumps through these vectors.
1269                 ---------------------------------------------------------------------- */
1270
1271                 /* defined in epcaconfig.h */
1272                 bd = &boards[crd];
1273
1274                 switch (bd->type)
1275                 { /* Begin switch on bd->type {board type} */
1276                         case PCXEM:
1277                         case EISAXEM:
1278                                 bd->memwinon     = pcxem_memwinon ;
1279                                 bd->memwinoff    = pcxem_memwinoff ;
1280                                 bd->globalwinon  = pcxem_globalwinon ;
1281                                 bd->txwinon      = pcxem_txwinon ;
1282                                 bd->rxwinon      = pcxem_rxwinon ;
1283                                 bd->memoff       = pcxem_memoff ;
1284                                 bd->assertgwinon = dummy_assertgwinon;
1285                                 bd->assertmemoff = dummy_assertmemoff;
1286                                 break;
1287
1288                         case PCIXEM:
1289                         case PCIXRJ:
1290                         case PCIXR:
1291                                 bd->memwinon     = dummy_memwinon;
1292                                 bd->memwinoff    = dummy_memwinoff;
1293                                 bd->globalwinon  = dummy_globalwinon;
1294                                 bd->txwinon      = dummy_txwinon;
1295                                 bd->rxwinon      = dummy_rxwinon;
1296                                 bd->memoff       = dummy_memoff;
1297                                 bd->assertgwinon = dummy_assertgwinon;
1298                                 bd->assertmemoff = dummy_assertmemoff;
1299                                 break;
1300
1301                         case PCXE:
1302                         case PCXEVE:
1303
1304                                 bd->memwinon     = pcxe_memwinon;
1305                                 bd->memwinoff    = pcxe_memwinoff;
1306                                 bd->globalwinon  = pcxe_globalwinon;
1307                                 bd->txwinon      = pcxe_txwinon;
1308                                 bd->rxwinon      = pcxe_rxwinon;
1309                                 bd->memoff       = pcxe_memoff;
1310                                 bd->assertgwinon = dummy_assertgwinon;
1311                                 bd->assertmemoff = dummy_assertmemoff;
1312                                 break;
1313
1314                         case PCXI:
1315                         case PC64XE:
1316
1317                                 bd->memwinon     = pcxi_memwinon;
1318                                 bd->memwinoff    = pcxi_memwinoff;
1319                                 bd->globalwinon  = pcxi_globalwinon;
1320                                 bd->txwinon      = pcxi_txwinon;
1321                                 bd->rxwinon      = pcxi_rxwinon;
1322                                 bd->memoff       = pcxi_memoff;
1323                                 bd->assertgwinon = pcxi_assertgwinon;
1324                                 bd->assertmemoff = pcxi_assertmemoff;
1325                                 break;
1326
1327                         default:
1328                                 break;
1329
1330                 } /* End switch on bd->type */
1331
1332                 /* ---------------------------------------------------------------
1333                         Some cards need a memory segment to be defined for use in
1334                         transmit and receive windowing operations.  These boards
1335                         are listed in the below switch.  In the case of the XI the
1336                         amount of memory on the board is variable so the memory_seg
1337                         is also variable.  This code determines what they segment
1338                         should be.
1339                 ----------------------------------------------------------------- */
1340
1341                 switch (bd->type)
1342                 { /* Begin switch on bd->type {board type} */
1343
1344                         case PCXE:
1345                         case PCXEVE:
1346                         case PC64XE:
1347                                 bd->memory_seg = 0xf000;
1348                         break;
1349
1350                         case PCXI:
1351                                 board_id = inb((int)bd->port);
1352                                 if ((board_id & 0x1) == 0x1)
1353                                 { /* Begin it's an XI card */
1354
1355                                         /* Is it a 64K board */
1356                                         if ((board_id & 0x30) == 0)
1357                                                 bd->memory_seg = 0xf000;
1358
1359                                         /* Is it a 128K board */
1360                                         if ((board_id & 0x30) == 0x10)
1361                                                 bd->memory_seg = 0xe000;
1362
1363                                         /* Is is a 256K board */
1364                                         if ((board_id & 0x30) == 0x20)
1365                                                 bd->memory_seg = 0xc000;
1366
1367                                         /* Is it a 512K board */
1368                                         if ((board_id & 0x30) == 0x30)
1369                                                 bd->memory_seg = 0x8000;
1370
1371                                 } else printk(KERN_ERR "epca: Board at 0x%x doesn't appear to be an XI\n",(int)bd->port);
1372                         break;
1373
1374                 } /* End switch on bd->type */
1375
1376         } /* End for each card */
1377
1378         if (tty_register_driver(pc_driver))
1379                 panic("Couldn't register Digi PC/ driver");
1380
1381         if (tty_register_driver(pc_info))
1382                 panic("Couldn't register Digi PC/ info ");
1383
1384         /* -------------------------------------------------------------------
1385            Start up the poller to check for events on all enabled boards
1386         ---------------------------------------------------------------------- */
1387
1388         init_timer(&epca_timer);
1389         epca_timer.function = epcapoll;
1390         mod_timer(&epca_timer, jiffies + HZ/25);
1391         return 0;
1392
1393 } /* End pc_init */
1394
1395 /* ------------------ Begin post_fep_init  ---------------------- */
1396
1397 static void post_fep_init(unsigned int crd)
1398 { /* Begin post_fep_init */
1399
1400         int i;
1401         void __iomem *memaddr;
1402         struct global_data __iomem *gd;
1403         struct board_info *bd;
1404         struct board_chan __iomem *bc;
1405         struct channel *ch;
1406         int shrinkmem = 0, lowwater ;
1407
1408         /*  -------------------------------------------------------------
1409                 This call is made by the user via. the ioctl call DIGI_INIT.
1410                 It is responsible for setting up all the card specific stuff.
1411         ---------------------------------------------------------------- */
1412         bd = &boards[crd];
1413
1414         /* -----------------------------------------------------------------
1415                 If this is a PCI board, get the port info.  Remember PCI cards
1416                 do not have entries into the epcaconfig.h file, so we can't get
1417                 the number of ports from it.  Unfortunetly, this means that anyone
1418                 doing a DIGI_GETINFO before the board has booted will get an invalid
1419                 number of ports returned (It should return 0).  Calls to DIGI_GETINFO
1420                 after DIGI_INIT has been called will return the proper values.
1421         ------------------------------------------------------------------- */
1422
1423         if (bd->type >= PCIXEM) { /* Begin get PCI number of ports */
1424                 /* --------------------------------------------------------------------
1425                         Below we use XEMPORTS as a memory offset regardless of which PCI
1426                         card it is.  This is because all of the supported PCI cards have
1427                         the same memory offset for the channel data.  This will have to be
1428                         changed if we ever develop a PCI/XE card.  NOTE : The FEP manual
1429                         states that the port offset is 0xC22 as opposed to 0xC02.  This is
1430                         only true for PC/XE, and PC/XI cards; not for the XEM, or CX series.
1431                         On the PCI cards the number of ports is determined by reading a
1432                         ID PROM located in the box attached to the card.  The card can then
1433                         determine the index the id to determine the number of ports available.
1434                         (FYI - The id should be located at 0x1ac (And may use up to 4 bytes
1435                         if the box in question is a XEM or CX)).
1436                 ------------------------------------------------------------------------ */
1437                 /* PCI cards are already remapped at this point ISA are not */
1438                 bd->numports = readw(bd->re_map_membase + XEMPORTS);
1439                 epcaassert(bd->numports <= 64,"PCI returned a invalid number of ports");
1440                 nbdevs += (bd->numports);
1441         } else {
1442                 /* Fix up the mappings for ISA/EISA etc */
1443                 /* FIXME: 64K - can we be smarter ? */
1444                 bd->re_map_membase = ioremap(bd->membase, 0x10000);
1445         }
1446
1447         if (crd != 0)
1448                 card_ptr[crd] = card_ptr[crd-1] + boards[crd-1].numports;
1449         else
1450                 card_ptr[crd] = &digi_channels[crd]; /* <- For card 0 only */
1451
1452         ch = card_ptr[crd];
1453         epcaassert(ch <= &digi_channels[nbdevs - 1], "ch out of range");
1454
1455         memaddr = bd->re_map_membase;
1456
1457         /* -----------------------------------------------------------------
1458                 The below assignment will set bc to point at the BEGINING of
1459                 the cards channel structures.  For 1 card there will be between
1460                 8 and 64 of these structures.
1461         -------------------------------------------------------------------- */
1462
1463         bc = memaddr + CHANSTRUCT;
1464
1465         /* -------------------------------------------------------------------
1466                 The below assignment will set gd to point at the BEGINING of
1467                 global memory address 0xc00.  The first data in that global
1468                 memory actually starts at address 0xc1a.  The command in
1469                 pointer begins at 0xd10.
1470         ---------------------------------------------------------------------- */
1471
1472         gd = memaddr + GLOBAL;
1473
1474         /* --------------------------------------------------------------------
1475                 XEPORTS (address 0xc22) points at the number of channels the
1476                 card supports. (For 64XE, XI, XEM, and XR use 0xc02)
1477         ----------------------------------------------------------------------- */
1478
1479         if ((bd->type == PCXEVE || bd->type == PCXE) && (readw(memaddr + XEPORTS) < 3))
1480                 shrinkmem = 1;
1481         if (bd->type < PCIXEM)
1482                 if (!request_region((int)bd->port, 4, board_desc[bd->type]))
1483                         return;
1484         memwinon(bd, 0);
1485
1486         /*  --------------------------------------------------------------------
1487                 Remember ch is the main drivers channels structure, while bc is
1488            the cards channel structure.
1489         ------------------------------------------------------------------------ */
1490
1491         /* For every port on the card do ..... */
1492
1493         for (i = 0; i < bd->numports; i++, ch++, bc++)  { /* Begin for each port */
1494                 unsigned long flags;
1495                 u16 tseg, rseg;
1496
1497                 ch->brdchan        = bc;
1498                 ch->mailbox        = gd;
1499                 INIT_WORK(&ch->tqueue, do_softint, ch);
1500                 ch->board          = &boards[crd];
1501
1502                 spin_lock_irqsave(&epca_lock, flags);
1503                 switch (bd->type) {
1504                         /* ----------------------------------------------------------------
1505                                 Since some of the boards use different bitmaps for their
1506                                 control signals we cannot hard code these values and retain
1507                                 portability.  We virtualize this data here.
1508                         ------------------------------------------------------------------- */
1509                         case EISAXEM:
1510                         case PCXEM:
1511                         case PCIXEM:
1512                         case PCIXRJ:
1513                         case PCIXR:
1514                                 ch->m_rts = 0x02 ;
1515                                 ch->m_dcd = 0x80 ;
1516                                 ch->m_dsr = 0x20 ;
1517                                 ch->m_cts = 0x10 ;
1518                                 ch->m_ri  = 0x40 ;
1519                                 ch->m_dtr = 0x01 ;
1520                                 break;
1521
1522                         case PCXE:
1523                         case PCXEVE:
1524                         case PCXI:
1525                         case PC64XE:
1526                                 ch->m_rts = 0x02 ;
1527                                 ch->m_dcd = 0x08 ;
1528                                 ch->m_dsr = 0x10 ;
1529                                 ch->m_cts = 0x20 ;
1530                                 ch->m_ri  = 0x40 ;
1531                                 ch->m_dtr = 0x80 ;
1532                                 break;
1533
1534                 } /* End switch bd->type */
1535
1536                 if (boards[crd].altpin) {
1537                         ch->dsr = ch->m_dcd;
1538                         ch->dcd = ch->m_dsr;
1539                         ch->digiext.digi_flags |= DIGI_ALTPIN;
1540                 }
1541                 else {
1542                         ch->dcd = ch->m_dcd;
1543                         ch->dsr = ch->m_dsr;
1544                 }
1545
1546                 ch->boardnum   = crd;
1547                 ch->channelnum = i;
1548                 ch->magic      = EPCA_MAGIC;
1549                 ch->tty        = NULL;
1550
1551                 if (shrinkmem) {
1552                         fepcmd(ch, SETBUFFER, 32, 0, 0, 0);
1553                         shrinkmem = 0;
1554                 }
1555
1556                 tseg = readw(&bc->tseg);
1557                 rseg = readw(&bc->rseg);
1558
1559                 switch (bd->type) {
1560
1561                         case PCIXEM:
1562                         case PCIXRJ:
1563                         case PCIXR:
1564                                 /* Cover all the 2MEG cards */
1565                                 ch->txptr = memaddr + ((tseg << 4) & 0x1fffff);
1566                                 ch->rxptr = memaddr + ((rseg << 4) & 0x1fffff);
1567                                 ch->txwin = FEPWIN | (tseg >> 11);
1568                                 ch->rxwin = FEPWIN | (rseg >> 11);
1569                                 break;
1570
1571                         case PCXEM:
1572                         case EISAXEM:
1573                                 /* Cover all the 32K windowed cards */
1574                                 /* Mask equal to window size - 1 */
1575                                 ch->txptr = memaddr + ((tseg << 4) & 0x7fff);
1576                                 ch->rxptr = memaddr + ((rseg << 4) & 0x7fff);
1577                                 ch->txwin = FEPWIN | (tseg >> 11);
1578                                 ch->rxwin = FEPWIN | (rseg >> 11);
1579                                 break;
1580
1581                         case PCXEVE:
1582                         case PCXE:
1583                                 ch->txptr = memaddr + (((tseg - bd->memory_seg) << 4) & 0x1fff);
1584                                 ch->txwin = FEPWIN | ((tseg - bd->memory_seg) >> 9);
1585                                 ch->rxptr = memaddr + (((rseg - bd->memory_seg) << 4) & 0x1fff);
1586                                 ch->rxwin = FEPWIN | ((rseg - bd->memory_seg) >>9 );
1587                                 break;
1588
1589                         case PCXI:
1590                         case PC64XE:
1591                                 ch->txptr = memaddr + ((tseg - bd->memory_seg) << 4);
1592                                 ch->rxptr = memaddr + ((rseg - bd->memory_seg) << 4);
1593                                 ch->txwin = ch->rxwin = 0;
1594                                 break;
1595
1596                 } /* End switch bd->type */
1597
1598                 ch->txbufhead = 0;
1599                 ch->txbufsize = readw(&bc->tmax) + 1;
1600
1601                 ch->rxbufhead = 0;
1602                 ch->rxbufsize = readw(&bc->rmax) + 1;
1603
1604                 lowwater = ch->txbufsize >= 2000 ? 1024 : (ch->txbufsize / 2);
1605
1606                 /* Set transmitter low water mark */
1607                 fepcmd(ch, STXLWATER, lowwater, 0, 10, 0);
1608
1609                 /* Set receiver low water mark */
1610
1611                 fepcmd(ch, SRXLWATER, (ch->rxbufsize / 4), 0, 10, 0);
1612
1613                 /* Set receiver high water mark */
1614
1615                 fepcmd(ch, SRXHWATER, (3 * ch->rxbufsize / 4), 0, 10, 0);
1616
1617                 writew(100, &bc->edelay);
1618                 writeb(1, &bc->idata);
1619
1620                 ch->startc  = readb(&bc->startc);
1621                 ch->stopc   = readb(&bc->stopc);
1622                 ch->startca = readb(&bc->startca);
1623                 ch->stopca  = readb(&bc->stopca);
1624
1625                 ch->fepcflag = 0;
1626                 ch->fepiflag = 0;
1627                 ch->fepoflag = 0;
1628                 ch->fepstartc = 0;
1629                 ch->fepstopc = 0;
1630                 ch->fepstartca = 0;
1631                 ch->fepstopca = 0;
1632
1633                 ch->close_delay = 50;
1634                 ch->count = 0;
1635                 ch->blocked_open = 0;
1636                 init_waitqueue_head(&ch->open_wait);
1637                 init_waitqueue_head(&ch->close_wait);
1638
1639                 spin_unlock_irqrestore(&epca_lock, flags);
1640
1641                 ch->tmp_buf = kmalloc(ch->txbufsize,GFP_KERNEL);
1642                 if (!ch->tmp_buf) {
1643                         printk(KERN_ERR "POST FEP INIT : kmalloc failed for port 0x%x\n",i);
1644                         release_region((int)bd->port, 4);
1645                         while(i-- > 0)
1646                                 kfree((ch--)->tmp_buf);
1647                         return;
1648                 } else
1649                         memset((void *)ch->tmp_buf,0,ch->txbufsize);
1650         } /* End for each port */
1651
1652         printk(KERN_INFO
1653                 "Digi PC/Xx Driver V%s:  %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n",
1654                 VERSION, board_desc[bd->type], (long)bd->port, (long)bd->membase, bd->numports);
1655         memwinoff(bd, 0);
1656
1657 } /* End post_fep_init */
1658
1659 /* --------------------- Begin epcapoll  ------------------------ */
1660
1661 static void epcapoll(unsigned long ignored)
1662 { /* Begin epcapoll */
1663
1664         unsigned long flags;
1665         int crd;
1666         volatile unsigned int head, tail;
1667         struct channel *ch;
1668         struct board_info *bd;
1669
1670         /* -------------------------------------------------------------------
1671                 This routine is called upon every timer interrupt.  Even though
1672                 the Digi series cards are capable of generating interrupts this
1673                 method of non-looping polling is more efficient.  This routine
1674                 checks for card generated events (Such as receive data, are transmit
1675                 buffer empty) and acts on those events.
1676         ----------------------------------------------------------------------- */
1677
1678         for (crd = 0; crd < num_cards; crd++)
1679         { /* Begin for each card */
1680
1681                 bd = &boards[crd];
1682                 ch = card_ptr[crd];
1683
1684                 if ((bd->status == DISABLED) || digi_poller_inhibited)
1685                         continue; /* Begin loop next interation */
1686
1687                 /* -----------------------------------------------------------
1688                         assertmemoff is not needed here; indeed it is an empty subroutine.
1689                         It is being kept because future boards may need this as well as
1690                         some legacy boards.
1691                 ---------------------------------------------------------------- */
1692
1693                 spin_lock_irqsave(&epca_lock, flags);
1694
1695                 assertmemoff(ch);
1696
1697                 globalwinon(ch);
1698
1699                 /* ---------------------------------------------------------------
1700                         In this case head and tail actually refer to the event queue not
1701                         the transmit or receive queue.
1702                 ------------------------------------------------------------------- */
1703
1704                 head = readw(&ch->mailbox->ein);
1705                 tail = readw(&ch->mailbox->eout);
1706
1707                 /* If head isn't equal to tail we have an event */
1708
1709                 if (head != tail)
1710                         doevent(crd);
1711                 memoff(ch);
1712
1713                 spin_unlock_irqrestore(&epca_lock, flags);
1714
1715         } /* End for each card */
1716         mod_timer(&epca_timer, jiffies + (HZ / 25));
1717 } /* End epcapoll */
1718
1719 /* --------------------- Begin doevent  ------------------------ */
1720
1721 static void doevent(int crd)
1722 { /* Begin doevent */
1723
1724         void __iomem *eventbuf;
1725         struct channel *ch, *chan0;
1726         static struct tty_struct *tty;
1727         struct board_info *bd;
1728         struct board_chan __iomem *bc;
1729         unsigned int tail, head;
1730         int event, channel;
1731         int mstat, lstat;
1732
1733         /* -------------------------------------------------------------------
1734                 This subroutine is called by epcapoll when an event is detected
1735                 in the event queue.  This routine responds to those events.
1736         --------------------------------------------------------------------- */
1737         bd = &boards[crd];
1738
1739         chan0 = card_ptr[crd];
1740         epcaassert(chan0 <= &digi_channels[nbdevs - 1], "ch out of range");
1741         assertgwinon(chan0);
1742         while ((tail = readw(&chan0->mailbox->eout)) != (head = readw(&chan0->mailbox->ein)))
1743         { /* Begin while something in event queue */
1744                 assertgwinon(chan0);
1745                 eventbuf = bd->re_map_membase + tail + ISTART;
1746                 /* Get the channel the event occurred on */
1747                 channel = readb(eventbuf);
1748                 /* Get the actual event code that occurred */
1749                 event = readb(eventbuf + 1);
1750                 /*  ----------------------------------------------------------------
1751                         The two assignments below get the current modem status (mstat)
1752                         and the previous modem status (lstat).  These are useful becuase
1753                         an event could signal a change in modem signals itself.
1754                 ------------------------------------------------------------------- */
1755                 mstat = readb(eventbuf + 2);
1756                 lstat = readb(eventbuf + 3);
1757
1758                 ch = chan0 + channel;
1759                 if ((unsigned)channel >= bd->numports || !ch)  {
1760                         if (channel >= bd->numports)
1761                                 ch = chan0;
1762                         bc = ch->brdchan;
1763                         goto next;
1764                 }
1765
1766                 if ((bc = ch->brdchan) == NULL)
1767                         goto next;
1768
1769                 if (event & DATA_IND)  { /* Begin DATA_IND */
1770                         receive_data(ch);
1771                         assertgwinon(ch);
1772                 } /* End DATA_IND */
1773                 /* else *//* Fix for DCD transition missed bug */
1774                 if (event & MODEMCHG_IND)  { /* Begin MODEMCHG_IND */
1775                         /* A modem signal change has been indicated */
1776                         ch->imodem = mstat;
1777                         if (ch->asyncflags & ASYNC_CHECK_CD)  {
1778                                 if (mstat & ch->dcd)  /* We are now receiving dcd */
1779                                         wake_up_interruptible(&ch->open_wait);
1780                                 else
1781                                         pc_sched_event(ch, EPCA_EVENT_HANGUP); /* No dcd; hangup */
1782                         }
1783                 } /* End MODEMCHG_IND */
1784                 tty = ch->tty;
1785                 if (tty)  { /* Begin if valid tty */
1786                         if (event & BREAK_IND)  { /* Begin if BREAK_IND */
1787                                 /* A break has been indicated */
1788                                 tty_insert_flip_char(tty, 0, TTY_BREAK);
1789                                 tty_schedule_flip(tty);
1790                         } else if (event & LOWTX_IND)  { /* Begin LOWTX_IND */
1791                                 if (ch->statusflags & LOWWAIT)
1792                                 { /* Begin if LOWWAIT */
1793                                         ch->statusflags &= ~LOWWAIT;
1794                                         tty_wakeup(tty);
1795                                         wake_up_interruptible(&tty->write_wait);
1796                                 } /* End if LOWWAIT */
1797                         } else if (event & EMPTYTX_IND)  { /* Begin EMPTYTX_IND */
1798                                 /* This event is generated by setup_empty_event */
1799                                 ch->statusflags &= ~TXBUSY;
1800                                 if (ch->statusflags & EMPTYWAIT)  { /* Begin if EMPTYWAIT */
1801                                         ch->statusflags &= ~EMPTYWAIT;
1802                                         tty_wakeup(tty);
1803                                         wake_up_interruptible(&tty->write_wait);
1804                                 } /* End if EMPTYWAIT */
1805                         } /* End EMPTYTX_IND */
1806                 } /* End if valid tty */
1807         next:
1808                 globalwinon(ch);
1809                 BUG_ON(!bc);
1810                 writew(1, &bc->idata);
1811                 writew((tail + 4) & (IMAX - ISTART - 4), &chan0->mailbox->eout);
1812                 globalwinon(chan0);
1813         } /* End while something in event queue */
1814 } /* End doevent */
1815
1816 /* --------------------- Begin fepcmd  ------------------------ */
1817
1818 static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
1819                    int byte2, int ncmds, int bytecmd)
1820 { /* Begin fepcmd */
1821         unchar __iomem *memaddr;
1822         unsigned int head, cmdTail, cmdStart, cmdMax;
1823         long count;
1824         int n;
1825
1826         /* This is the routine in which commands may be passed to the card. */
1827
1828         if (ch->board->status == DISABLED)
1829                 return;
1830         assertgwinon(ch);
1831         /* Remember head (As well as max) is just an offset not a base addr */
1832         head = readw(&ch->mailbox->cin);
1833         /* cmdStart is a base address */
1834         cmdStart = readw(&ch->mailbox->cstart);
1835         /* ------------------------------------------------------------------
1836                 We do the addition below because we do not want a max pointer
1837                 relative to cmdStart.  We want a max pointer that points at the
1838                 physical end of the command queue.
1839         -------------------------------------------------------------------- */
1840         cmdMax = (cmdStart + 4 + readw(&ch->mailbox->cmax));
1841         memaddr = ch->board->re_map_membase;
1842
1843         if (head >= (cmdMax - cmdStart) || (head & 03))  {
1844                 printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n", __LINE__,  cmd, head);
1845                 printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n", __LINE__,  cmdMax, cmdStart);
1846                 return;
1847         }
1848         if (bytecmd)  {
1849                 writeb(cmd, memaddr + head + cmdStart + 0);
1850                 writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
1851                 /* Below word_or_byte is bits to set */
1852                 writeb(word_or_byte,  memaddr + head + cmdStart + 2);
1853                 /* Below byte2 is bits to reset */
1854                 writeb(byte2, memaddr + head + cmdStart + 3);
1855         }  else {
1856                 writeb(cmd, memaddr + head + cmdStart + 0);
1857                 writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
1858                 writeb(word_or_byte,  memaddr + head + cmdStart + 2);
1859         }
1860         head = (head + 4) & (cmdMax - cmdStart - 4);
1861         writew(head, &ch->mailbox->cin);
1862         count = FEPTIMEOUT;
1863
1864         for (;;)  { /* Begin forever loop */
1865                 count--;
1866                 if (count == 0)  {
1867                         printk(KERN_ERR "<Error> - Fep not responding in fepcmd()\n");
1868                         return;
1869                 }
1870                 head = readw(&ch->mailbox->cin);
1871                 cmdTail = readw(&ch->mailbox->cout);
1872                 n = (head - cmdTail) & (cmdMax - cmdStart - 4);
1873                 /* ----------------------------------------------------------
1874                         Basically this will break when the FEP acknowledges the
1875                         command by incrementing cmdTail (Making it equal to head).
1876                 ------------------------------------------------------------- */
1877                 if (n <= ncmds * (sizeof(short) * 4))
1878                         break; /* Well nearly forever :-) */
1879         } /* End forever loop */
1880 } /* End fepcmd */
1881
1882 /* ---------------------------------------------------------------------
1883         Digi products use fields in their channels structures that are very
1884         similar to the c_cflag and c_iflag fields typically found in UNIX
1885         termios structures.  The below three routines allow mappings
1886         between these hardware "flags" and their respective Linux flags.
1887 ------------------------------------------------------------------------- */
1888
1889 /* --------------------- Begin termios2digi_h -------------------- */
1890
1891 static unsigned termios2digi_h(struct channel *ch, unsigned cflag)
1892 { /* Begin termios2digi_h */
1893         unsigned res = 0;
1894
1895         if (cflag & CRTSCTS) {
1896                 ch->digiext.digi_flags |= (RTSPACE | CTSPACE);
1897                 res |= ((ch->m_cts) | (ch->m_rts));
1898         }
1899
1900         if (ch->digiext.digi_flags & RTSPACE)
1901                 res |= ch->m_rts;
1902
1903         if (ch->digiext.digi_flags & DTRPACE)
1904                 res |= ch->m_dtr;
1905
1906         if (ch->digiext.digi_flags & CTSPACE)
1907                 res |= ch->m_cts;
1908
1909         if (ch->digiext.digi_flags & DSRPACE)
1910                 res |= ch->dsr;
1911
1912         if (ch->digiext.digi_flags & DCDPACE)
1913                 res |= ch->dcd;
1914
1915         if (res & (ch->m_rts))
1916                 ch->digiext.digi_flags |= RTSPACE;
1917
1918         if (res & (ch->m_cts))
1919                 ch->digiext.digi_flags |= CTSPACE;
1920
1921         return res;
1922
1923 } /* End termios2digi_h */
1924
1925 /* --------------------- Begin termios2digi_i -------------------- */
1926 static unsigned termios2digi_i(struct channel *ch, unsigned iflag)
1927 { /* Begin termios2digi_i */
1928
1929         unsigned res = iflag & (IGNBRK | BRKINT | IGNPAR | PARMRK |
1930                                 INPCK | ISTRIP|IXON|IXANY|IXOFF);
1931         if (ch->digiext.digi_flags & DIGI_AIXON)
1932                 res |= IAIXON;
1933         return res;
1934
1935 } /* End termios2digi_i */
1936
1937 /* --------------------- Begin termios2digi_c -------------------- */
1938
1939 static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
1940 { /* Begin termios2digi_c */
1941
1942         unsigned res = 0;
1943         if (cflag & CBAUDEX) { /* Begin detected CBAUDEX */
1944                 ch->digiext.digi_flags |= DIGI_FAST;
1945                 /* -------------------------------------------------------------
1946                    HUPCL bit is used by FEP to indicate fast baud
1947                    table is to be used.
1948                 ----------------------------------------------------------------- */
1949                 res |= FEP_HUPCL;
1950         } /* End detected CBAUDEX */
1951         else ch->digiext.digi_flags &= ~DIGI_FAST;
1952         /* -------------------------------------------------------------------
1953                 CBAUD has bit position 0x1000 set these days to indicate Linux
1954                 baud rate remap.  Digi hardware can't handle the bit assignment.
1955                 (We use a different bit assignment for high speed.).  Clear this
1956                 bit out.
1957         ---------------------------------------------------------------------- */
1958         res |= cflag & ((CBAUD ^ CBAUDEX) | PARODD | PARENB | CSTOPB | CSIZE);
1959         /* -------------------------------------------------------------
1960                 This gets a little confusing.  The Digi cards have their own
1961                 representation of c_cflags controling baud rate.  For the most
1962                 part this is identical to the Linux implementation.  However;
1963                 Digi supports one rate (76800) that Linux doesn't.  This means
1964                 that the c_cflag entry that would normally mean 76800 for Digi
1965                 actually means 115200 under Linux.  Without the below mapping,
1966                 a stty 115200 would only drive the board at 76800.  Since
1967                 the rate 230400 is also found after 76800, the same problem afflicts
1968                 us when we choose a rate of 230400.  Without the below modificiation
1969                 stty 230400 would actually give us 115200.
1970
1971                 There are two additional differences.  The Linux value for CLOCAL
1972                 (0x800; 0004000) has no meaning to the Digi hardware.  Also in
1973                 later releases of Linux; the CBAUD define has CBAUDEX (0x1000;
1974                 0010000) ored into it (CBAUD = 0x100f as opposed to 0xf). CBAUDEX
1975                 should be checked for a screened out prior to termios2digi_c
1976                 returning.  Since CLOCAL isn't used by the board this can be
1977                 ignored as long as the returned value is used only by Digi hardware.
1978                 ----------------------------------------------------------------- */
1979         if (cflag & CBAUDEX) {
1980                 /* -------------------------------------------------------------
1981                         The below code is trying to guarantee that only baud rates
1982                         115200 and 230400 are remapped.  We use exclusive or because
1983                         the various baud rates share common bit positions and therefore
1984                         can't be tested for easily.
1985                 ----------------------------------------------------------------- */
1986
1987
1988                 if ((!((cflag & 0x7) ^ (B115200 & ~CBAUDEX))) ||
1989                     (!((cflag & 0x7) ^ (B230400 & ~CBAUDEX))))
1990                         res += 1;
1991         }
1992         return res;
1993
1994 } /* End termios2digi_c */
1995
1996 /* --------------------- Begin epcaparam  ----------------------- */
1997
1998 /* Caller must hold the locks */
1999 static void epcaparam(struct tty_struct *tty, struct channel *ch)
2000 { /* Begin epcaparam */
2001
2002         unsigned int cmdHead;
2003         struct termios *ts;
2004         struct board_chan __iomem *bc;
2005         unsigned mval, hflow, cflag, iflag;
2006
2007         bc = ch->brdchan;
2008         epcaassert(bc !=0, "bc out of range");
2009
2010         assertgwinon(ch);
2011         ts = tty->termios;
2012         if ((ts->c_cflag & CBAUD) == 0)  { /* Begin CBAUD detected */
2013                 cmdHead = readw(&bc->rin);
2014                 writew(cmdHead, &bc->rout);
2015                 cmdHead = readw(&bc->tin);
2016                 /* Changing baud in mid-stream transmission can be wonderful */
2017                 /* ---------------------------------------------------------------
2018                         Flush current transmit buffer by setting cmdTail pointer (tout)
2019                         to cmdHead pointer (tin).  Hopefully the transmit buffer is empty.
2020                 ----------------------------------------------------------------- */
2021                 fepcmd(ch, STOUT, (unsigned) cmdHead, 0, 0, 0);
2022                 mval = 0;
2023         } else  { /* Begin CBAUD not detected */
2024                 /* -------------------------------------------------------------------
2025                         c_cflags have changed but that change had nothing to do with BAUD.
2026                         Propagate the change to the card.
2027                 ---------------------------------------------------------------------- */
2028                 cflag = termios2digi_c(ch, ts->c_cflag);
2029                 if (cflag != ch->fepcflag)  {
2030                         ch->fepcflag = cflag;
2031                         /* Set baud rate, char size, stop bits, parity */
2032                         fepcmd(ch, SETCTRLFLAGS, (unsigned) cflag, 0, 0, 0);
2033                 }
2034                 /* ----------------------------------------------------------------
2035                         If the user has not forced CLOCAL and if the device is not a
2036                         CALLOUT device (Which is always CLOCAL) we set flags such that
2037                         the driver will wait on carrier detect.
2038                 ------------------------------------------------------------------- */
2039                 if (ts->c_cflag & CLOCAL)
2040                         ch->asyncflags &= ~ASYNC_CHECK_CD;
2041                 else
2042                         ch->asyncflags |= ASYNC_CHECK_CD;
2043                 mval = ch->m_dtr | ch->m_rts;
2044         } /* End CBAUD not detected */
2045         iflag = termios2digi_i(ch, ts->c_iflag);
2046         /* Check input mode flags */
2047         if (iflag != ch->fepiflag)  {
2048                 ch->fepiflag = iflag;
2049                 /* ---------------------------------------------------------------
2050                         Command sets channels iflag structure on the board. Such things
2051                         as input soft flow control, handling of parity errors, and
2052                         break handling are all set here.
2053                 ------------------------------------------------------------------- */
2054                 /* break handling, parity handling, input stripping, flow control chars */
2055                 fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0);
2056         }
2057         /* ---------------------------------------------------------------
2058                 Set the board mint value for this channel.  This will cause hardware
2059                 events to be generated each time the DCD signal (Described in mint)
2060                 changes.
2061         ------------------------------------------------------------------- */
2062         writeb(ch->dcd, &bc->mint);
2063         if ((ts->c_cflag & CLOCAL) || (ch->digiext.digi_flags & DIGI_FORCEDCD))
2064                 if (ch->digiext.digi_flags & DIGI_FORCEDCD)
2065                         writeb(0, &bc->mint);
2066         ch->imodem = readb(&bc->mstat);
2067         hflow = termios2digi_h(ch, ts->c_cflag);
2068         if (hflow != ch->hflow)  {
2069                 ch->hflow = hflow;
2070                 /* --------------------------------------------------------------
2071                         Hard flow control has been selected but the board is not
2072                         using it.  Activate hard flow control now.
2073                 ----------------------------------------------------------------- */
2074                 fepcmd(ch, SETHFLOW, hflow, 0xff, 0, 1);
2075         }
2076         mval ^= ch->modemfake & (mval ^ ch->modem);
2077
2078         if (ch->omodem ^ mval)  {
2079                 ch->omodem = mval;
2080                 /* --------------------------------------------------------------
2081                         The below command sets the DTR and RTS mstat structure.  If
2082                         hard flow control is NOT active these changes will drive the
2083                         output of the actual DTR and RTS lines.  If hard flow control
2084                         is active, the changes will be saved in the mstat structure and
2085                         only asserted when hard flow control is turned off.
2086                 ----------------------------------------------------------------- */
2087
2088                 /* First reset DTR & RTS; then set them */
2089                 fepcmd(ch, SETMODEM, 0, ((ch->m_dtr)|(ch->m_rts)), 0, 1);
2090                 fepcmd(ch, SETMODEM, mval, 0, 0, 1);
2091         }
2092         if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc)  {
2093                 ch->fepstartc = ch->startc;
2094                 ch->fepstopc = ch->stopc;
2095                 /* ------------------------------------------------------------
2096                         The XON / XOFF characters have changed; propagate these
2097                         changes to the card.
2098                 --------------------------------------------------------------- */
2099                 fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
2100         }
2101         if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca)  {
2102                 ch->fepstartca = ch->startca;
2103                 ch->fepstopca = ch->stopca;
2104                 /* ---------------------------------------------------------------
2105                         Similar to the above, this time the auxilarly XON / XOFF
2106                         characters have changed; propagate these changes to the card.
2107                 ------------------------------------------------------------------ */
2108                 fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
2109         }
2110 } /* End epcaparam */
2111
2112 /* --------------------- Begin receive_data  ----------------------- */
2113 /* Caller holds lock */
2114 static void receive_data(struct channel *ch)
2115 { /* Begin receive_data */
2116
2117         unchar *rptr;
2118         struct termios *ts = NULL;
2119         struct tty_struct *tty;
2120         struct board_chan __iomem *bc;
2121         int dataToRead, wrapgap, bytesAvailable;
2122         unsigned int tail, head;
2123         unsigned int wrapmask;
2124
2125         /* ---------------------------------------------------------------
2126                 This routine is called by doint when a receive data event
2127                 has taken place.
2128         ------------------------------------------------------------------- */
2129
2130         globalwinon(ch);
2131         if (ch->statusflags & RXSTOPPED)
2132                 return;
2133         tty = ch->tty;
2134         if (tty)
2135                 ts = tty->termios;
2136         bc = ch->brdchan;
2137         BUG_ON(!bc);
2138         wrapmask = ch->rxbufsize - 1;
2139
2140         /* ---------------------------------------------------------------------
2141                 Get the head and tail pointers to the receiver queue.  Wrap the
2142                 head pointer if it has reached the end of the buffer.
2143         ------------------------------------------------------------------------ */
2144         head = readw(&bc->rin);
2145         head &= wrapmask;
2146         tail = readw(&bc->rout) & wrapmask;
2147
2148         bytesAvailable = (head - tail) & wrapmask;
2149         if (bytesAvailable == 0)
2150                 return;
2151
2152         /* ------------------------------------------------------------------
2153            If CREAD bit is off or device not open, set TX tail to head
2154         --------------------------------------------------------------------- */
2155
2156         if (!tty || !ts || !(ts->c_cflag & CREAD))  {
2157                 writew(head, &bc->rout);
2158                 return;
2159         }
2160
2161         if (tty_buffer_request_room(tty, bytesAvailable + 1) == 0)
2162                 return;
2163
2164         if (readb(&bc->orun)) {
2165                 writeb(0, &bc->orun);
2166                 printk(KERN_WARNING "epca; overrun! DigiBoard device %s\n",tty->name);
2167                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
2168         }
2169         rxwinon(ch);
2170         while (bytesAvailable > 0)  { /* Begin while there is data on the card */
2171                 wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
2172                 /* ---------------------------------------------------------------
2173                         Even if head has wrapped around only report the amount of
2174                         data to be equal to the size - tail.  Remember memcpy can't
2175                         automaticly wrap around the receive buffer.
2176                 ----------------------------------------------------------------- */
2177                 dataToRead = (wrapgap < bytesAvailable) ? wrapgap : bytesAvailable;
2178                 /* --------------------------------------------------------------
2179                    Make sure we don't overflow the buffer
2180                 ----------------------------------------------------------------- */
2181                 dataToRead = tty_prepare_flip_string(tty, &rptr, dataToRead);
2182                 if (dataToRead == 0)
2183                         break;
2184                 /* ---------------------------------------------------------------
2185                         Move data read from our card into the line disciplines buffer
2186                         for translation if necessary.
2187                 ------------------------------------------------------------------ */
2188                 memcpy_fromio(rptr, ch->rxptr + tail, dataToRead);
2189                 tail = (tail + dataToRead) & wrapmask;
2190                 bytesAvailable -= dataToRead;
2191         } /* End while there is data on the card */
2192         globalwinon(ch);
2193         writew(tail, &bc->rout);
2194         /* Must be called with global data */
2195         tty_schedule_flip(ch->tty);
2196         return;
2197 } /* End receive_data */
2198
2199 static int info_ioctl(struct tty_struct *tty, struct file * file,
2200                     unsigned int cmd, unsigned long arg)
2201 {
2202         switch (cmd)
2203         { /* Begin switch cmd */
2204                 case DIGI_GETINFO:
2205                 { /* Begin case DIGI_GETINFO */
2206                         struct digi_info di ;
2207                         int brd;
2208
2209                         if(get_user(brd, (unsigned int __user *)arg))
2210                                 return -EFAULT;
2211                         if (brd < 0 || brd >= num_cards || num_cards == 0)
2212                                 return -ENODEV;
2213
2214                         memset(&di, 0, sizeof(di));
2215
2216                         di.board = brd ;
2217                         di.status = boards[brd].status;
2218                         di.type = boards[brd].type ;
2219                         di.numports = boards[brd].numports ;
2220                         /* Legacy fixups - just move along nothing to see */
2221                         di.port = (unsigned char *)boards[brd].port ;
2222                         di.membase = (unsigned char *)boards[brd].membase ;
2223
2224                         if (copy_to_user((void __user *)arg, &di, sizeof (di)))
2225                                 return -EFAULT;
2226                         break;
2227
2228                 } /* End case DIGI_GETINFO */
2229
2230                 case DIGI_POLLER:
2231                 { /* Begin case DIGI_POLLER */
2232
2233                         int brd = arg & 0xff000000 >> 16 ;
2234                         unsigned char state = arg & 0xff ;
2235
2236                         if (brd < 0 || brd >= num_cards) {
2237                                 printk(KERN_ERR "epca: DIGI POLLER : brd not valid!\n");
2238                                 return (-ENODEV);
2239                         }
2240                         digi_poller_inhibited = state ;
2241                         break ;
2242                 } /* End case DIGI_POLLER */
2243
2244                 case DIGI_INIT:
2245                 { /* Begin case DIGI_INIT */
2246                         /* ------------------------------------------------------------
2247                                 This call is made by the apps to complete the initilization
2248                                 of the board(s).  This routine is responsible for setting
2249                                 the card to its initial state and setting the drivers control
2250                                 fields to the sutianle settings for the card in question.
2251                         ---------------------------------------------------------------- */
2252                         int crd ;
2253                         for (crd = 0; crd < num_cards; crd++)
2254                                 post_fep_init (crd);
2255                         break ;
2256                 } /* End case DIGI_INIT */
2257                 default:
2258                         return -ENOTTY;
2259         } /* End switch cmd */
2260         return (0) ;
2261 }
2262 /* --------------------- Begin pc_ioctl  ----------------------- */
2263
2264 static int pc_tiocmget(struct tty_struct *tty, struct file *file)
2265 {
2266         struct channel *ch = (struct channel *) tty->driver_data;
2267         struct board_chan __iomem *bc;
2268         unsigned int mstat, mflag = 0;
2269         unsigned long flags;
2270
2271         if (ch)
2272                 bc = ch->brdchan;
2273         else
2274                 return -EINVAL;
2275
2276         spin_lock_irqsave(&epca_lock, flags);
2277         globalwinon(ch);
2278         mstat = readb(&bc->mstat);
2279         memoff(ch);
2280         spin_unlock_irqrestore(&epca_lock, flags);
2281
2282         if (mstat & ch->m_dtr)
2283                 mflag |= TIOCM_DTR;
2284         if (mstat & ch->m_rts)
2285                 mflag |= TIOCM_RTS;
2286         if (mstat & ch->m_cts)
2287                 mflag |= TIOCM_CTS;
2288         if (mstat & ch->dsr)
2289                 mflag |= TIOCM_DSR;
2290         if (mstat & ch->m_ri)
2291                 mflag |= TIOCM_RI;
2292         if (mstat & ch->dcd)
2293                 mflag |= TIOCM_CD;
2294         return mflag;
2295 }
2296
2297 static int pc_tiocmset(struct tty_struct *tty, struct file *file,
2298                        unsigned int set, unsigned int clear)
2299 {
2300         struct channel *ch = (struct channel *) tty->driver_data;
2301         unsigned long flags;
2302
2303         if (!ch)
2304                 return -EINVAL;
2305
2306         spin_lock_irqsave(&epca_lock, flags);
2307         /*
2308          * I think this modemfake stuff is broken.  It doesn't
2309          * correctly reflect the behaviour desired by the TIOCM*
2310          * ioctls.  Therefore this is probably broken.
2311          */
2312         if (set & TIOCM_RTS) {
2313                 ch->modemfake |= ch->m_rts;
2314                 ch->modem |= ch->m_rts;
2315         }
2316         if (set & TIOCM_DTR) {
2317                 ch->modemfake |= ch->m_dtr;
2318                 ch->modem |= ch->m_dtr;
2319         }
2320         if (clear & TIOCM_RTS) {
2321                 ch->modemfake |= ch->m_rts;
2322                 ch->modem &= ~ch->m_rts;
2323         }
2324         if (clear & TIOCM_DTR) {
2325                 ch->modemfake |= ch->m_dtr;
2326                 ch->modem &= ~ch->m_dtr;
2327         }
2328         globalwinon(ch);
2329         /*  --------------------------------------------------------------
2330                 The below routine generally sets up parity, baud, flow control
2331                 issues, etc.... It effect both control flags and input flags.
2332         ------------------------------------------------------------------ */
2333         epcaparam(tty,ch);
2334         memoff(ch);
2335         spin_unlock_irqrestore(&epca_lock, flags);
2336         return 0;
2337 }
2338
2339 static int pc_ioctl(struct tty_struct *tty, struct file * file,
2340                     unsigned int cmd, unsigned long arg)
2341 { /* Begin pc_ioctl */
2342
2343         digiflow_t dflow;
2344         int retval;
2345         unsigned long flags;
2346         unsigned int mflag, mstat;
2347         unsigned char startc, stopc;
2348         struct board_chan __iomem *bc;
2349         struct channel *ch = (struct channel *) tty->driver_data;
2350         void __user *argp = (void __user *)arg;
2351
2352         if (ch)
2353                 bc = ch->brdchan;
2354         else
2355                 return -EINVAL;
2356
2357         /* -------------------------------------------------------------------
2358                 For POSIX compliance we need to add more ioctls.  See tty_ioctl.c
2359                 in /usr/src/linux/drivers/char for a good example.  In particular
2360                 think about adding TCSETAF, TCSETAW, TCSETA, TCSETSF, TCSETSW, TCSETS.
2361         ---------------------------------------------------------------------- */
2362
2363         switch (cmd)
2364         { /* Begin switch cmd */
2365
2366                 case TCGETS:
2367                         if (copy_to_user(argp, tty->termios, sizeof(struct termios)))
2368                                 return -EFAULT;
2369                         return 0;
2370                 case TCGETA:
2371                         return get_termio(tty, argp);
2372                 case TCSBRK:    /* SVID version: non-zero arg --> no break */
2373                         retval = tty_check_change(tty);
2374                         if (retval)
2375                                 return retval;
2376                         /* Setup an event to indicate when the transmit buffer empties */
2377                         spin_lock_irqsave(&epca_lock, flags);
2378                         setup_empty_event(tty,ch);
2379                         spin_unlock_irqrestore(&epca_lock, flags);
2380                         tty_wait_until_sent(tty, 0);
2381                         if (!arg)
2382                                 digi_send_break(ch, HZ/4);    /* 1/4 second */
2383                         return 0;
2384                 case TCSBRKP:   /* support for POSIX tcsendbreak() */
2385                         retval = tty_check_change(tty);
2386                         if (retval)
2387                                 return retval;
2388
2389                         /* Setup an event to indicate when the transmit buffer empties */
2390                         spin_lock_irqsave(&epca_lock, flags);
2391                         setup_empty_event(tty,ch);
2392                         spin_unlock_irqrestore(&epca_lock, flags);
2393                         tty_wait_until_sent(tty, 0);
2394                         digi_send_break(ch, arg ? arg*(HZ/10) : HZ/4);
2395                         return 0;
2396                 case TIOCGSOFTCAR:
2397                         if (put_user(C_CLOCAL(tty)?1:0, (unsigned long __user *)arg))
2398                                 return -EFAULT;
2399                         return 0;
2400                 case TIOCSSOFTCAR:
2401                 {
2402                         unsigned int value;
2403
2404                         if (get_user(value, (unsigned __user *)argp))
2405                                 return -EFAULT;
2406                         tty->termios->c_cflag =
2407                                 ((tty->termios->c_cflag & ~CLOCAL) |
2408                                  (value ? CLOCAL : 0));
2409                         return 0;
2410                 }
2411                 case TIOCMODG:
2412                         mflag = pc_tiocmget(tty, file);
2413                         if (put_user(mflag, (unsigned long __user *)argp))
2414                                 return -EFAULT;
2415                         break;
2416                 case TIOCMODS:
2417                         if (get_user(mstat, (unsigned __user *)argp))
2418                                 return -EFAULT;
2419                         return pc_tiocmset(tty, file, mstat, ~mstat);
2420                 case TIOCSDTR:
2421                         spin_lock_irqsave(&epca_lock, flags);
2422                         ch->omodem |= ch->m_dtr;
2423                         globalwinon(ch);
2424                         fepcmd(ch, SETMODEM, ch->m_dtr, 0, 10, 1);
2425                         memoff(ch);
2426                         spin_unlock_irqrestore(&epca_lock, flags);
2427                         break;
2428
2429                 case TIOCCDTR:
2430                         spin_lock_irqsave(&epca_lock, flags);
2431                         ch->omodem &= ~ch->m_dtr;
2432                         globalwinon(ch);
2433                         fepcmd(ch, SETMODEM, 0, ch->m_dtr, 10, 1);
2434                         memoff(ch);
2435                         spin_unlock_irqrestore(&epca_lock, flags);
2436                         break;
2437                 case DIGI_GETA:
2438                         if (copy_to_user(argp, &ch->digiext, sizeof(digi_t)))
2439                                 return -EFAULT;
2440                         break;
2441                 case DIGI_SETAW:
2442                 case DIGI_SETAF:
2443                         if (cmd == DIGI_SETAW) {
2444                                 /* Setup an event to indicate when the transmit buffer empties */
2445                                 spin_lock_irqsave(&epca_lock, flags);
2446                                 setup_empty_event(tty,ch);
2447                                 spin_unlock_irqrestore(&epca_lock, flags);
2448                                 tty_wait_until_sent(tty, 0);
2449                         } else  {
2450                                 /* ldisc lock already held in ioctl */
2451                                 if (tty->ldisc.flush_buffer)
2452                                         tty->ldisc.flush_buffer(tty);
2453                         }
2454                         /* Fall Thru */
2455                 case DIGI_SETA:
2456                         if (copy_from_user(&ch->digiext, argp, sizeof(digi_t)))
2457                                 return -EFAULT;
2458
2459                         if (ch->digiext.digi_flags & DIGI_ALTPIN)  {
2460                                 ch->dcd = ch->m_dsr;
2461                                 ch->dsr = ch->m_dcd;
2462                         } else {
2463                                 ch->dcd = ch->m_dcd;
2464                                 ch->dsr = ch->m_dsr;
2465                         }
2466
2467                         spin_lock_irqsave(&epca_lock, flags);
2468                         globalwinon(ch);
2469
2470                         /* -----------------------------------------------------------------
2471                                 The below routine generally sets up parity, baud, flow control
2472                                 issues, etc.... It effect both control flags and input flags.
2473                         ------------------------------------------------------------------- */
2474
2475                         epcaparam(tty,ch);
2476                         memoff(ch);
2477                         spin_unlock_irqrestore(&epca_lock, flags);
2478                         break;
2479
2480                 case DIGI_GETFLOW:
2481                 case DIGI_GETAFLOW:
2482                         spin_lock_irqsave(&epca_lock, flags);
2483                         globalwinon(ch);
2484                         if (cmd == DIGI_GETFLOW) {
2485                                 dflow.startc = readb(&bc->startc);
2486                                 dflow.stopc = readb(&bc->stopc);
2487                         } else {
2488                                 dflow.startc = readb(&bc->startca);
2489                                 dflow.stopc = readb(&bc->stopca);
2490                         }
2491                         memoff(ch);
2492                         spin_unlock_irqrestore(&epca_lock, flags);
2493
2494                         if (copy_to_user(argp, &dflow, sizeof(dflow)))
2495                                 return -EFAULT;
2496                         break;
2497
2498                 case DIGI_SETAFLOW:
2499                 case DIGI_SETFLOW:
2500                         if (cmd == DIGI_SETFLOW) {
2501                                 startc = ch->startc;
2502                                 stopc = ch->stopc;
2503                         } else {
2504                                 startc = ch->startca;
2505                                 stopc = ch->stopca;
2506                         }
2507
2508                         if (copy_from_user(&dflow, argp, sizeof(dflow)))
2509                                 return -EFAULT;
2510
2511                         if (dflow.startc != startc || dflow.stopc != stopc) { /* Begin  if setflow toggled */
2512                                 spin_lock_irqsave(&epca_lock, flags);
2513                                 globalwinon(ch);
2514
2515                                 if (cmd == DIGI_SETFLOW) {
2516                                         ch->fepstartc = ch->startc = dflow.startc;
2517                                         ch->fepstopc = ch->stopc = dflow.stopc;
2518                                         fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
2519                                 } else {
2520                                         ch->fepstartca = ch->startca = dflow.startc;
2521                                         ch->fepstopca  = ch->stopca = dflow.stopc;
2522                                         fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
2523                                 }
2524
2525                                 if (ch->statusflags & TXSTOPPED)
2526                                         pc_start(tty);
2527
2528                                 memoff(ch);
2529                                 spin_unlock_irqrestore(&epca_lock, flags);
2530                         } /* End if setflow toggled */
2531                         break;
2532                 default:
2533                         return -ENOIOCTLCMD;
2534         } /* End switch cmd */
2535         return 0;
2536 } /* End pc_ioctl */
2537
2538 /* --------------------- Begin pc_set_termios  ----------------------- */
2539
2540 static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
2541 { /* Begin pc_set_termios */
2542
2543         struct channel *ch;
2544         unsigned long flags;
2545         /* ---------------------------------------------------------
2546                 verifyChannel returns the channel from the tty struct
2547                 if it is valid.  This serves as a sanity check.
2548         ------------------------------------------------------------- */
2549         if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
2550                 spin_lock_irqsave(&epca_lock, flags);
2551                 globalwinon(ch);
2552                 epcaparam(tty, ch);
2553                 memoff(ch);
2554                 spin_unlock_irqrestore(&epca_lock, flags);
2555
2556                 if ((old_termios->c_cflag & CRTSCTS) &&
2557                          ((tty->termios->c_cflag & CRTSCTS) == 0))
2558                         tty->hw_stopped = 0;
2559
2560                 if (!(old_termios->c_cflag & CLOCAL) &&
2561                          (tty->termios->c_cflag & CLOCAL))
2562                         wake_up_interruptible(&ch->open_wait);
2563
2564         } /* End if channel valid */
2565
2566 } /* End pc_set_termios */
2567
2568 /* --------------------- Begin do_softint  ----------------------- */
2569
2570 static void do_softint(void *private_)
2571 { /* Begin do_softint */
2572         struct channel *ch = (struct channel *) private_;
2573         /* Called in response to a modem change event */
2574         if (ch && ch->magic == EPCA_MAGIC)  { /* Begin EPCA_MAGIC */
2575                 struct tty_struct *tty = ch->tty;
2576
2577                 if (tty && tty->driver_data) {
2578                         if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) { /* Begin if clear_bit */
2579                                 tty_hangup(tty);        /* FIXME: module removal race here - AKPM */
2580                                 wake_up_interruptible(&ch->open_wait);
2581                                 ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
2582                         } /* End if clear_bit */
2583                 }
2584         } /* End EPCA_MAGIC */
2585 } /* End do_softint */
2586
2587 /* ------------------------------------------------------------
2588         pc_stop and pc_start provide software flow control to the
2589         routine and the pc_ioctl routine.
2590 ---------------------------------------------------------------- */
2591
2592 /* --------------------- Begin pc_stop  ----------------------- */
2593
2594 static void pc_stop(struct tty_struct *tty)
2595 { /* Begin pc_stop */
2596
2597         struct channel *ch;
2598         unsigned long flags;
2599         /* ---------------------------------------------------------
2600                 verifyChannel returns the channel from the tty struct
2601                 if it is valid.  This serves as a sanity check.
2602         ------------------------------------------------------------- */
2603         if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if valid channel */
2604                 spin_lock_irqsave(&epca_lock, flags);
2605                 if ((ch->statusflags & TXSTOPPED) == 0)  { /* Begin if transmit stop requested */
2606                         globalwinon(ch);
2607                         /* STOP transmitting now !! */
2608                         fepcmd(ch, PAUSETX, 0, 0, 0, 0);
2609                         ch->statusflags |= TXSTOPPED;
2610                         memoff(ch);
2611                 } /* End if transmit stop requested */
2612                 spin_unlock_irqrestore(&epca_lock, flags);
2613         } /* End if valid channel */
2614 } /* End pc_stop */
2615
2616 /* --------------------- Begin pc_start  ----------------------- */
2617
2618 static void pc_start(struct tty_struct *tty)
2619 { /* Begin pc_start */
2620         struct channel *ch;
2621         /* ---------------------------------------------------------
2622                 verifyChannel returns the channel from the tty struct
2623                 if it is valid.  This serves as a sanity check.
2624         ------------------------------------------------------------- */
2625         if ((ch = verifyChannel(tty)) != NULL) { /* Begin if channel valid */
2626                 unsigned long flags;
2627                 spin_lock_irqsave(&epca_lock, flags);
2628                 /* Just in case output was resumed because of a change in Digi-flow */
2629                 if (ch->statusflags & TXSTOPPED)  { /* Begin transmit resume requested */
2630                         struct board_chan __iomem *bc;
2631                         globalwinon(ch);
2632                         bc = ch->brdchan;
2633                         if (ch->statusflags & LOWWAIT)
2634                                 writeb(1, &bc->ilow);
2635                         /* Okay, you can start transmitting again... */
2636                         fepcmd(ch, RESUMETX, 0, 0, 0, 0);
2637                         ch->statusflags &= ~TXSTOPPED;
2638                         memoff(ch);
2639                 } /* End transmit resume requested */
2640                 spin_unlock_irqrestore(&epca_lock, flags);
2641         } /* End if channel valid */
2642 } /* End pc_start */
2643
2644 /* ------------------------------------------------------------------
2645         The below routines pc_throttle and pc_unthrottle are used
2646         to slow (And resume) the receipt of data into the kernels
2647         receive buffers.  The exact occurrence of this depends on the
2648         size of the kernels receive buffer and what the 'watermarks'
2649         are set to for that buffer.  See the n_ttys.c file for more
2650         details.
2651 ______________________________________________________________________ */
2652 /* --------------------- Begin throttle  ----------------------- */
2653
2654 static void pc_throttle(struct tty_struct * tty)
2655 { /* Begin pc_throttle */
2656         struct channel *ch;
2657         unsigned long flags;
2658         /* ---------------------------------------------------------
2659                 verifyChannel returns the channel from the tty struct
2660                 if it is valid.  This serves as a sanity check.
2661         ------------------------------------------------------------- */
2662         if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
2663                 spin_lock_irqsave(&epca_lock, flags);
2664                 if ((ch->statusflags & RXSTOPPED) == 0) {
2665                         globalwinon(ch);
2666                         fepcmd(ch, PAUSERX, 0, 0, 0, 0);
2667                         ch->statusflags |= RXSTOPPED;
2668                         memoff(ch);
2669                 }
2670                 spin_unlock_irqrestore(&epca_lock, flags);
2671         } /* End if channel valid */
2672 } /* End pc_throttle */
2673
2674 /* --------------------- Begin unthrottle  ----------------------- */
2675
2676 static void pc_unthrottle(struct tty_struct *tty)
2677 { /* Begin pc_unthrottle */
2678         struct channel *ch;
2679         unsigned long flags;
2680         /* ---------------------------------------------------------
2681                 verifyChannel returns the channel from the tty struct
2682                 if it is valid.  This serves as a sanity check.
2683         ------------------------------------------------------------- */
2684         if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
2685                 /* Just in case output was resumed because of a change in Digi-flow */
2686                 spin_lock_irqsave(&epca_lock, flags);
2687                 if (ch->statusflags & RXSTOPPED) {
2688                         globalwinon(ch);
2689                         fepcmd(ch, RESUMERX, 0, 0, 0, 0);
2690                         ch->statusflags &= ~RXSTOPPED;
2691                         memoff(ch);
2692                 }
2693                 spin_unlock_irqrestore(&epca_lock, flags);
2694         } /* End if channel valid */
2695 } /* End pc_unthrottle */
2696
2697 /* --------------------- Begin digi_send_break  ----------------------- */
2698
2699 void digi_send_break(struct channel *ch, int msec)
2700 { /* Begin digi_send_break */
2701         unsigned long flags;
2702
2703         spin_lock_irqsave(&epca_lock, flags);
2704         globalwinon(ch);
2705         /* --------------------------------------------------------------------
2706            Maybe I should send an infinite break here, schedule() for
2707            msec amount of time, and then stop the break.  This way,
2708            the user can't screw up the FEP by causing digi_send_break()
2709            to be called (i.e. via an ioctl()) more than once in msec amount
2710            of time.  Try this for now...
2711         ------------------------------------------------------------------------ */
2712         fepcmd(ch, SENDBREAK, msec, 0, 10, 0);
2713         memoff(ch);
2714         spin_unlock_irqrestore(&epca_lock, flags);
2715 } /* End digi_send_break */
2716
2717 /* --------------------- Begin setup_empty_event  ----------------------- */
2718
2719 /* Caller MUST hold the lock */
2720
2721 static void setup_empty_event(struct tty_struct *tty, struct channel *ch)
2722 { /* Begin setup_empty_event */
2723
2724         struct board_chan __iomem *bc = ch->brdchan;
2725
2726         globalwinon(ch);
2727         ch->statusflags |= EMPTYWAIT;
2728         /* ------------------------------------------------------------------
2729                 When set the iempty flag request a event to be generated when the
2730                 transmit buffer is empty (If there is no BREAK in progress).
2731         --------------------------------------------------------------------- */
2732         writeb(1, &bc->iempty);
2733         memoff(ch);
2734 } /* End setup_empty_event */
2735
2736 /* --------------------- Begin get_termio ----------------------- */
2737
2738 static int get_termio(struct tty_struct * tty, struct termio __user * termio)
2739 { /* Begin get_termio */
2740         return kernel_termios_to_user_termio(termio, tty->termios);
2741 } /* End get_termio */
2742
2743 /* ---------------------- Begin epca_setup  -------------------------- */
2744 void epca_setup(char *str, int *ints)
2745 { /* Begin epca_setup */
2746         struct board_info board;
2747         int               index, loop, last;
2748         char              *temp, *t2;
2749         unsigned          len;
2750
2751         /* ----------------------------------------------------------------------
2752                 If this routine looks a little strange it is because it is only called
2753                 if a LILO append command is given to boot the kernel with parameters.
2754                 In this way, we can provide the user a method of changing his board
2755                 configuration without rebuilding the kernel.
2756         ----------------------------------------------------------------------- */
2757         if (!liloconfig)
2758                 liloconfig = 1;
2759
2760         memset(&board, 0, sizeof(board));
2761
2762         /* Assume the data is int first, later we can change it */
2763         /* I think that array position 0 of ints holds the number of args */
2764         for (last = 0, index = 1; index <= ints[0]; index++)
2765                 switch(index)
2766                 { /* Begin parse switch */
2767                         case 1:
2768                                 board.status = ints[index];
2769                                 /* ---------------------------------------------------------
2770                                         We check for 2 (As opposed to 1; because 2 is a flag
2771                                         instructing the driver to ignore epcaconfig.)  For this
2772                                         reason we check for 2.
2773                                 ------------------------------------------------------------ */
2774                                 if (board.status == 2) { /* Begin ignore epcaconfig as well as lilo cmd line */
2775                                         nbdevs = 0;
2776                                         num_cards = 0;
2777                                         return;
2778                                 } /* End ignore epcaconfig as well as lilo cmd line */
2779
2780                                 if (board.status > 2) {
2781                                         printk(KERN_ERR "epca_setup: Invalid board status 0x%x\n", board.status);
2782                                         invalid_lilo_config = 1;
2783                                         setup_error_code |= INVALID_BOARD_STATUS;
2784                                         return;
2785                                 }
2786                                 last = index;
2787                                 break;
2788                         case 2:
2789                                 board.type = ints[index];
2790                                 if (board.type >= PCIXEM)  {
2791                                         printk(KERN_ERR "epca_setup: Invalid board type 0x%x\n", board.type);
2792                                         invalid_lilo_config = 1;
2793                                         setup_error_code |= INVALID_BOARD_TYPE;
2794                                         return;
2795                                 }
2796                                 last = index;
2797                                 break;
2798                         case 3:
2799                                 board.altpin = ints[index];
2800                                 if (board.altpin > 1) {
2801                                         printk(KERN_ERR "epca_setup: Invalid board altpin 0x%x\n", board.altpin);
2802                                         invalid_lilo_config = 1;
2803                                         setup_error_code |= INVALID_ALTPIN;
2804                                         return;
2805                                 }
2806                                 last = index;
2807                                 break;
2808
2809                         case 4:
2810                                 board.numports = ints[index];
2811                                 if (board.numports < 2 || board.numports > 256) {
2812                                         printk(KERN_ERR "epca_setup: Invalid board numports 0x%x\n", board.numports);
2813                                         invalid_lilo_config = 1;
2814                                         setup_error_code |= INVALID_NUM_PORTS;
2815                                         return;
2816                                 }
2817                                 nbdevs += board.numports;
2818                                 last = index;
2819                                 break;
2820
2821                         case 5:
2822                                 board.port = ints[index];
2823                                 if (ints[index] <= 0) {
2824                                         printk(KERN_ERR "epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
2825                                         invalid_lilo_config = 1;
2826                                         setup_error_code |= INVALID_PORT_BASE;
2827                                         return;
2828                                 }
2829                                 last = index;
2830                                 break;
2831
2832                         case 6:
2833                                 board.membase = ints[index];
2834                                 if (ints[index] <= 0) {
2835                                         printk(KERN_ERR "epca_setup: Invalid memory base 0x%x\n",(unsigned int)board.membase);
2836                                         invalid_lilo_config = 1;
2837                                         setup_error_code |= INVALID_MEM_BASE;
2838                                         return;
2839                                 }
2840                                 last = index;
2841                                 break;
2842
2843                         default:
2844                                 printk(KERN_ERR "<Error> - epca_setup: Too many integer parms\n");
2845                                 return;
2846
2847                 } /* End parse switch */
2848
2849         while (str && *str)  { /* Begin while there is a string arg */
2850                 /* find the next comma or terminator */
2851                 temp = str;
2852                 /* While string is not null, and a comma hasn't been found */
2853                 while (*temp && (*temp != ','))
2854                         temp++;
2855                 if (!*temp)
2856                         temp = NULL;
2857                 else
2858                         *temp++ = 0;
2859                 /* Set index to the number of args + 1 */
2860                 index = last + 1;
2861
2862                 switch(index)
2863                 {
2864                         case 1:
2865                                 len = strlen(str);
2866                                 if (strncmp("Disable", str, len) == 0)
2867                                         board.status = 0;
2868                                 else if (strncmp("Enable", str, len) == 0)
2869                                         board.status = 1;
2870                                 else {
2871                                         printk(KERN_ERR "epca_setup: Invalid status %s\n", str);
2872                                         invalid_lilo_config = 1;
2873                                         setup_error_code |= INVALID_BOARD_STATUS;
2874                                         return;
2875                                 }
2876                                 last = index;
2877                                 break;
2878
2879                         case 2:
2880                                 for(loop = 0; loop < EPCA_NUM_TYPES; loop++)
2881                                         if (strcmp(board_desc[loop], str) == 0)
2882                                                 break;
2883                                 /* ---------------------------------------------------------------
2884                                         If the index incremented above refers to a legitamate board
2885                                         type set it here.
2886                                 ------------------------------------------------------------------*/
2887                                 if (index < EPCA_NUM_TYPES)
2888                                         board.type = loop;
2889                                 else {
2890                                         printk(KERN_ERR "epca_setup: Invalid board type: %s\n", str);
2891                                         invalid_lilo_config = 1;
2892                                         setup_error_code |= INVALID_BOARD_TYPE;
2893                                         return;
2894                                 }
2895                                 last = index;
2896                                 break;
2897
2898                         case 3:
2899                                 len = strlen(str);
2900                                 if (strncmp("Disable", str, len) == 0)
2901                                         board.altpin = 0;
2902                                 else if (strncmp("Enable", str, len) == 0)
2903                                         board.altpin = 1;
2904                                 else {
2905                                         printk(KERN_ERR "epca_setup: Invalid altpin %s\n", str);
2906                                         invalid_lilo_config = 1;
2907                                         setup_error_code |= INVALID_ALTPIN;
2908                                         return;
2909                                 }
2910                                 last = index;
2911                                 break;
2912
2913                         case 4:
2914                                 t2 = str;
2915                                 while (isdigit(*t2))
2916                                         t2++;
2917
2918                                 if (*t2) {
2919                                         printk(KERN_ERR "epca_setup: Invalid port count %s\n", str);
2920                                         invalid_lilo_config = 1;
2921                                         setup_error_code |= INVALID_NUM_PORTS;
2922                                         return;
2923                                 }
2924
2925                                 /* ------------------------------------------------------------
2926                                         There is not a man page for simple_strtoul but the code can be
2927                                         found in vsprintf.c.  The first argument is the string to
2928                                         translate (To an unsigned long obviously),  the second argument
2929                                         can be the address of any character variable or a NULL.  If a
2930                                         variable is given, the end pointer of the string will be stored
2931                                         in that variable; if a NULL is given the end pointer will
2932                                         not be returned.  The last argument is the base to use.  If
2933                                         a 0 is indicated, the routine will attempt to determine the
2934                                         proper base by looking at the values prefix (A '0' for octal,
2935                                         a 'x' for hex, etc ...  If a value is given it will use that
2936                                         value as the base.
2937                                 ---------------------------------------------------------------- */
2938                                 board.numports = simple_strtoul(str, NULL, 0);
2939                                 nbdevs += board.numports;
2940                                 last = index;
2941                                 break;
2942
2943                         case 5:
2944                                 t2 = str;
2945                                 while (isxdigit(*t2))
2946                                         t2++;
2947
2948                                 if (*t2) {
2949                                         printk(KERN_ERR "epca_setup: Invalid i/o address %s\n", str);
2950                                         invalid_lilo_config = 1;
2951                                         setup_error_code |= INVALID_PORT_BASE;
2952                                         return;
2953                                 }
2954
2955                                 board.port = simple_strtoul(str, NULL, 16);
2956                                 last = index;
2957                                 break;
2958
2959                         case 6:
2960                                 t2 = str;
2961                                 while (isxdigit(*t2))
2962                                         t2++;
2963
2964                                 if (*t2) {
2965                                         printk(KERN_ERR "epca_setup: Invalid memory base %s\n",str);
2966                                         invalid_lilo_config = 1;
2967                                         setup_error_code |= INVALID_MEM_BASE;
2968                                         return;
2969                                 }
2970                                 board.membase = simple_strtoul(str, NULL, 16);
2971                                 last = index;
2972                                 break;
2973                         default:
2974                                 printk(KERN_ERR "epca: Too many string parms\n");
2975                                 return;
2976                 }
2977                 str = temp;
2978         } /* End while there is a string arg */
2979
2980         if (last < 6) {
2981                 printk(KERN_ERR "epca: Insufficient parms specified\n");
2982                 return;
2983         }
2984
2985         /* I should REALLY validate the stuff here */
2986         /* Copies our local copy of board into boards */
2987         memcpy((void *)&boards[num_cards],(void *)&board, sizeof(board));
2988         /* Does this get called once per lilo arg are what ? */
2989         printk(KERN_INFO "PC/Xx: Added board %i, %s %i ports at 0x%4.4X base 0x%6.6X\n",
2990                 num_cards, board_desc[board.type],
2991                 board.numports, (int)board.port, (unsigned int) board.membase);
2992         num_cards++;
2993 } /* End epca_setup */
2994
2995
2996 /* ------------------------ Begin init_PCI  --------------------------- */
2997
2998 enum epic_board_types {
2999         brd_xr = 0,
3000         brd_xem,
3001         brd_cx,
3002         brd_xrj,
3003 };
3004
3005
3006 /* indexed directly by epic_board_types enum */
3007 static struct {
3008         unsigned char board_type;
3009         unsigned bar_idx;               /* PCI base address region */
3010 } epca_info_tbl[] = {
3011         { PCIXR, 0, },
3012         { PCIXEM, 0, },
3013         { PCICX, 0, },
3014         { PCIXRJ, 2, },
3015 };
3016
3017 static int __devinit epca_init_one (struct pci_dev *pdev,
3018                                  const struct pci_device_id *ent)
3019 {
3020         static int board_num = -1;
3021         int board_idx, info_idx = ent->driver_data;
3022         unsigned long addr;
3023
3024         if (pci_enable_device(pdev))
3025                 return -EIO;
3026
3027         board_num++;
3028         board_idx = board_num + num_cards;
3029         if (board_idx >= MAXBOARDS)
3030                 goto err_out;
3031
3032         addr = pci_resource_start (pdev, epca_info_tbl[info_idx].bar_idx);
3033         if (!addr) {
3034                 printk (KERN_ERR PFX "PCI region #%d not available (size 0)\n",
3035                         epca_info_tbl[info_idx].bar_idx);
3036                 goto err_out;
3037         }
3038
3039         boards[board_idx].status = ENABLED;
3040         boards[board_idx].type = epca_info_tbl[info_idx].board_type;
3041         boards[board_idx].numports = 0x0;
3042         boards[board_idx].port = addr + PCI_IO_OFFSET;
3043         boards[board_idx].membase = addr;
3044
3045         if (!request_mem_region (addr + PCI_IO_OFFSET, 0x200000, "epca")) {
3046                 printk (KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
3047                         0x200000, addr + PCI_IO_OFFSET);
3048                 goto err_out;
3049         }
3050
3051         boards[board_idx].re_map_port = ioremap(addr + PCI_IO_OFFSET, 0x200000);
3052         if (!boards[board_idx].re_map_port) {
3053                 printk (KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
3054                         0x200000, addr + PCI_IO_OFFSET);
3055                 goto err_out_free_pciio;
3056         }
3057
3058         if (!request_mem_region (addr, 0x200000, "epca")) {
3059                 printk (KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
3060                         0x200000, addr);
3061                 goto err_out_free_iounmap;
3062         }
3063
3064         boards[board_idx].re_map_membase = ioremap(addr, 0x200000);
3065         if (!boards[board_idx].re_map_membase) {
3066                 printk (KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
3067                         0x200000, addr + PCI_IO_OFFSET);
3068                 goto err_out_free_memregion;
3069         }
3070
3071         /* --------------------------------------------------------------
3072                 I don't know what the below does, but the hardware guys say
3073                 its required on everything except PLX (In this case XRJ).
3074         ---------------------------------------------------------------- */
3075         if (info_idx != brd_xrj) {
3076                 pci_write_config_byte(pdev, 0x40, 0);
3077                 pci_write_config_byte(pdev, 0x46, 0);
3078         }
3079
3080         return 0;
3081
3082 err_out_free_memregion:
3083         release_mem_region (addr, 0x200000);
3084 err_out_free_iounmap:
3085         iounmap (boards[board_idx].re_map_port);
3086 err_out_free_pciio:
3087         release_mem_region (addr + PCI_IO_OFFSET, 0x200000);
3088 err_out:
3089         return -ENODEV;
3090 }
3091
3092
3093 static struct pci_device_id epca_pci_tbl[] = {
3094         { PCI_VENDOR_DIGI, PCI_DEVICE_XR, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xr },
3095         { PCI_VENDOR_DIGI, PCI_DEVICE_XEM, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xem },
3096         { PCI_VENDOR_DIGI, PCI_DEVICE_CX, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_cx },
3097         { PCI_VENDOR_DIGI, PCI_DEVICE_XRJ, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xrj },
3098         { 0, }
3099 };
3100
3101 MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
3102
3103 int __init init_PCI (void)
3104 {       /* Begin init_PCI */
3105         memset (&epca_driver, 0, sizeof (epca_driver));
3106         epca_driver.name = "epca";
3107         epca_driver.id_table = epca_pci_tbl;
3108         epca_driver.probe = epca_init_one;
3109
3110         return pci_register_driver(&epca_driver);
3111 }
3112
3113 MODULE_LICENSE("GPL");