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