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